diff --git a/.clang-format b/.clang-format deleted file mode 100644 index 3cdca3d53..000000000 --- a/.clang-format +++ /dev/null @@ -1,90 +0,0 @@ -BasedOnStyle: Mozilla - -AccessModifierOffset: '-4' -AlignAfterOpenBracket: BlockIndent -AlignEscapedNewlines: Left -AllowAllArgumentsOnNextLine: false -AllowAllParametersOfDeclarationOnNextLine: false -AllowShortBlocksOnASingleLine: false -AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: false -AllowShortIfStatementsOnASingleLine: false -# Forbid one line lambdas because clang-format makes a weird split when -# single instructions lambdas are too long. -AllowShortLambdasOnASingleLine: Empty -AllowShortLoopsOnASingleLine: false -AlwaysBreakAfterDefinitionReturnType: None -AlwaysBreakAfterReturnType: None -AlwaysBreakTemplateDeclarations: Yes -BinPackArguments: false -BinPackParameters: false -BreakBeforeBinaryOperators: NonAssignment -BreakBeforeBraces: Allman -BreakBeforeTernaryOperators: true -BreakConstructorInitializers: BeforeComma -BreakInheritanceList: AfterComma -BreakStringLiterals: false -ColumnLimit: '110' -ConstructorInitializerIndentWidth: '4' -ContinuationIndentWidth: '4' -Cpp11BracedListStyle: true -DerivePointerAlignment: false -DisableFormat: false -EmptyLineAfterAccessModifier: Always -EmptyLineBeforeAccessModifier: Always -ExperimentalAutoDetectBinPacking: true -IncludeBlocks: Regroup -IncludeCategories: -- Regex: <[^.]+> - Priority: 1 -- Regex: - Priority: 3 -- Regex: <.+> - Priority: 2 -- Regex: '"xtensor/.+"' - Priority: 4 -- Regex: '".+"' - Priority: 5 -IndentCaseLabels: true -IndentWidth: '4' -IndentWrappedFunctionNames: false -InsertBraces: true -InsertTrailingCommas: Wrapped -KeepEmptyLinesAtTheStartOfBlocks: false -LambdaBodyIndentation: Signature -Language: Cpp -MaxEmptyLinesToKeep: '2' -NamespaceIndentation: All -ObjCBlockIndentWidth: '4' -ObjCSpaceAfterProperty: false -ObjCSpaceBeforeProtocolList: false -PackConstructorInitializers: Never -PenaltyBreakAssignment: 100000 -PenaltyBreakBeforeFirstCallParameter: 0 -PenaltyBreakComment: 10 -PenaltyBreakOpenParenthesis: 0 -PenaltyBreakTemplateDeclaration: 0 -PenaltyExcessCharacter: 10 -PenaltyIndentedWhitespace: 0 -PenaltyReturnTypeOnItsOwnLine: 10 -PointerAlignment: Left -QualifierAlignment: Custom # Experimental -QualifierOrder: [inline, static, constexpr, const, volatile, type] -ReflowComments: true -SeparateDefinitionBlocks: Always -SortIncludes: CaseInsensitive -SortUsingDeclarations: true -SpaceAfterCStyleCast: true -SpaceAfterTemplateKeyword: true -SpaceBeforeAssignmentOperators: true -SpaceBeforeParens: ControlStatements -SpaceInEmptyParentheses: false -SpacesBeforeTrailingComments: '2' -SpacesInAngles: false -SpacesInCStyleCastParentheses: false -SpacesInContainerLiterals: false -SpacesInParentheses: false -SpacesInSquareBrackets: false -Standard: c++20 -TabWidth: '4' -UseTab: Never diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md deleted file mode 100644 index 3de597778..000000000 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ /dev/null @@ -1,13 +0,0 @@ -# Checklist - -- [ ] The title and commit message(s) are descriptive. -- [ ] Small commits made to fix your PR have been squashed to avoid history pollution. -- [ ] Tests have been added for new features or bug fixes. -- [ ] API of new functions and classes are documented. - -# Description - - diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml deleted file mode 100644 index 9ec6f8f33..000000000 --- a/.github/workflows/benchmarks.yml +++ /dev/null @@ -1,73 +0,0 @@ -name: benchmarks -on: - workflow_dispatch: - pull_request: - push: - branches: [master] -concurrency: - group: ${{ github.workflow }}-${{ github.job }}-${{ github.ref }} - cancel-in-progress: true -defaults: - run: - shell: bash -e -l {0} -jobs: - build: - runs-on: ubuntu-24.04 - name: ${{ matrix.sys.compiler }} ${{ matrix.sys.version }} - ${{ matrix.sys.name }} - strategy: - fail-fast: false - matrix: - sys: - - {compiler: clang, version: '20', name: xsimd, flags: -DXTENSOR_USE_XSIMD=ON} - - {compiler: clang, version: '20', name: xsimd-tbb, flags: -DXTENSOR_USE_XSIMD=ON -DXTENSOR_USE_TBB=ON} - - {compiler: gcc, version: '14', name: xsimd, flags: -DXTENSOR_USE_XSIMD=ON} - - {compiler: gcc, version: '14', name: xsimd-tbb, flags: -DXTENSOR_USE_XSIMD=ON -DXTENSOR_USE_TBB=ON} - - steps: - - name: Install GCC - if: matrix.sys.compiler == 'gcc' - uses: egor-tensin/setup-gcc@v1 - with: - version: ${{matrix.sys.version}} - platform: x64 - - - name: Install LLVM and Clang - if: matrix.sys.compiler == 'clang' - run: | - wget https://apt.llvm.org/llvm.sh - chmod +x llvm.sh - sudo ./llvm.sh ${{matrix.sys.version}} - sudo apt-get install -y clang-tools-${{matrix.sys.version}} - sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-${{matrix.sys.version}} 200 - sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-${{matrix.sys.version}} 200 - sudo update-alternatives --install /usr/bin/clang-scan-deps clang-scan-deps /usr/bin/clang-scan-deps-${{matrix.sys.version}} 200 - sudo update-alternatives --set clang /usr/bin/clang-${{matrix.sys.version}} - sudo update-alternatives --set clang++ /usr/bin/clang++-${{matrix.sys.version}} - sudo update-alternatives --set clang-scan-deps /usr/bin/clang-scan-deps-${{matrix.sys.version}} - - - name: Checkout code - uses: actions/checkout@v3 - - - name: Set conda environment - uses: mamba-org/setup-micromamba@main - with: - environment-name: myenv - environment-file: environment-dev.yml - init-shell: bash - cache-downloads: true - create-args: | - ${{ (matrix.sys.name == 'tbb' || matrix.sys.name == 'xsimd-tbb' ) && 'tbb-devel' || '' }} - - - name: Configure using CMake - run: | - if [[ "${{matrix.sys.compiler}}" = "gcc" ]]; then export CC=gcc-${{matrix.sys.version}}; export CXX=g++-${{matrix.sys.version}}; else export CC=clang; export CXX=clang++; fi - cmake -G Ninja -Bbuild -DCMAKE_C_COMPILER=$CC -DCMAKE_CXX_COMPILER=$CXX -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -DBUILD_BENCHMARK=ON ${{ matrix.sys.flags }} - - - name: Build - working-directory: build - run: cmake --build . --target benchmark_xtensor --parallel 8 - - - name: Run benchmark - timeout-minutes: 10 # Consider increasing timeout - working-directory: build/benchmark - run: ./benchmark_xtensor diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml deleted file mode 100644 index f86b5256a..000000000 --- a/.github/workflows/gh-pages.yml +++ /dev/null @@ -1,48 +0,0 @@ -name: gh-pages - -on: - push: - branches: - - master - -defaults: - run: - shell: bash -l {0} - -jobs: - - publish: - - runs-on: ubuntu-latest - - defaults: - run: - shell: bash -l {0} - - steps: - - - name: Basic GitHub action setup - uses: actions/checkout@v2 - - - name: Set mamba environment - uses: mamba-org/setup-micromamba@main - with: - environment-file: docs/ghp_environment.yml - environment-name: xtensor-doc - init-shell: bash - cache-downloads: true - - - name: Run doxygen - working-directory: docs - run: doxygen - - - name: Deploy to GitHub Pages - if: success() - uses: crazy-max/ghaction-github-pages@v2 - with: - target_branch: gh-pages - build_dir: docs/html - jekyll: false - keep_history: false - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/issue-close.yml b/.github/workflows/issue-close.yml deleted file mode 100644 index 7156c375c..000000000 --- a/.github/workflows/issue-close.yml +++ /dev/null @@ -1,33 +0,0 @@ -name: Close inactive issues and PRs -on: - schedule: - - cron: 30 1 * * * - -jobs: - close-issues: - runs-on: ubuntu-latest - permissions: - issues: write - pull-requests: write - steps: - - uses: actions/stale@v8 - with: - any-of-issue-labels: Needs clarification, Answered, Stale? - days-before-issue-stale: 30 - days-before-issue-close: 14 - stale-issue-label: Stale - stale-issue-message: | - This issue is stale because it has been open for 30 days with no activity. - It will be automatically closed in 14 days. - close-issue-message: | - This issue was closed because it has been inactive for 14 days since being marked as stale. - any-of-pr-labels: Needs clarification, Answered, Needs revision, Stale? - days-before-pr-stale: 60 - days-before-pr-close: 14 - stale-pr-label: Stale - stale-pr-message: | - This pr is stale because it has been open for 60 days with no activity. - It will be automatically closed in 14 days. - close-pr-message: | - This issue was closed because it has been inactive for 14 days since being marked as stale. - repo-token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml deleted file mode 100644 index a4de87fb8..000000000 --- a/.github/workflows/linux.yml +++ /dev/null @@ -1,83 +0,0 @@ -name: Linux -on: - workflow_dispatch: - pull_request: - push: - branches: [master] -concurrency: - group: ${{ github.workflow }}-${{ github.job }}-${{ github.ref }} - cancel-in-progress: true -defaults: - run: - shell: bash -e -l {0} -jobs: - build: - runs-on: ubuntu-24.04 - name: ${{ matrix.sys.compiler }} ${{ matrix.sys.version }} - ${{ matrix.sys.name }} - strategy: - fail-fast: false - matrix: - sys: - - {compiler: clang, version: '17', name: assert, flags: -DXTENSOR_ENABLE_ASSERT=ON} - - {compiler: clang, version: '18', name: column-major, flags: -DDEFAULT_COLUMN_MAJOR=ON} - - {compiler: clang, version: '19', name: assert, flags: -DXTENSOR_ENABLE_ASSERT=ON} - - {compiler: clang, version: '20', name: column-major, flags: -DDEFAULT_COLUMN_MAJOR=ON} - - {compiler: clang, version: '21', name: assert, flags: -DXTENSOR_ENABLE_ASSERT=ON} - - {compiler: gcc, version: '11', name: openmp, flags: -DXTENSOR_USE_OPENMP=ON} - - {compiler: gcc, version: '11', name: noexcept, flags: -DXTENSOR_DISABLE_EXCEPTIONS=ON} - - {compiler: gcc, version: '12', name: xsimd, flags: -DXTENSOR_USE_XSIMD=ON} - - {compiler: gcc, version: '13', name: xsimd-tbb, flags: -DXTENSOR_USE_XSIMD=ON -DXTENSOR_USE_TBB=ON} - - {compiler: gcc, version: '13', name: tbb, flags: -DXTENSOR_USE_TBB=ON -DTBB_INCLUDE_DIR=$CONDA_PREFIX/include -DTBB_LIBRARY=$CONDA_PREFIX/lib} - - {compiler: gcc, version: '14', name: xsimd-tbb, flags: -DXTENSOR_USE_XSIMD=ON -DXTENSOR_USE_TBB=ON} - - {compiler: gcc, version: '14', name: tbb, flags: -DXTENSOR_USE_TBB=ON -DTBB_INCLUDE_DIR=$CONDA_PREFIX/include -DTBB_LIBRARY=$CONDA_PREFIX/lib} - steps: - - name: Install GCC - if: matrix.sys.compiler == 'gcc' - uses: egor-tensin/setup-gcc@v1 - with: - version: ${{matrix.sys.version}} - platform: x64 - - - name: Install LLVM and Clang - if: matrix.sys.compiler == 'clang' - run: | - wget https://apt.llvm.org/llvm.sh - chmod +x llvm.sh - sudo ./llvm.sh ${{matrix.sys.version}} - sudo apt-get install -y clang-tools-${{matrix.sys.version}} - sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-${{matrix.sys.version}} 200 - sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-${{matrix.sys.version}} 200 - sudo update-alternatives --install /usr/bin/clang-scan-deps clang-scan-deps /usr/bin/clang-scan-deps-${{matrix.sys.version}} 200 - sudo update-alternatives --set clang /usr/bin/clang-${{matrix.sys.version}} - sudo update-alternatives --set clang++ /usr/bin/clang++-${{matrix.sys.version}} - sudo update-alternatives --set clang-scan-deps /usr/bin/clang-scan-deps-${{matrix.sys.version}} - - - name: Checkout code - uses: actions/checkout@v4 - - - name: Set conda environment - uses: mamba-org/setup-micromamba@main - with: - environment-name: myenv - environment-file: environment-dev.yml - init-shell: bash - cache-downloads: true - create-args: | - ${{ (matrix.sys.name == 'tbb' || matrix.sys.name == 'xsimd-tbb' ) && 'tbb-devel' || '' }} - - - name: Configure using CMake - run: | - if [[ "${{matrix.sys.compiler}}" = "gcc" ]]; then export CC=gcc-${{matrix.sys.version}}; export CXX=g++-${{matrix.sys.version}}; else export CC=clang; export CXX=clang++; fi - cmake -G Ninja -Bbuild -DCMAKE_C_COMPILER=$CC -DCMAKE_CXX_COMPILER=$CXX -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -DBUILD_TESTS=ON ${{ matrix.sys.flags }} - - - name: Install - working-directory: build - run: cmake --install . - - - name: Build - working-directory: build - run: cmake --build . --target test_xtensor_lib - - - name: Run tests - working-directory: build - run: ctest -R ^xtest$ --output-on-failure diff --git a/.github/workflows/osx.yml b/.github/workflows/osx.yml deleted file mode 100644 index 5dbce477e..000000000 --- a/.github/workflows/osx.yml +++ /dev/null @@ -1,50 +0,0 @@ -name: OSX -on: - workflow_dispatch: - pull_request: - push: - branches: [master] -concurrency: - group: ${{ github.workflow }}-${{ github.job }}-${{ github.ref }} - cancel-in-progress: true -defaults: - run: - shell: bash -e -l {0} -jobs: - build: - runs-on: macos-${{ matrix.os }} - name: macos-${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: - - 14 - - 15 - - steps: - - - name: Checkout code - uses: actions/checkout@v4 - - - name: Set conda environment - uses: mamba-org/setup-micromamba@main - with: - environment-name: myenv - environment-file: environment-dev.yml - init-shell: bash - cache-downloads: true - - - name: Configure using CMake - run: cmake -Bbuild -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -DBUILD_TESTS=ON - - - name: Install - working-directory: build - run: cmake --install . - - - name: Build - working-directory: build - run: cmake --build . --target test_xtensor_lib --parallel 8 - - - name: Run tests - working-directory: build - run: ctest -R ^xtest$ --output-on-failure diff --git a/.github/workflows/static-analysis.yml b/.github/workflows/static-analysis.yml deleted file mode 100644 index e3204614b..000000000 --- a/.github/workflows/static-analysis.yml +++ /dev/null @@ -1,22 +0,0 @@ -name: Static Analysis - -on: - push: - branches: [master] - pull_request: - branches: [master] - -jobs: - pre-commit: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - uses: pre-commit/action@v3.0.0 - - include-check: - runs-on: ubuntu-latest - name: Check unused standard includes - steps: - - uses: actions/checkout@v6 - - run: pip install diskarzhan - - run: diskarzhan `find include -name '*.hpp'` diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml deleted file mode 100644 index c04adc626..000000000 --- a/.github/workflows/windows.yml +++ /dev/null @@ -1,64 +0,0 @@ -name: Windows -on: - workflow_dispatch: - pull_request: - push: - branches: [master] -concurrency: - group: ${{ github.workflow }}-${{ github.job }}-${{ github.ref }} - cancel-in-progress: true -defaults: - run: - shell: bash -e -l {0} -jobs: - build: - runs-on: ${{ matrix.runs-on }} - name: ${{ matrix.sys.compiler }} - strategy: - fail-fast: false - matrix: - runs-on: [windows-latest] - sys: - - {compiler: default} - # Enable again and fix remaining issues after refactoring - #- {compiler: clang} - - steps: - - - name: Setup MSVC - if: matrix.sys.compiler == 'default' - uses: ilammy/msvc-dev-cmd@v1 - - - name: Setup clang - if: matrix.sys.compiler == 'clang' - run: | - echo "CC=clang" >> $GITHUB_ENV - echo "CXX=clang++" >> $GITHUB_ENV - - - name: Checkout code - uses: actions/checkout@v4 - - - name: Set conda environment - uses: mamba-org/setup-micromamba@main - with: - environment-name: myenv - environment-file: environment-dev.yml - init-shell: bash - cache-downloads: false - create-args: | - ninja - - - name: Configure using CMake - run: cmake -Bbuild -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX -DBUILD_TESTS=ON -G Ninja - - - name: Install - working-directory: build - run: cmake --install . - - - name: Build - working-directory: build - run: cmake --build . --target test_xtensor_lib --parallel 8 - - - name: Run tests - working-directory: build - run: ctest -R ^xtest$ --output-on-failure diff --git a/.gitignore b/.gitignore deleted file mode 100644 index 4a5bcec30..000000000 --- a/.gitignore +++ /dev/null @@ -1,68 +0,0 @@ -# Doxygen output -docs/html/ -docs/xml/ - -# Prerequisites -*.d - -# Compiled Object files -*.slo -*.lo -*.o -*.obj - -# Precompiled Headers -*.gch -*.pch - -# Compiled Dynamic libraries -*.so -*.dylib -*.dll - -# Compiled Static libraries -*.lai -*.la -*.a -*.lib - -# Executables -*.exe -*.out -*.app - -# Vim tmp files -*.swp -*~ - -# Generated directory -include/tmp/ - -# Build directory -build/ - -# Test build artefacts -test/test_xtensor -test/CMakeCache.txt -test/Makefile -test/CMakeFiles/ -test/cmake_install.cmake - -# Documentation build artefacts -docs/CMakeCache.txt -docs/xml/ -docs/build/ -docs/*.tmp - -# Jupyter artefacts -.ipynb_checkpoints/ - -# Pytho artefacts -__pycache__ - -# Generated files -*.pc -.vscode/settings.json - -# Allow tag JSONs under etc/xeus-cpp -!etc/xeus-cpp/tags.d/ diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 000000000..e69de29bb diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml deleted file mode 100644 index bfc98b9cf..000000000 --- a/.pre-commit-config.yaml +++ /dev/null @@ -1,48 +0,0 @@ -repos: -- repo: https://github.com/pre-commit/pre-commit-hooks - rev: v4.5.0 - hooks: - - id: check-added-large-files - - id: check-case-conflict - - id: end-of-file-fixer - - id: trailing-whitespace - - id: mixed-line-ending - args: [--fix=lf] - exclude: \.bat$ - - id: check-json - - id: pretty-format-json - args: [--autofix, --top-keys=version] - - id: check-yaml - types: [file] - files: \.(yaml|yml|clang-format) - - id: detect-private-key - - id: check-merge-conflict -- repo: https://github.com/Lucas-C/pre-commit-hooks - rev: v1.5.4 - hooks: - - id: forbid-tabs - - id: remove-tabs - args: [--whitespaces-count, '4'] -- repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks - rev: v2.16.0 - hooks: - - id: pretty-format-yaml - args: [--autofix, --indent, '2'] - types: [file] - files: \.(yaml|yml|clang-format) - additional_dependencies: [setuptools] -- repo: https://github.com/tdegeus/cpp_comment_format - rev: v0.2.1 - hooks: - - id: cpp_comment_format -- repo: https://github.com/tdegeus/conda_envfile - rev: v0.4.2 - hooks: - - id: conda_envfile_parse - files: environment.yaml -# Externally provided executables (so we can use them with editors as well). -- repo: https://github.com/pre-commit/mirrors-clang-format - rev: v17.0.6 - hooks: - - id: clang-format - files: .*\.[hc]pp$ diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index 38b5ba171..000000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,345 +0,0 @@ -############################################################################ -# Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht # -# Copyright (c) QuantStack # -# # -# Distributed under the terms of the BSD 3-Clause License. # -# # -# The full license is in the file LICENSE, distributed with this software. # -############################################################################ - -cmake_minimum_required(VERSION 3.15..3.29) -project(xtensor CXX) - -set(XTENSOR_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include) - -# xtensor tag files -set(XTENSOR_DATA_DIR "share/xeus-cpp") -set(XTENSOR_TAGFILES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/share/xeus-cpp/tagfiles) - -set(XTENSOR_CONF_DIR "etc/xeus-cpp") -set(XTENSOR_TAGCONFS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/etc/xeus-cpp/tags.d) - -file(COPY "${XTENSOR_TAGFILES_DIR}" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/share/xeus-cpp") -file(COPY "${XTENSOR_TAGCONFS_DIR}" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/etc/xeus-cpp") - - -# Versionning -# =========== - -file(STRINGS "${XTENSOR_INCLUDE_DIR}/xtensor/core/xtensor_config.hpp" xtensor_version_defines - REGEX "#define XTENSOR_VERSION_(MAJOR|MINOR|PATCH)") -foreach(ver ${xtensor_version_defines}) - if(ver MATCHES "#define XTENSOR_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$") - set(XTENSOR_VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}" CACHE INTERNAL "") - endif() -endforeach() -set(${PROJECT_NAME}_VERSION - ${XTENSOR_VERSION_MAJOR}.${XTENSOR_VERSION_MINOR}.${XTENSOR_VERSION_PATCH}) -message(STATUS "Building xtensor v${${PROJECT_NAME}_VERSION}") - -# Dependencies -# ============ - -set(xtl_REQUIRED_VERSION 0.8.0) -if(TARGET xtl) - set(xtl_VERSION ${XTL_VERSION_MAJOR}.${XTL_VERSION_MINOR}.${XTL_VERSION_PATCH}) - # Note: This is not SEMVER compatible comparison - if(${xtl_VERSION} VERSION_LESS ${xtl_REQUIRED_VERSION}) - message(ERROR "Mismatch xtl versions. Found '${xtl_VERSION}' but requires: '${xtl_REQUIRED_VERSION}'") - else() - message(STATUS "Found xtl v${xtl_VERSION}") - endif() -else() - find_package(xtl ${xtl_REQUIRED_VERSION} REQUIRED) - message(STATUS "Found xtl: ${xtl_INCLUDE_DIRS}/xtl") -endif() - -find_package(nlohmann_json 3.1.1 QUIET) - -# Optional dependencies -# ===================== - -OPTION(XTENSOR_USE_XSIMD "simd acceleration for xtensor" OFF) -OPTION(XTENSOR_USE_TBB "enable parallelization using intel TBB" OFF) -OPTION(XTENSOR_USE_OPENMP "enable parallelization using OpenMP" OFF) -if(XTENSOR_USE_TBB AND XTENSOR_USE_OPENMP) - message( - FATAL - "XTENSOR_USE_TBB and XTENSOR_USE_OPENMP cannot both be active at once" - ) -endif() - -if(XTENSOR_USE_XSIMD) - set(xsimd_REQUIRED_VERSION 13.2.0) - if(TARGET xsimd) - set(xsimd_VERSION ${XSIMD_VERSION_MAJOR}.${XSIMD_VERSION_MINOR}.${XSIMD_VERSION_PATCH}) - # Note: This is not SEMVER compatible comparison - if(${xsimd_VERSION} VERSION_LESS ${xsimd_REQUIRED_VERSION}) - message(ERROR "Mismatch xsimd versions. Found '${xsimd_VERSION}' but requires: '${xsimd_REQUIRED_VERSION}'") - else() - message(STATUS "Found xsimd v${xsimd_VERSION}") - endif() - else() - find_package(xsimd ${xsimd_REQUIRED_VERSION} REQUIRED) - message(STATUS "Found xsimd: ${xsimd_INCLUDE_DIRS}/xsimd") - endif() -endif() - -if(XTENSOR_USE_TBB) - set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/") - find_package(TBB REQUIRED) - message(STATUS "Found intel TBB: ${TBB_INCLUDE_DIRS}") -endif() - -if(XTENSOR_USE_OPENMP) - find_package(OpenMP REQUIRED) - if (OPENMP_FOUND) - # Set openmp variables now - - # Create private target just for this lib - # https://cliutils.gitlab.io/modern-cmake/chapters/packages/OpenMP.html - # Probably not safe for cmake < 3.4 .. - find_package(Threads REQUIRED) - add_library(OpenMP::OpenMP_CXX_xtensor IMPORTED INTERFACE) - set_property( - TARGET - OpenMP::OpenMP_CXX_xtensor - PROPERTY - INTERFACE_COMPILE_OPTIONS ${OpenMP_CXX_FLAGS} - ) - # Only works if the same flag is passed to the linker; use CMake 3.9+ otherwise (Intel, AppleClang) - set_property( - TARGET - OpenMP::OpenMP_CXX_xtensor - PROPERTY - INTERFACE_LINK_LIBRARIES ${OpenMP_CXX_FLAGS} Threads::Threads) - - message(STATUS "OpenMP Found") - else() - message(FATAL "Failed to locate OpenMP") - endif() -endif() - -# Build -# ===== - -set(XTENSOR_HEADERS - ${XTENSOR_INCLUDE_DIR}/xtensor/chunk/xchunked_array.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/chunk/xchunked_assign.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/chunk/xchunked_view.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xadapt.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xarray.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xbuffer_adaptor.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xcontainer.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xfixed.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xscalar.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xstorage.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/containers/xtensor.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xaccessible.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xassign.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xeval.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xexpression.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xexpression_traits.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xfunction.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xiterable.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xiterator.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xlayout.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xmath.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xmultiindex_iterator.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xnoalias.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xoperation.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xsemantic.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xshape.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xstrides.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xtensor_config.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xtensor_forward.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/core/xvectorize.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/generators/xbuilder.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/generators/xgenerator.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/generators/xrandom.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/io/xcsv.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/io/xinfo.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/io/xio.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/io/xjson.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/io/xmime.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/io/xnpy.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xcomplex.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xexpression_holder.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xfft.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xhistogram.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xmanipulation.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xpad.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xset_operation.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/misc/xsort.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/optional/xoptional.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/optional/xoptional_assembly.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/optional/xoptional_assembly_base.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/optional/xoptional_assembly_storage.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/reducers/xaccumulator.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/reducers/xblockwise_reducer.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/reducers/xblockwise_reducer_functors.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/reducers/xnorm.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/reducers/xreducer.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/utils/xexception.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/utils/xtensor_simd.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/utils/xutils.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xaxis_iterator.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xaxis_slice_iterator.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xbroadcast.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xdynamic_view.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xfunctor_view.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xindex_view.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xmasked_view.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xoffset_view.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xrepeat.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xslice.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xstrided_view.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xstrided_view_base.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xview.hpp - ${XTENSOR_INCLUDE_DIR}/xtensor/views/xview_utils.hpp -) - -add_library(xtensor INTERFACE) - -target_include_directories(xtensor INTERFACE - $ - $ - $) - -target_compile_features(xtensor INTERFACE cxx_std_20) - -target_link_libraries(xtensor INTERFACE xtl) - -OPTION(XTENSOR_ENABLE_ASSERT "xtensor bound check" OFF) -OPTION(XTENSOR_CHECK_DIMENSION "xtensor dimension check" OFF) -OPTION(XTENSOR_FORCE_TEMPORARY_MEMORY_IN_ASSIGNMENTS "xtensor force the use of temporary memory when assigning instead of an automatic overlap check" ON) -OPTION(BUILD_TESTS "xtensor test suite" OFF) -OPTION(BUILD_BENCHMARK "xtensor benchmark" OFF) -OPTION(DOWNLOAD_GBENCHMARK "download google benchmark and build from source" ON) -OPTION(DEFAULT_COLUMN_MAJOR "set default layout to column major" OFF) -OPTION(CPP23 "enables C++23 (experimental)" OFF) -OPTION(XTENSOR_DISABLE_EXCEPTIONS "Disable C++ exceptions" OFF) -OPTION(DISABLE_MSVC_ITERATOR_CHECK "Disable the MVSC iterator check" ON) - - -if(XTENSOR_ENABLE_ASSERT OR XTENSOR_CHECK_DIMENSION) - add_definitions(-DXTENSOR_ENABLE_ASSERT) -endif() - -if(XTENSOR_CHECK_DIMENSION) - add_definitions(-DXTENSOR_ENABLE_CHECK_DIMENSION) -endif() - -if(XTENSOR_FORCE_TEMPORARY_MEMORY_IN_ASSIGNMENTS) - add_definitions(-DXTENSOR_FORCE_TEMPORARY_MEMORY_IN_ASSIGNMENTS) -endif() - -if(DEFAULT_COLUMN_MAJOR) - add_definitions(-DXTENSOR_DEFAULT_LAYOUT=layout_type::column_major) -endif() - -if(MSVC AND DISABLE_MSVC_ITERATOR_CHECK) - add_compile_definitions($<$:_ITERATOR_DEBUG_LEVEL=0>) -endif() - -if(BUILD_TESTS) - enable_testing() - add_subdirectory(test) -endif() - -if(BUILD_BENCHMARK) - add_subdirectory(benchmark) -endif() - -if(XTENSOR_USE_OPENMP) - # Link xtensor itself to OpenMP to propagate to user projects - target_link_libraries(xtensor INTERFACE OpenMP::OpenMP_CXX_xtensor) -endif() - -# Installation -# ============ - -include(GNUInstallDirs) -include(CMakePackageConfigHelpers) - -install(TARGETS xtensor - EXPORT ${PROJECT_NAME}-targets) - -# Makes the project importable from the build directory -export(EXPORT ${PROJECT_NAME}-targets - FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake") - -install(DIRECTORY ${XTENSOR_INCLUDE_DIR}/xtensor - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) - -set(XTENSOR_CMAKECONFIG_INSTALL_DIR "${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}" CACHE - STRING "install path for xtensorConfig.cmake") - -configure_package_config_file(${PROJECT_NAME}Config.cmake.in - "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" - INSTALL_DESTINATION ${XTENSOR_CMAKECONFIG_INSTALL_DIR}) - -# xtensor is header-only and does not depend on the architecture. -# Remove CMAKE_SIZEOF_VOID_P from xtensorConfigVersion.cmake so that an xtensorConfig.cmake -# generated for a 64 bit target can be used for 32 bit targets and vice versa. -set(_XTENSOR_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P}) -unset(CMAKE_SIZEOF_VOID_P) -write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake - VERSION ${${PROJECT_NAME}_VERSION} - COMPATIBILITY AnyNewerVersion) -set(CMAKE_SIZEOF_VOID_P ${_XTENSOR_CMAKE_SIZEOF_VOID_P}) -install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake - ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake - DESTINATION ${XTENSOR_CMAKECONFIG_INSTALL_DIR}) -install(EXPORT ${PROJECT_NAME}-targets - FILE ${PROJECT_NAME}Targets.cmake - DESTINATION ${XTENSOR_CMAKECONFIG_INSTALL_DIR}) - -configure_file(${PROJECT_NAME}.pc.in - "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc" - @ONLY) -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc" - DESTINATION "${CMAKE_INSTALL_DATADIR}/pkgconfig/") - -install(DIRECTORY ${XTENSOR_TAGFILES_DIR} - DESTINATION ${XTENSOR_DATA_DIR}) - -install(DIRECTORY ${XTENSOR_TAGCONFS_DIR} - DESTINATION ${XTENSOR_CONF_DIR}) - -# Write single include -# ==================== - -function(PREPEND var prefix) - set(listVar "") - foreach(f ${ARGN}) - list(APPEND listVar "${prefix}${f}") - endforeach(f) - set(${var} "${listVar}" PARENT_SCOPE) -endfunction() - -function(POSTFIX var postfix) - set(listVar "") - foreach(f ${ARGN}) - list(APPEND listVar "${f}${postfix}") - endforeach(f) - set(${var} "${listVar}" PARENT_SCOPE) -endfunction() - -set(XTENSOR_SINGLE_INCLUDE ${XTENSOR_HEADERS}) -string(REPLACE "${XTENSOR_INCLUDE_DIR}/" "" XTENSOR_SINGLE_INCLUDE "${XTENSOR_SINGLE_INCLUDE}") -list(REMOVE_ITEM XTENSOR_SINGLE_INCLUDE - xtensor/misc/xexpression_holder.hpp - xtensor/io/xjson.hpp - xtensor/io/xmime.hpp - xtensor/io/xnpy.hpp) - -PREPEND(XTENSOR_SINGLE_INCLUDE "#include <" ${XTENSOR_SINGLE_INCLUDE}) -POSTFIX(XTENSOR_SINGLE_INCLUDE ">" ${XTENSOR_SINGLE_INCLUDE}) -string(REPLACE ";" "\n" XTENSOR_SINGLE_INCLUDE "${XTENSOR_SINGLE_INCLUDE}") -string(CONCAT XTENSOR_SINGLE_INCLUDE "#ifndef XTENSOR\n" "#define XTENSOR\n\n" "${XTENSOR_SINGLE_INCLUDE}" "\n\n#endif\n") - -file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/xtensor.hpp" "${XTENSOR_SINGLE_INCLUDE}") - -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/xtensor.hpp" - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 03d48a3bc..000000000 --- a/LICENSE +++ /dev/null @@ -1,28 +0,0 @@ -Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht -Copyright (c) 2016, QuantStack -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -* Neither the name of the copyright holder nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md deleted file mode 100644 index 0813d3438..000000000 --- a/README.md +++ /dev/null @@ -1,447 +0,0 @@ -# ![xtensor](docs/source/xtensor.svg) - -[![GHA Linux](https://github.com/xtensor-stack/xtensor/actions/workflows/linux.yml/badge.svg)](https://github.com/xtensor-stack/xtensor/actions/workflows/linux.yml) -[![GHA OSX](https://github.com/xtensor-stack/xtensor/actions/workflows/osx.yml/badge.svg)](https://github.com/xtensor-stack/xtensor/actions/workflows/osx.yml) -[![GHA Windows](https://github.com/xtensor-stack/xtensor/actions/workflows/windows.yml/badge.svg)](https://github.com/xtensor-stack/xtensor/actions/workflows/windows.yml) -[![Documentation](http://readthedocs.org/projects/xtensor/badge/?version=latest)](https://xtensor.readthedocs.io/en/latest/?badge=latest) -[![Doxygen -> gh-pages](https://github.com/xtensor-stack/xtensor/workflows/gh-pages/badge.svg)](https://xtensor-stack.github.io/xtensor) -[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/xtensor-stack/xtensor/stable?filepath=notebooks%2Fxtensor.ipynb) -[![Zulip](https://img.shields.io/badge/social_chat-zulip-blue.svg)](https://xtensor.zulipchat.com/#narrow/channel/539553-Ask-anything) - -Multi-dimensional arrays with broadcasting and lazy computing. - -## Introduction - -`xtensor` is a C++ library meant for numerical analysis with multi-dimensional -array expressions. - -`xtensor` provides - - - an extensible expression system enabling **lazy broadcasting**. - - an API following the idioms of the **C++ standard library**. - - tools to manipulate array expressions and build upon `xtensor`. - -Containers of `xtensor` are inspired by [NumPy](http://www.numpy.org), the -Python array programming library. **Adaptors** for existing data structures to -be plugged into our expression system can easily be written. - -In fact, `xtensor` can be used to **process NumPy data structures inplace** -using Python's [buffer protocol](https://docs.python.org/3/c-api/buffer.html). -Similarly, we can operate on Julia and R arrays. For more details on the NumPy, -Julia and R bindings, check out the [xtensor-python](https://github.com/xtensor-stack/xtensor-python), -[xtensor-julia](https://github.com/xtensor-stack/Xtensor.jl) and -[xtensor-r](https://github.com/xtensor-stack/xtensor-r) projects respectively. - -Up to version 0.26.0, `xtensor` requires a C++ compiler supporting C++14. -`xtensor` 0.26.x requires a C++ compiler supporting C++17. -`xtensor` 0.27.x requires a C++ compiler supporting C++20. - - -## Installation - -### Package managers - -We provide a package for the mamba (or conda) package manager: - -```bash -mamba install -c conda-forge xtensor -``` - -### Install from sources - -`xtensor` is a header-only library. - -You can directly install it from the sources: - -```bash -cmake -DCMAKE_INSTALL_PREFIX=your_install_prefix -make install -``` - -### Installing xtensor using vcpkg - -You can download and install xtensor using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager: - -```bash -git clone https://github.com/Microsoft/vcpkg.git -cd vcpkg -./bootstrap-vcpkg.sh -./vcpkg integrate install -./vcpkg install xtensor -``` - -The xtensor port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository. - -## Trying it online - -You can play with `xtensor` interactively in a Jupyter notebook right now! Just click on the binder link below: - -[![Binder](docs/source/binder-logo.svg)](https://mybinder.org/v2/gh/xtensor-stack/xtensor/stable?filepath=notebooks/xtensor.ipynb) - -The C++ support in Jupyter is powered by the [xeus-cling](https://github.com/jupyter-xeus/xeus-cling) C++ kernel. Together with xeus-cling, xtensor enables a similar workflow to that of NumPy with the IPython Jupyter kernel. - -![xeus-cling](docs/source/xeus-cling-screenshot.png) - -## Documentation - -For more information on using `xtensor`, check out the reference documentation - -http://xtensor.readthedocs.io/ - -## Dependencies - -`xtensor` depends on the [xtl](https://github.com/xtensor-stack/xtl) library and -has an optional dependency on the [xsimd](https://github.com/xtensor-stack/xsimd) -library: - -| `xtensor` | `xtl` |`xsimd` (optional) | -|-----------|---------|-------------------| -| master | ^0.8.0 | ^13.2.0 | -| 0.27.1 | ^0.8.0 | ^13.2.0 | -| 0.27.0 | ^0.8.0 | ^13.2.0 | -| 0.26.0 | ^0.8.0 | ^13.2.0 | -| 0.25.0 | ^0.7.5 | ^11.0.0 | -| 0.24.7 | ^0.7.0 | ^10.0.0 | -| 0.24.6 | ^0.7.0 | ^10.0.0 | -| 0.24.5 | ^0.7.0 | ^10.0.0 | -| 0.24.4 | ^0.7.0 | ^10.0.0 | -| 0.24.3 | ^0.7.0 | ^8.0.3 | -| 0.24.2 | ^0.7.0 | ^8.0.3 | -| 0.24.1 | ^0.7.0 | ^8.0.3 | -| 0.24.0 | ^0.7.0 | ^8.0.3 | -| 0.23.x | ^0.7.0 | ^7.4.8 | -| 0.22.0 | ^0.6.23 | ^7.4.8 | - -The dependency on `xsimd` is required if you want to enable SIMD acceleration -in `xtensor`. This can be done by defining the macro `XTENSOR_USE_XSIMD` -*before* including any header of `xtensor`. - -## Usage - -### Basic usage - -**Initialize a 2-D array and compute the sum of one of its rows and a 1-D array.** - -```cpp -#include -#include "xtensor/xarray.hpp" -#include "xtensor/xio.hpp" -#include "xtensor/xview.hpp" - -xt::xarray arr1 - {{1.0, 2.0, 3.0}, - {2.0, 5.0, 7.0}, - {2.0, 5.0, 7.0}}; - -xt::xarray arr2 - {5.0, 6.0, 7.0}; - -xt::xarray res = xt::view(arr1, 1) + arr2; - -std::cout << res; -``` - -Outputs: - -``` -{7, 11, 14} -``` - -**Initialize a 1-D array and reshape it inplace.** - -```cpp -#include -#include "xtensor/xarray.hpp" -#include "xtensor/xio.hpp" - -xt::xarray arr - {1, 2, 3, 4, 5, 6, 7, 8, 9}; - -arr.reshape({3, 3}); - -std::cout << arr; -``` - -Outputs: - -``` -{{1, 2, 3}, - {4, 5, 6}, - {7, 8, 9}} -``` - -**Index Access** - -```cpp -#include -#include "xtensor/xarray.hpp" -#include "xtensor/xio.hpp" - -xt::xarray arr1 - {{1.0, 2.0, 3.0}, - {2.0, 5.0, 7.0}, - {2.0, 5.0, 7.0}}; - -std::cout << arr1(0, 0) << std::endl; - -xt::xarray arr2 - {1, 2, 3, 4, 5, 6, 7, 8, 9}; - -std::cout << arr2(0); -``` - -Outputs: - -``` -1.0 -1 -``` - -### The NumPy to xtensor cheat sheet - -If you are familiar with NumPy APIs, and you are interested in xtensor, you can -check out the [NumPy to xtensor cheat sheet](https://xtensor.readthedocs.io/en/latest/numpy.html) -provided in the documentation. - -### Lazy broadcasting with `xtensor` - -Xtensor can operate on arrays of different shapes of dimensions in an -element-wise fashion. Broadcasting rules of xtensor are similar to those of -[NumPy](http://www.numpy.org) and [libdynd](http://libdynd.org). - -### Broadcasting rules - -In an operation involving two arrays of different dimensions, the array with -the lesser dimensions is broadcast across the leading dimensions of the other. - -For example, if `A` has shape `(2, 3)`, and `B` has shape `(4, 2, 3)`, the -result of a broadcasted operation with `A` and `B` has shape `(4, 2, 3)`. - -``` - (2, 3) # A -(4, 2, 3) # B ---------- -(4, 2, 3) # Result -``` - -The same rule holds for scalars, which are handled as 0-D expressions. If `A` -is a scalar, the equation becomes: - -``` - () # A -(4, 2, 3) # B ---------- -(4, 2, 3) # Result -``` - -If matched up dimensions of two input arrays are different, and one of them has -size `1`, it is broadcast to match the size of the other. Let's say B has the -shape `(4, 2, 1)` in the previous example, so the broadcasting happens as -follows: - -``` - (2, 3) # A -(4, 2, 1) # B ---------- -(4, 2, 3) # Result -``` - -### Universal functions, laziness and vectorization - -With `xtensor`, if `x`, `y` and `z` are arrays of *broadcastable shapes*, the -return type of an expression such as `x + y * sin(z)` is **not an array**. It -is an `xexpression` object offering the same interface as an N-dimensional -array, which does not hold the result. **Values are only computed upon access -or when the expression is assigned to an xarray object**. This allows to -operate symbolically on very large arrays and only compute the result for the -indices of interest. - -We provide utilities to **vectorize any scalar function** (taking multiple -scalar arguments) into a function that will perform on `xexpression`s, applying -the lazy broadcasting rules which we just described. These functions are called -*xfunction*s. They are `xtensor`'s counterpart to NumPy's universal functions. - -In `xtensor`, arithmetic operations (`+`, `-`, `*`, `/`) and all special -functions are *xfunction*s. - -### Iterating over `xexpression`s and broadcasting Iterators - -All `xexpression`s offer two sets of functions to retrieve iterator pairs (and -their `const` counterpart). - - - `begin()` and `end()` provide instances of `xiterator`s which can be used to - iterate over all the elements of the expression. The order in which - elements are listed is `row-major` in that the index of last dimension is - incremented first. - - `begin(shape)` and `end(shape)` are similar but take a *broadcasting shape* - as an argument. Elements are iterated upon in a row-major way, but certain - dimensions are repeated to match the provided shape as per the rules - described above. For an expression `e`, `e.begin(e.shape())` and `e.begin()` - are equivalent. - -### Runtime vs compile-time dimensionality - -Two container classes implementing multi-dimensional arrays are provided: -`xarray` and `xtensor`. - - - `xarray` can be reshaped dynamically to any number of dimensions. It is the - container that is the most similar to NumPy arrays. - - `xtensor` has a dimension set at compilation time, which enables many - optimizations. For example, shapes and strides of `xtensor` instances are - allocated on the stack instead of the heap. - -`xarray` and `xtensor` container are both `xexpression`s and can be involved -and mixed in universal functions, assigned to each other etc... - -Besides, two access operators are provided: - - - The variadic template `operator()` which can take multiple integral - arguments or none. - - And the `operator[]` which takes a single multi-index argument, which can be - of size determined at runtime. `operator[]` also supports access with braced - initializers. - -## Performances - -Xtensor operations make use of SIMD acceleration depending on what instruction -sets are available on the platform at hand (SSE, AVX, AVX512, Neon). - -### [![xsimd](docs/source/xsimd-small.svg)](https://github.com/xtensor-stack/xsimd) - -The [xsimd](https://github.com/xtensor-stack/xsimd) project underlies the -detection of the available instruction sets, and provides generic high-level -wrappers and memory allocators for client libraries such as xtensor. - -### Continuous benchmarking - -Xtensor operations are continuously benchmarked, and are significantly improved -at each new version. Current performances on statically dimensioned tensors -match those of the Eigen library. Dynamically dimension tensors for which the -shape is heap allocated come at a small additional cost. - -### Stack allocation for shapes and strides - -More generally, the library implement a `promote_shape` mechanism at build time -to determine the optimal sequence type to hold the shape of an expression. The -shape type of a broadcasting expression whose members have a dimensionality -determined at compile time will have a stack allocated sequence type. If at -least one note of a broadcasting expression has a dynamic dimension -(for example an `xarray`), it bubbles up to the entire broadcasting expression -which will have a heap allocated shape. The same hold for views, broadcast -expressions, etc... - -Therefore, when building an application with xtensor, we recommend using -statically-dimensioned containers whenever possible to improve the overall -performance of the application. - -## Language bindings - -### [![xtensor-python](docs/source/xtensor-python-small.svg)](https://github.com/xtensor-stack/xtensor-python) - -The [xtensor-python](https://github.com/xtensor-stack/xtensor-python) project -provides the implementation of two `xtensor` containers, `pyarray` and -`pytensor` which effectively wrap NumPy arrays, allowing inplace modification, -including reshapes. - -Utilities to automatically generate NumPy-style universal functions, exposed to -Python from scalar functions are also provided. - -### [![xtensor-julia](docs/source/xtensor-julia-small.svg)](https://github.com/xtensor-stack/xtensor-julia) - -The [xtensor-julia](https://github.com/xtensor-stack/xtensor-julia) project -provides the implementation of two `xtensor` containers, `jlarray` and -`jltensor` which effectively wrap julia arrays, allowing inplace modification, -including reshapes. - -Like in the Python case, utilities to generate NumPy-style universal functions -are provided. - -### [![xtensor-r](docs/source/xtensor-r-small.svg)](https://github.com/xtensor-stack/xtensor-r) - -The [xtensor-r](https://github.com/xtensor-stack/xtensor-r) project provides the -implementation of two `xtensor` containers, `rarray` and `rtensor` which -effectively wrap R arrays, allowing inplace modification, including reshapes. - -Like for the Python and Julia bindings, utilities to generate NumPy-style -universal functions are provided. - -## Library bindings - -### [![xtensor-blas](docs/source/xtensor-blas-small.svg)](https://github.com/xtensor-stack/xtensor-blas) - -The [xtensor-blas](https://github.com/xtensor-stack/xtensor-blas) project provides -bindings to BLAS libraries, enabling linear-algebra operations on xtensor -expressions. - -### [![xtensor-io](docs/source/xtensor-io-small.svg)](https://github.com/xtensor-stack/xtensor-io) - -The [xtensor-io](https://github.com/xtensor-stack/xtensor-io) project enables the -loading of a variety of file formats into xtensor expressions, such as image -files, sound files, HDF5 files, as well as NumPy npy and npz files. - -## Building and running the tests - -Building the tests requires the [GTest](https://github.com/google/googletest) -testing framework and [cmake](https://cmake.org). - -gtest and cmake are available as packages for most Linux distributions. -Besides, they can also be installed with the `conda` package manager (even on -windows): - -```bash -conda install -c conda-forge gtest cmake -``` - -Once `gtest` and `cmake` are installed, you can build and run the tests: - -```bash -mkdir build -cd build -cmake -DBUILD_TESTS=ON ../ -make xtest -``` - -You can also use CMake to download the source of `gtest`, build it, and use the -generated libraries: - -```bash -mkdir build -cd build -cmake -DBUILD_TESTS=ON -DDOWNLOAD_GTEST=ON ../ -make xtest -``` - -## Building the HTML documentation - -xtensor's documentation is built with three tools - - - [doxygen](http://www.doxygen.org) - - [sphinx](http://www.sphinx-doc.org) - - [breathe](https://breathe.readthedocs.io) - -While doxygen must be installed separately, you can install breathe by typing - -```bash -pip install breathe sphinx_rtd_theme -``` - -Breathe can also be installed with `conda` - -```bash -conda install -c conda-forge breathe -``` - -Finally, go to `docs` subdirectory and build the documentation with the -following command: - -```bash -make html -``` - -## License - -We use a shared copyright model that enables all contributors to maintain the -copyright on their contributions. - -This software is licensed under the BSD-3-Clause license. See the -[LICENSE](LICENSE) file for details. diff --git a/_2home_2runner_2work_2xtensor_2xtensor_2include_2xtensor_2views_2index_mapper_8hpp-example.html b/_2home_2runner_2work_2xtensor_2xtensor_2include_2xtensor_2views_2index_mapper_8hpp-example.html new file mode 100644 index 000000000..d709fd96c --- /dev/null +++ b/_2home_2runner_2work_2xtensor_2xtensor_2include_2xtensor_2views_2index_mapper_8hpp-example.html @@ -0,0 +1,541 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/views/index_mapper.hpp + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
/home/runner/work/xtensor/xtensor/include/xtensor/views/index_mapper.hpp
+
+
+
xt::xarray<double> a = xt::arange(24).reshape({2, 3, 4});
+
auto view1 = xt::view(a, 1, xt::all(), xt::all()); // Fixed first dimension
+
index_mapper<decltype(view1)> mapper;
+
+
// Map view indices (i,j) to container indices (1,i,j)
+
double val = mapper.map(a, view1, 0, 0); // Returns a(1, 0, 0)
+
double val2 = mapper.map(a, view1, 1, 2); // Returns a(1, 1, 2)
+
xt::all
bool all(E &&e)
Any.
Definition xoperation.hpp:959
+
xt::arange
auto arange(T start, T stop, S step=1) noexcept
Generates numbers evenly spaced within given half-open interval [start, stop).
Definition xbuilder.hpp:432
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
xt::view
auto view(E &&e, S &&... slices)
Constructs and returns a view on the specified xexpression.
Definition xview.hpp:1823
+
/***************************************************************************
+
* Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht *
+
* Copyright (c) QuantStack *
+
* *
+
* Distributed under the terms of the BSD 3-Clause License. *
+
* *
+
* The full license is in the file LICENSE, distributed with this software. *
+
****************************************************************************/
+
+
#ifndef XTENSOR_INDEX_MAPPER_HPP
+
#define XTENSOR_INDEX_MAPPER_HPP
+
+
#include <cassert>
+
+
#include "xview.hpp"
+
+
namespace xt
+
{
+
+
template <class UndefinedView>
+
struct index_mapper;
+
+
enum class access_t
+
{
+
SAFE,
+
UNSAFE
+
};
+
+
template <class UnderlyingContainer, class... Slices>
+
class index_mapper<xt::xview<UnderlyingContainer, Slices...>>
+
{
+
public:
+
+
using view_type = xt::xview<UnderlyingContainer, Slices...>;
+
+
using reference = typename xt::xview<UnderlyingContainer, Slices...>::reference;
+
+
using const_reference = typename xt::xview<UnderlyingContainer, Slices...>::const_reference;
+
+
static constexpr size_t n_slices = sizeof...(Slices);
+
+
static constexpr size_t nb_integral_slices = (std::is_integral_v<Slices> + ...);
+
+
static constexpr size_t nb_new_axis_slices = (xt::detail::is_newaxis_v<Slices> + ...);
+
+
template <std::integral... Indices>
+
static constexpr size_t n_indices_full_v = size_t(sizeof...(Indices) + nb_integral_slices);
+
+
template <std::integral... Indices>
+
reference map(UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+
template <std::integral... Indices>
+
const_reference
+
cmap(const UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+
template <std::integral... Indices>
+
reference map_at(UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+
template <std::integral... Indices>
+
const_reference
+
cmap_at(const UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+
size_t dimension(const UnderlyingContainer& container) const;
+
+
private:
+
+
template <bool IS_CONST>
+
using conditional_reference = std::conditional_t<IS_CONST, const_reference, reference>;
+
+
template <size_t I>
+
using slice_type = std::tuple_element_t<I, std::tuple<Slices...>>;
+
+
template <size_t I>
+
static consteval bool is_slice_integral();
+
+
template <size_t I>
+
static consteval bool is_slice_new_axis();
+
+
template <size_t first, size_t bound, size_t... indices>
+
struct indices_sequence_helper
+
{
+
// we add the current axis
+
using not_new_axis_type = typename indices_sequence_helper<first + 1, bound, indices..., first>::type;
+
+
// we skip the current axis
+
using new_axis_type = typename indices_sequence_helper<first + 1, bound, indices...>::type;
+
+
// NOTE: is_slice_new_axis works even if first >= sizeof...(Slices)
+
using type = std::conditional_t<is_slice_new_axis<first>(), new_axis_type, not_new_axis_type>;
+
};
+
+
template <size_t bound, size_t... indices>
+
struct indices_sequence_helper<bound, bound, indices...>
+
{
+
using type = std::index_sequence<indices...>;
+
};
+
+
template <size_t bound>
+
using indices_sequence = indices_sequence_helper<0, bound>::type;
+
+
template <size_t I, std::integral Index>
+
size_t map_ith_index(const view_type& view, const Index i) const;
+
+
template <bool IS_CONST, access_t ACCESS, std::integral FirstIndice, std::integral... OtherIndices>
+
conditional_reference<IS_CONST> map_main(
+
std::bool_constant<IS_CONST> /* is_const */,
+
std::conditional_t<IS_CONST, const UnderlyingContainer&, UnderlyingContainer&> container,
+
std::integral_constant<access_t, ACCESS> /* access */,
+
const view_type& view,
+
const FirstIndice firstIndice,
+
const OtherIndices... otherIndices
+
) const;
+
+
template <bool IS_CONST, access_t ACCESS>
+
conditional_reference<IS_CONST> map_main(
+
std::bool_constant<IS_CONST> /* is_const */,
+
std::conditional_t<IS_CONST, const UnderlyingContainer&, UnderlyingContainer&> container,
+
std::integral_constant<access_t, ACCESS> /* access */,
+
const view_type& view
+
) const;
+
+
template <bool IS_CONST, access_t ACCESS, size_t n_indices, size_t... Is>
+
conditional_reference<IS_CONST> map_all_indices(
+
std::bool_constant<IS_CONST> /* is_const */,
+
std::conditional_t<IS_CONST, const UnderlyingContainer&, UnderlyingContainer&> container,
+
std::integral_constant<access_t, ACCESS> /* access */,
+
const view_type& view,
+
std::index_sequence<Is...> /* is_seq */,
+
const std::array<size_t, n_indices>& indices
+
) const;
+
+
template <std::integral... Indices>
+
std::array<size_t, n_indices_full_v<Indices...>> get_indices_full(const Indices... indices) const;
+
};
+
+
/*******************************
+
* index_mapper implementation *
+
*******************************/
+
+
template <class UnderlyingContainer, class... Slices>
+
template <size_t I>
+
consteval bool index_mapper<xt::xview<UnderlyingContainer, Slices...>>::is_slice_integral()
+
{
+
if constexpr (I < sizeof...(Slices))
+
{
+
return std::is_integral_v<slice_type<I>>;
+
}
+
else
+
{
+
return false;
+
}
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <size_t I>
+
consteval bool index_mapper<xt::xview<UnderlyingContainer, Slices...>>::is_slice_new_axis()
+
{
+
if constexpr (I < sizeof...(Slices))
+
{
+
return xt::detail::is_newaxis_v<slice_type<I>>;
+
}
+
else
+
{
+
return false;
+
}
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <std::integral... Indices>
+
auto
+
index_mapper<xt::xview<UnderlyingContainer, Slices...>>::get_indices_full(const Indices... indices) const
+
-> std::array<size_t, n_indices_full_v<Indices...>>
+
{
+
constexpr size_t n_indices_full = n_indices_full_v<Indices...>;
+
+
std::array<size_t, sizeof...(indices)> args{size_t(indices)...};
+
std::array<size_t, n_indices_full> args_full;
+
+
const auto fill_args_full = [&args_full, &args]<size_t... Is>(std::index_sequence<Is...>)
+
{
+
auto it = std::cbegin(args);
+
+
((args_full[Is] = (is_slice_integral<Is>()) ? size_t(0) : *it++), ...);
+
};
+
+
fill_args_full(std::make_index_sequence<n_indices_full>{});
+
+
return args_full;
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <std::integral... Indices>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::map(
+
UnderlyingContainer& container,
+
const view_type& view,
+
const Indices... indices
+
) const -> reference
+
{
+
return map_main(
+
std::false_type{},
+
container,
+
std::integral_constant<access_t, access_t::UNSAFE>{},
+
view,
+
indices...
+
);
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <std::integral... Indices>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::cmap(
+
const UnderlyingContainer& container,
+
const view_type& view,
+
const Indices... indices
+
) const -> const_reference
+
{
+
return map_main(
+
std::true_type{},
+
container,
+
std::integral_constant<access_t, access_t::UNSAFE>{},
+
view,
+
indices...
+
);
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <std::integral... Indices>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::map_at(
+
UnderlyingContainer& container,
+
const view_type& view,
+
const Indices... indices
+
) const -> reference
+
{
+
return map_main(
+
std::false_type{},
+
container,
+
std::integral_constant<access_t, access_t::SAFE>{},
+
view,
+
indices...
+
);
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <std::integral... Indices>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::cmap_at(
+
const UnderlyingContainer& container,
+
const view_type& view,
+
const Indices... indices
+
) const -> const_reference
+
{
+
return map_main(
+
std::true_type{},
+
container,
+
std::integral_constant<access_t, access_t::SAFE>{},
+
view,
+
indices...
+
);
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <bool IS_CONST, access_t ACCESS, std::integral FirstIndice, std::integral... OtherIndices>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::map_main(
+
std::bool_constant<IS_CONST> is_const,
+
std::conditional_t<IS_CONST, const UnderlyingContainer&, UnderlyingContainer&> container,
+
std::integral_constant<access_t, ACCESS> access,
+
const view_type& view,
+
const FirstIndice firstIndice,
+
const OtherIndices... otherIndices
+
) const -> conditional_reference<IS_CONST>
+
{
+
constexpr size_t n_indices_full = n_indices_full_v<FirstIndice, OtherIndices...>;
+
+
constexpr size_t underlying_n_dimensions = xt::static_dimension<
+
typename std::decay_t<UnderlyingContainer>::shape_type>::value;
+
+
// If there is too many indices, we need to drop the first ones.
+
// If the number of dimensions of the underlying container is known at compile time we can drop them
+
// at compile time Else a runtime-test is requires, which, breaks vectorization.
+
// I don't know if we can do it in another way.
+
+
if constexpr (underlying_n_dimensions != size_t(-1))
+
{
+
// the number of dimensions of the underlying container is known at compile time.
+
constexpr size_t n_dimensions = underlying_n_dimensions - nb_integral_slices + nb_new_axis_slices;
+
+
// we can perform compile time checks
+
if constexpr (1 + sizeof...(OtherIndices) > n_dimensions)
+
{
+
return map_main(is_const, container, access, view, otherIndices...);
+
}
+
else
+
{
+
return map_all_indices(
+
is_const,
+
container,
+
access,
+
view,
+
indices_sequence<n_indices_full>{},
+
get_indices_full(firstIndice, otherIndices...)
+
);
+
}
+
}
+
else
+
{
+
// we need execution time checks
+
if (1 + sizeof...(OtherIndices) > dimension(container))
+
{
+
return map_main(is_const, container, access, view, otherIndices...);
+
}
+
else
+
{
+
return map_all_indices(
+
is_const,
+
container,
+
access,
+
view,
+
indices_sequence<n_indices_full>{},
+
get_indices_full(firstIndice, otherIndices...)
+
);
+
}
+
}
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <bool IS_CONST, access_t ACCESS>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::map_main(
+
std::bool_constant<IS_CONST> is_const,
+
std::conditional_t<IS_CONST, const UnderlyingContainer&, UnderlyingContainer&> container,
+
std::integral_constant<access_t, ACCESS> access,
+
const view_type& view
+
) const -> conditional_reference<IS_CONST>
+
{
+
constexpr size_t n_indices_full = n_indices_full_v<>;
+
+
return map_all_indices(
+
is_const,
+
container,
+
access,
+
view,
+
indices_sequence<n_indices_full>{},
+
get_indices_full()
+
);
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <bool IS_CONST, access_t ACCESS, size_t n_indices, size_t... Is>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::map_all_indices(
+
std::bool_constant<IS_CONST> /* is_const */,
+
std::conditional_t<IS_CONST, const UnderlyingContainer&, UnderlyingContainer&> container,
+
std::integral_constant<access_t, ACCESS> /* access */,
+
const view_type& view,
+
std::index_sequence<Is...> /* is_seq */,
+
const std::array<size_t, n_indices>& indices
+
) const -> conditional_reference<IS_CONST>
+
{
+
if constexpr (ACCESS == access_t::SAFE)
+
{
+
return container.at(map_ith_index<Is>(view, indices[Is])...);
+
}
+
else
+
{
+
return container(map_ith_index<Is>(view, indices[Is])...);
+
}
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
template <size_t I, std::integral Index>
+
auto
+
index_mapper<xt::xview<UnderlyingContainer, Slices...>>::map_ith_index(const view_type& view, const Index i) const
+
-> size_t
+
{
+
if constexpr (I < sizeof...(Slices))
+
{
+
// if the slice is explicitly specified, use it
+
using current_slice = std::tuple_element_t<I, std::tuple<Slices...>>;
+
+
static_assert(not xt::detail::is_newaxis_v<current_slice>);
+
+
const auto& slice = std::get<I>(view.slices());
+
+
if constexpr (std::is_integral_v<current_slice>)
+
{
+
assert(i == 0);
+
return size_t(slice);
+
}
+
else
+
{
+
assert(i < slice.size());
+
return size_t(slice(i));
+
}
+
}
+
else
+
{
+
// else assume xt::all
+
return i;
+
}
+
}
+
+
template <class UnderlyingContainer, class... Slices>
+
auto index_mapper<xt::xview<UnderlyingContainer, Slices...>>::dimension(const UnderlyingContainer& container
+
) const -> size_t
+
{
+
return container.dimension() - nb_integral_slices + nb_new_axis_slices;
+
}
+
+
} // namespace xt
+
+
#endif // XTENSOR_INDEX_MAPPER_HPP
+
xt::xview
Multidimensional view with tensor semantic.
Definition xview.hpp:365
+
xt
standard mathematical functions for xexpressions
Definition xchunked_array.hpp:20
+
xt::access_t
access_t
Defines the access policy for the underlying container.
Definition index_mapper.hpp:28
+
xt::access_t::UNSAFE
@ UNSAFE
Use operator() accessor (no bounds checking).
Definition index_mapper.hpp:30
+
xt::access_t::SAFE
@ SAFE
Use .at() accessor (bounds checked).
Definition index_mapper.hpp:29
+
xt::static_dimension
Definition xshape.hpp:246
+
+
+ + + + diff --git a/_formulas.tex b/_formulas.tex new file mode 100644 index 000000000..ee292d983 --- /dev/null +++ b/_formulas.tex @@ -0,0 +1,34 @@ +\documentclass{article} +\usepackage{iftex} +\usepackage{ifthen} +\usepackage{epsfig} +\usepackage[utf8]{inputenc} +\usepackage{xcolor} +\ifPDFTeX +\usepackage{newunicodechar} + \makeatletter + \def\doxynewunicodechar#1#2{% + \@tempswafalse + \edef\nuc@tempa{\detokenize{#1}}% + \if\relax\nuc@tempa\relax + \nuc@emptyargerr + \else + \edef\@tempb{\expandafter\@car\nuc@tempa\@nil}% + \nuc@check + \if@tempswa + \@namedef{u8:\nuc@tempa}{#2}% + \fi + \fi + } + \makeatother + \doxynewunicodechar{⁻}{${}^{-}$}% Superscript minus + \doxynewunicodechar{²}{${}^{2}$}% Superscript two + \doxynewunicodechar{³}{${}^{3}$}% Superscript three + +\fi +\pagestyle{empty} +\begin{document} +$ 2 \pi $ +\pagebreak + +\end{document} diff --git a/_formulas_dark.tex b/_formulas_dark.tex new file mode 100644 index 000000000..03a6e1444 --- /dev/null +++ b/_formulas_dark.tex @@ -0,0 +1,36 @@ +\documentclass{article} +\usepackage{iftex} +\usepackage{ifthen} +\usepackage{epsfig} +\usepackage[utf8]{inputenc} +\usepackage{xcolor} +\color{white} +\pagecolor{black} +\ifPDFTeX +\usepackage{newunicodechar} + \makeatletter + \def\doxynewunicodechar#1#2{% + \@tempswafalse + \edef\nuc@tempa{\detokenize{#1}}% + \if\relax\nuc@tempa\relax + \nuc@emptyargerr + \else + \edef\@tempb{\expandafter\@car\nuc@tempa\@nil}% + \nuc@check + \if@tempswa + \@namedef{u8:\nuc@tempa}{#2}% + \fi + \fi + } + \makeatother + \doxynewunicodechar{⁻}{${}^{-}$}% Superscript minus + \doxynewunicodechar{²}{${}^{2}$}% Superscript two + \doxynewunicodechar{³}{${}^{3}$}% Superscript three + +\fi +\pagestyle{empty} +\begin{document} +$ 2 \pi $ +\pagebreak + +\end{document} diff --git a/annotated.html b/annotated.html new file mode 100644 index 000000000..bdccc6bc4 --- /dev/null +++ b/annotated.html @@ -0,0 +1,657 @@ + + + + + + + +xtensor: Class List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class List
+
+
+
Here are the classes, structs, unions and interfaces with brief descriptions:
+
[detail level 123]
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ►Nstd
 ►NxtStandard mathematical functions for xexpressions
 ►Nxt_simd
 ►Nxtl
+
+
+
+ + + + diff --git a/annotated_dup.js b/annotated_dup.js new file mode 100644 index 000000000..df4bb493b --- /dev/null +++ b/annotated_dup.js @@ -0,0 +1,548 @@ +var annotated_dup = +[ + [ "std", null, [ + [ "tuple_size< xt::const_array< T, N > >", "classstd_1_1tuple__size_3_01xt_1_1const__array_3_01_t_00_01_n_01_4_01_4.html", null ], + [ "tuple_size< xt::fixed_shape< N... > >", "classstd_1_1tuple__size_3_01xt_1_1fixed__shape_3_01_n_8_8_8_01_4_01_4.html", null ], + [ "tuple_size< xt::sequence_view< T, Start, End > >", "classstd_1_1tuple__size_3_01xt_1_1sequence__view_3_01_t_00_01_start_00_01_end_01_4_01_4.html", null ] + ] ], + [ "xt", "namespacext.html", [ + [ "check_policy", null, [ + [ "full", "structxt_1_1check__policy_1_1full.html", null ], + [ "none", "structxt_1_1check__policy_1_1none.html", null ] + ] ], + [ "convolve_mode", null, [ + [ "full", "structxt_1_1convolve__mode_1_1full.html", null ], + [ "valid", "structxt_1_1convolve__mode_1_1valid.html", null ] + ] ], + [ "evaluation_strategy", null, [ + [ "immediate_type", "structxt_1_1evaluation__strategy_1_1immediate__type.html", null ], + [ "lazy_type", "structxt_1_1evaluation__strategy_1_1lazy__type.html", null ] + ] ], + [ "extension", null, [ + [ "expression_tag_and", "structxt_1_1extension_1_1expression__tag__and.html", null ], + [ "expression_tag_and< T >", "structxt_1_1extension_1_1expression__tag__and_3_01_t_01_4.html", null ], + [ "expression_tag_and< T, T >", "structxt_1_1extension_1_1expression__tag__and_3_01_t_00_01_t_01_4.html", null ], + [ "expression_tag_and< T, xtensor_expression_tag >", "structxt_1_1extension_1_1expression__tag__and_3_01_t_00_01xtensor__expression__tag_01_4.html", null ], + [ "expression_tag_and< T1, T... >", "structxt_1_1extension_1_1expression__tag__and_3_01_t1_00_01_t_8_8_8_01_4.html", null ], + [ "expression_tag_and< xtensor_expression_tag, T >", "structxt_1_1extension_1_1expression__tag__and_3_01xtensor__expression__tag_00_01_t_01_4.html", null ], + [ "expression_tag_and< xtensor_expression_tag, xtensor_expression_tag >", "structxt_1_1extension_1_1expression__tag__and_3_01xtensor__expression__tag_00_01xtensor__expression__tag_01_4.html", null ], + [ "expression_tag_and<>", "structxt_1_1extension_1_1expression__tag__and_3_4.html", null ], + [ "get_expression_tag", "structxt_1_1extension_1_1get__expression__tag.html", null ], + [ "get_expression_tag< xtl::xoptional< T, B > >", "structxt_1_1extension_1_1get__expression__tag_3_01xtl_1_1xoptional_3_01_t_00_01_b_01_4_01_4.html", null ], + [ "get_expression_tag_impl", "structxt_1_1extension_1_1get__expression__tag__impl.html", null ], + [ "get_expression_tag_impl< E, void_t< typename std::decay_t< E >::expression_tag > >", "structxt_1_1extension_1_1get__expression__tag__impl_3_01_e_00_01void__t_3_01typename_01std_1_1de048c22abe806a8cb61aa0c08ab63f2de.html", null ], + [ "xarray_adaptor_base", "structxt_1_1extension_1_1xarray__adaptor__base.html", null ], + [ "xarray_adaptor_base< EC, L, SC, xoptional_expression_tag >", "structxt_1_1extension_1_1xarray__adaptor__base_3_01_e_c_00_01_l_00_01_s_c_00_01xoptional__expression__tag_01_4.html", null ], + [ "xarray_adaptor_base< EC, L, SC, xtensor_expression_tag >", "structxt_1_1extension_1_1xarray__adaptor__base_3_01_e_c_00_01_l_00_01_s_c_00_01xtensor__expression__tag_01_4.html", null ], + [ "xarray_adaptor_optional_traits", "structxt_1_1extension_1_1xarray__adaptor__optional__traits.html", null ], + [ "xarray_container_base", "structxt_1_1extension_1_1xarray__container__base.html", null ], + [ "xarray_container_base< EC, L, SC, xoptional_expression_tag >", "structxt_1_1extension_1_1xarray__container__base_3_01_e_c_00_01_l_00_01_s_c_00_01xoptional__expression__tag_01_4.html", null ], + [ "xarray_container_base< EC, L, SC, xtensor_expression_tag >", "structxt_1_1extension_1_1xarray__container__base_3_01_e_c_00_01_l_00_01_s_c_00_01xtensor__expression__tag_01_4.html", null ], + [ "xarray_container_optional_traits", "structxt_1_1extension_1_1xarray__container__optional__traits.html", null ], + [ "xarray_optional_traits", "structxt_1_1extension_1_1xarray__optional__traits.html", null ], + [ "xbroadcast_base", "structxt_1_1extension_1_1xbroadcast__base.html", null ], + [ "xbroadcast_base_impl", "structxt_1_1extension_1_1xbroadcast__base__impl.html", null ], + [ "xbroadcast_base_impl< xoptional_expression_tag, CT, X >", "structxt_1_1extension_1_1xbroadcast__base__impl_3_01xoptional__expression__tag_00_01_c_t_00_01_x_01_4.html", null ], + [ "xbroadcast_base_impl< xtensor_expression_tag, CT, X >", "structxt_1_1extension_1_1xbroadcast__base__impl_3_01xtensor__expression__tag_00_01_c_t_00_01_x_01_4.html", null ], + [ "xbroadcast_optional", "classxt_1_1extension_1_1xbroadcast__optional.html", null ], + [ "xcontainer_optional_base", "classxt_1_1extension_1_1xcontainer__optional__base.html", null ], + [ "xdynamic_view_base", "structxt_1_1extension_1_1xdynamic__view__base.html", null ], + [ "xdynamic_view_base_impl", "structxt_1_1extension_1_1xdynamic__view__base__impl.html", null ], + [ "xdynamic_view_base_impl< xoptional_expression_tag, CT, S, L, FST >", "structxt_1_1extension_1_1xdynamic__view__base__impl_3_01xoptional__expression__tag_00_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4.html", null ], + [ "xdynamic_view_base_impl< xtensor_expression_tag, CT, S, L, FST >", "structxt_1_1extension_1_1xdynamic__view__base__impl_3_01xtensor__expression__tag_00_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4.html", null ], + [ "xdynamic_view_optional", "classxt_1_1extension_1_1xdynamic__view__optional.html", null ], + [ "xfunction_base", "structxt_1_1extension_1_1xfunction__base.html", null ], + [ "xfunction_base_impl", "structxt_1_1extension_1_1xfunction__base__impl.html", null ], + [ "xfunction_base_impl< xoptional_expression_tag, F, CT... >", "structxt_1_1extension_1_1xfunction__base__impl_3_01xoptional__expression__tag_00_01_f_00_01_c_t_8_8_8_01_4.html", null ], + [ "xfunction_base_impl< xtensor_expression_tag, F, CT... >", "structxt_1_1extension_1_1xfunction__base__impl_3_01xtensor__expression__tag_00_01_f_00_01_c_t_8_8_8_01_4.html", null ], + [ "xfunction_optional_base", "classxt_1_1extension_1_1xfunction__optional__base.html", null ], + [ "xfunctor_view_base", "structxt_1_1extension_1_1xfunctor__view__base.html", null ], + [ "xfunctor_view_base_impl", "structxt_1_1extension_1_1xfunctor__view__base__impl.html", null ], + [ "xfunctor_view_base_impl< xoptional_expression_tag, F, CT >", "structxt_1_1extension_1_1xfunctor__view__base__impl_3_01xoptional__expression__tag_00_01_f_00_01_c_t_01_4.html", null ], + [ "xfunctor_view_base_impl< xtensor_expression_tag, F, CT >", "structxt_1_1extension_1_1xfunctor__view__base__impl_3_01xtensor__expression__tag_00_01_f_00_01_c_t_01_4.html", null ], + [ "xfunctor_view_optional", "classxt_1_1extension_1_1xfunctor__view__optional.html", null ], + [ "xgenerator_base", "structxt_1_1extension_1_1xgenerator__base.html", null ], + [ "xgenerator_base_impl", "structxt_1_1extension_1_1xgenerator__base__impl.html", null ], + [ "xgenerator_base_impl< xoptional_expression_tag, F, R, S >", "structxt_1_1extension_1_1xgenerator__base__impl_3_01xoptional__expression__tag_00_01_f_00_01_r_00_01_s_01_4.html", null ], + [ "xgenerator_base_impl< xtensor_expression_tag, F, R, S >", "structxt_1_1extension_1_1xgenerator__base__impl_3_01xtensor__expression__tag_00_01_f_00_01_r_00_01_s_01_4.html", null ], + [ "xgenerator_optional", "classxt_1_1extension_1_1xgenerator__optional.html", null ], + [ "xindex_view_base", "structxt_1_1extension_1_1xindex__view__base.html", null ], + [ "xindex_view_base_impl", "structxt_1_1extension_1_1xindex__view__base__impl.html", null ], + [ "xindex_view_base_impl< xoptional_expression_tag, CT, I >", "structxt_1_1extension_1_1xindex__view__base__impl_3_01xoptional__expression__tag_00_01_c_t_00_01_i_01_4.html", null ], + [ "xindex_view_base_impl< xtensor_expression_tag, CT, I >", "structxt_1_1extension_1_1xindex__view__base__impl_3_01xtensor__expression__tag_00_01_c_t_00_01_i_01_4.html", null ], + [ "xindex_view_optional", "classxt_1_1extension_1_1xindex__view__optional.html", null ], + [ "xoptional_empty_base", "classxt_1_1extension_1_1xoptional__empty__base.html", null ], + [ "xreducer_base", "structxt_1_1extension_1_1xreducer__base.html", null ], + [ "xreducer_base_impl", "structxt_1_1extension_1_1xreducer__base__impl.html", null ], + [ "xreducer_base_impl< xoptional_expression_tag, F, CT, X, O >", "structxt_1_1extension_1_1xreducer__base__impl_3_01xoptional__expression__tag_00_01_f_00_01_c_t_00_01_x_00_01_o_01_4.html", null ], + [ "xreducer_base_impl< xtensor_expression_tag, F, CT, X, O >", "structxt_1_1extension_1_1xreducer__base__impl_3_01xtensor__expression__tag_00_01_f_00_01_c_t_00_01_x_00_01_o_01_4.html", null ], + [ "xreducer_optional", "classxt_1_1extension_1_1xreducer__optional.html", null ], + [ "xrepeat_base", "structxt_1_1extension_1_1xrepeat__base.html", null ], + [ "xrepeat_base_impl", "structxt_1_1extension_1_1xrepeat__base__impl.html", null ], + [ "xrepeat_base_impl< xoptional_expression_tag, CT, X >", "structxt_1_1extension_1_1xrepeat__base__impl_3_01xoptional__expression__tag_00_01_c_t_00_01_x_01_4.html", null ], + [ "xrepeat_base_impl< xtensor_expression_tag, CT, X >", "structxt_1_1extension_1_1xrepeat__base__impl_3_01xtensor__expression__tag_00_01_c_t_00_01_x_01_4.html", null ], + [ "xrepeat_optional", "classxt_1_1extension_1_1xrepeat__optional.html", null ], + [ "xscalar_base", "structxt_1_1extension_1_1xscalar__base.html", null ], + [ "xscalar_base_impl", "structxt_1_1extension_1_1xscalar__base__impl.html", null ], + [ "xscalar_base_impl< xoptional_expression_tag, CT >", "structxt_1_1extension_1_1xscalar__base__impl_3_01xoptional__expression__tag_00_01_c_t_01_4.html", null ], + [ "xscalar_base_impl< xtensor_expression_tag, CT >", "structxt_1_1extension_1_1xscalar__base__impl_3_01xtensor__expression__tag_00_01_c_t_01_4.html", null ], + [ "xscalar_optional_base", "classxt_1_1extension_1_1xscalar__optional__base.html", null ], + [ "xscalar_optional_traits", "structxt_1_1extension_1_1xscalar__optional__traits.html", null ], + [ "xstrided_view_base", "structxt_1_1extension_1_1xstrided__view__base.html", null ], + [ "xstrided_view_base_impl", "structxt_1_1extension_1_1xstrided__view__base__impl.html", null ], + [ "xstrided_view_base_impl< xoptional_expression_tag, CT, S, L, FST >", "structxt_1_1extension_1_1xstrided__view__base__impl_3_01xoptional__expression__tag_00_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4.html", null ], + [ "xstrided_view_base_impl< xtensor_expression_tag, CT, S, L, FST >", "structxt_1_1extension_1_1xstrided__view__base__impl_3_01xtensor__expression__tag_00_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4.html", null ], + [ "xstrided_view_optional", "classxt_1_1extension_1_1xstrided__view__optional.html", null ], + [ "xtensor_adaptor_base", "structxt_1_1extension_1_1xtensor__adaptor__base.html", null ], + [ "xtensor_adaptor_base< EC, N, L, xoptional_expression_tag >", "structxt_1_1extension_1_1xtensor__adaptor__base_3_01_e_c_00_01_n_00_01_l_00_01xoptional__expression__tag_01_4.html", null ], + [ "xtensor_adaptor_base< EC, N, L, xtensor_expression_tag >", "structxt_1_1extension_1_1xtensor__adaptor__base_3_01_e_c_00_01_n_00_01_l_00_01xtensor__expression__tag_01_4.html", null ], + [ "xtensor_adaptor_optional_traits", "structxt_1_1extension_1_1xtensor__adaptor__optional__traits.html", null ], + [ "xtensor_container_base", "structxt_1_1extension_1_1xtensor__container__base.html", null ], + [ "xtensor_container_base< EC, N, L, xoptional_expression_tag >", "structxt_1_1extension_1_1xtensor__container__base_3_01_e_c_00_01_n_00_01_l_00_01xoptional__expression__tag_01_4.html", null ], + [ "xtensor_container_base< EC, N, L, xtensor_expression_tag >", "structxt_1_1extension_1_1xtensor__container__base_3_01_e_c_00_01_n_00_01_l_00_01xtensor__expression__tag_01_4.html", null ], + [ "xtensor_container_optional_traits", "structxt_1_1extension_1_1xtensor__container__optional__traits.html", null ], + [ "xtensor_empty_base", "structxt_1_1extension_1_1xtensor__empty__base.html", null ], + [ "xtensor_optional_traits", "structxt_1_1extension_1_1xtensor__optional__traits.html", null ], + [ "xtensor_view_base", "structxt_1_1extension_1_1xtensor__view__base.html", null ], + [ "xtensor_view_base< EC, N, L, xoptional_expression_tag >", "structxt_1_1extension_1_1xtensor__view__base_3_01_e_c_00_01_n_00_01_l_00_01xoptional__expression__tag_01_4.html", null ], + [ "xtensor_view_base< EC, N, L, xtensor_expression_tag >", "structxt_1_1extension_1_1xtensor__view__base_3_01_e_c_00_01_n_00_01_l_00_01xtensor__expression__tag_01_4.html", null ], + [ "xtensor_view_optional_traits", "structxt_1_1extension_1_1xtensor__view__optional__traits.html", null ], + [ "xview_base", "structxt_1_1extension_1_1xview__base.html", null ], + [ "xview_base_impl", "structxt_1_1extension_1_1xview__base__impl.html", null ], + [ "xview_base_impl< xoptional_expression_tag, CT, S... >", "structxt_1_1extension_1_1xview__base__impl_3_01xoptional__expression__tag_00_01_c_t_00_01_s_8_8_8_01_4.html", null ], + [ "xview_base_impl< xtensor_expression_tag, CT, S... >", "structxt_1_1extension_1_1xview__base__impl_3_01xtensor__expression__tag_00_01_c_t_00_01_s_8_8_8_01_4.html", null ], + [ "xview_optional", "classxt_1_1extension_1_1xview__optional.html", null ] + ] ], + [ "math", null, [ + [ "abs_fun", "structxt_1_1math_1_1abs__fun.html", null ], + [ "acos_fun", "structxt_1_1math_1_1acos__fun.html", null ], + [ "acosh_fun", "structxt_1_1math_1_1acosh__fun.html", null ], + [ "arg_fun", "structxt_1_1math_1_1arg__fun.html", null ], + [ "asin_fun", "structxt_1_1math_1_1asin__fun.html", null ], + [ "asinh_fun", "structxt_1_1math_1_1asinh__fun.html", null ], + [ "atan2_fun", "structxt_1_1math_1_1atan2__fun.html", null ], + [ "atan_fun", "structxt_1_1math_1_1atan__fun.html", null ], + [ "atanh_fun", "structxt_1_1math_1_1atanh__fun.html", null ], + [ "cbrt_fun", "structxt_1_1math_1_1cbrt__fun.html", null ], + [ "ceil_fun", "structxt_1_1math_1_1ceil__fun.html", null ], + [ "clamp_fun", "structxt_1_1math_1_1clamp__fun.html", null ], + [ "conj_fun", "structxt_1_1math_1_1conj__fun.html", null ], + [ "conj_impl_fun", "structxt_1_1math_1_1conj__impl__fun.html", null ], + [ "cos_fun", "structxt_1_1math_1_1cos__fun.html", null ], + [ "cosh_fun", "structxt_1_1math_1_1cosh__fun.html", null ], + [ "deg2rad", "structxt_1_1math_1_1deg2rad.html", null ], + [ "erf_fun", "structxt_1_1math_1_1erf__fun.html", null ], + [ "erfc_fun", "structxt_1_1math_1_1erfc__fun.html", null ], + [ "exp2_fun", "structxt_1_1math_1_1exp2__fun.html", null ], + [ "exp_fun", "structxt_1_1math_1_1exp__fun.html", null ], + [ "expm1_fun", "structxt_1_1math_1_1expm1__fun.html", null ], + [ "fabs_fun", "structxt_1_1math_1_1fabs__fun.html", null ], + [ "fdim_fun", "structxt_1_1math_1_1fdim__fun.html", null ], + [ "floor_fun", "structxt_1_1math_1_1floor__fun.html", null ], + [ "fma_fun", "structxt_1_1math_1_1fma__fun.html", null ], + [ "fmax_fun", "structxt_1_1math_1_1fmax__fun.html", null ], + [ "fmin_fun", "structxt_1_1math_1_1fmin__fun.html", null ], + [ "fmod_fun", "structxt_1_1math_1_1fmod__fun.html", null ], + [ "hypot_fun", "structxt_1_1math_1_1hypot__fun.html", null ], + [ "isfinite_fun", "structxt_1_1math_1_1isfinite__fun.html", null ], + [ "isinf_fun", "structxt_1_1math_1_1isinf__fun.html", null ], + [ "isnan_fun", "structxt_1_1math_1_1isnan__fun.html", null ], + [ "lgamma_fun", "structxt_1_1math_1_1lgamma__fun.html", null ], + [ "log10_fun", "structxt_1_1math_1_1log10__fun.html", null ], + [ "log1p_fun", "structxt_1_1math_1_1log1p__fun.html", null ], + [ "log2_fun", "structxt_1_1math_1_1log2__fun.html", null ], + [ "log_fun", "structxt_1_1math_1_1log__fun.html", null ], + [ "maximum", "structxt_1_1math_1_1maximum.html", null ], + [ "minimum", "structxt_1_1math_1_1minimum.html", null ], + [ "nearbyint_fun", "structxt_1_1math_1_1nearbyint__fun.html", null ], + [ "norm_fun", "structxt_1_1math_1_1norm__fun.html", null ], + [ "pow_fun", "structxt_1_1math_1_1pow__fun.html", null ], + [ "rad2deg", "structxt_1_1math_1_1rad2deg.html", null ], + [ "remainder_fun", "structxt_1_1math_1_1remainder__fun.html", null ], + [ "rint_fun", "structxt_1_1math_1_1rint__fun.html", null ], + [ "round_fun", "structxt_1_1math_1_1round__fun.html", null ], + [ "sign_fun", "structxt_1_1math_1_1sign__fun.html", null ], + [ "sign_impl", "structxt_1_1math_1_1sign__impl.html", null ], + [ "sign_impl< xtl::xoptional< T, B > >", "structxt_1_1math_1_1sign__impl_3_01xtl_1_1xoptional_3_01_t_00_01_b_01_4_01_4.html", null ], + [ "sin_fun", "structxt_1_1math_1_1sin__fun.html", null ], + [ "sinh_fun", "structxt_1_1math_1_1sinh__fun.html", null ], + [ "sqrt_fun", "structxt_1_1math_1_1sqrt__fun.html", null ], + [ "tan_fun", "structxt_1_1math_1_1tan__fun.html", null ], + [ "tanh_fun", "structxt_1_1math_1_1tanh__fun.html", null ], + [ "tgamma_fun", "structxt_1_1math_1_1tgamma__fun.html", null ], + [ "trunc_fun", "structxt_1_1math_1_1trunc__fun.html", null ] + ] ], + [ "placeholders", null, [ + [ "rangemaker", "structxt_1_1placeholders_1_1rangemaker.html", null ], + [ "rangemaker< A, B >", "structxt_1_1placeholders_1_1rangemaker_3_01_a_00_01_b_01_4.html", null ], + [ "rangemaker< A, B, C >", "structxt_1_1placeholders_1_1rangemaker_3_01_a_00_01_b_00_01_c_01_4.html", null ], + [ "xtuph", "structxt_1_1placeholders_1_1xtuph.html", null ] + ] ], + [ "print_options", null, [ + [ "edge_items", "classxt_1_1print__options_1_1edge__items.html", null ], + [ "line_width", "classxt_1_1print__options_1_1line__width.html", null ], + [ "precision", "classxt_1_1print__options_1_1precision.html", null ], + [ "print_options_impl", "structxt_1_1print__options_1_1print__options__impl.html", null ], + [ "threshold", "classxt_1_1print__options_1_1threshold.html", null ] + ] ], + [ "strided_assign_detail", null, [ + [ "check_strides_functor", "structxt_1_1strided__assign__detail_1_1check__strides__functor.html", null ], + [ "idx_tools", "structxt_1_1strided__assign__detail_1_1idx__tools.html", null ], + [ "idx_tools< layout_type::column_major >", "structxt_1_1strided__assign__detail_1_1idx__tools_3_01layout__type_1_1column__major_01_4.html", null ], + [ "idx_tools< layout_type::row_major >", "structxt_1_1strided__assign__detail_1_1idx__tools_3_01layout__type_1_1row__major_01_4.html", null ], + [ "loop_sizes_t", "structxt_1_1strided__assign__detail_1_1loop__sizes__t.html", null ] + ] ], + [ "traits_detail", null, [ + [ "norm_of_array_elements_impl", "structxt_1_1traits__detail_1_1norm__of__array__elements__impl.html", null ], + [ "norm_of_array_elements_impl< long double, false, true >", "structxt_1_1traits__detail_1_1norm__of__array__elements__impl_3_01long_01double_00_01false_00_01true_01_4.html", null ], + [ "norm_of_array_elements_impl< T, false, false >", "structxt_1_1traits__detail_1_1norm__of__array__elements__impl_3_01_t_00_01false_00_01false_01_4.html", null ], + [ "norm_of_array_elements_impl< T, false, true >", "structxt_1_1traits__detail_1_1norm__of__array__elements__impl_3_01_t_00_01false_00_01true_01_4.html", null ], + [ "norm_of_array_elements_impl< T, true, false >", "structxt_1_1traits__detail_1_1norm__of__array__elements__impl_3_01_t_00_01true_00_01false_01_4.html", null ], + [ "norm_of_array_elements_impl< void *, false, false >", "structxt_1_1traits__detail_1_1norm__of__array__elements__impl_3_01void_01_5_00_01false_00_01false_01_4.html", null ], + [ "norm_of_scalar_impl", "structxt_1_1traits__detail_1_1norm__of__scalar__impl.html", null ], + [ "norm_of_scalar_impl< T, false >", "structxt_1_1traits__detail_1_1norm__of__scalar__impl_3_01_t_00_01false_01_4.html", null ], + [ "norm_of_scalar_impl< T, true >", "structxt_1_1traits__detail_1_1norm__of__scalar__impl_3_01_t_00_01true_01_4.html", null ], + [ "norm_of_vector_impl", "structxt_1_1traits__detail_1_1norm__of__vector__impl.html", null ], + [ "norm_type_base", "structxt_1_1traits__detail_1_1norm__type__base.html", null ] + ] ], + [ "acquire_ownership", "structxt_1_1acquire__ownership.html", null ], + [ "aligned_array", "classxt_1_1aligned__array.html", null ], + [ "aligned_mode", "structxt_1_1aligned__mode.html", null ], + [ "big_promote_value_type", "structxt_1_1big__promote__value__type.html", null ], + [ "broadcast_error", "classxt_1_1broadcast__error.html", null ], + [ "buffer_inner_types", "structxt_1_1buffer__inner__types.html", null ], + [ "buffer_inner_types< xbuffer_adaptor< CP, O, A > >", "structxt_1_1buffer__inner__types_3_01xbuffer__adaptor_3_01_c_p_00_01_o_00_01_a_01_4_01_4.html", null ], + [ "buffer_inner_types< xiterator_adaptor< I, CI > >", "structxt_1_1buffer__inner__types_3_01xiterator__adaptor_3_01_i_00_01_c_i_01_4_01_4.html", null ], + [ "buffer_inner_types< xiterator_owner_adaptor< C, IG > >", "structxt_1_1buffer__inner__types_3_01xiterator__owner__adaptor_3_01_c_00_01_i_g_01_4_01_4.html", null ], + [ "can_assign", "structxt_1_1can__assign.html", null ], + [ "can_assign< xstrided_view< CT, S, L, FST >, RHS >", "structxt_1_1can__assign_3_01xstrided__view_3_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4_00_01_r_h_s_01_4.html", null ], + [ "check_strides_overlap", "structxt_1_1check__strides__overlap.html", null ], + [ "check_strides_overlap< layout_type::column_major >", "structxt_1_1check__strides__overlap_3_01layout__type_1_1column__major_01_4.html", null ], + [ "check_strides_overlap< layout_type::row_major >", "structxt_1_1check__strides__overlap_3_01layout__type_1_1row__major_01_4.html", null ], + [ "common_difference_type", "structxt_1_1common__difference__type.html", null ], + [ "common_difference_type<>", "structxt_1_1common__difference__type_3_4.html", null ], + [ "common_size_type", "structxt_1_1common__size__type.html", null ], + [ "common_size_type<>", "structxt_1_1common__size__type_3_4.html", null ], + [ "common_tensor_type", "structxt_1_1common__tensor__type.html", null ], + [ "common_value_type", "structxt_1_1common__value__type.html", null ], + [ "concatenate_error", "classxt_1_1concatenate__error.html", null ], + [ "conditional_cast_functor", "structxt_1_1conditional__cast__functor.html", null ], + [ "conditional_cast_functor< false, T >", "structxt_1_1conditional__cast__functor_3_01false_00_01_t_01_4.html", null ], + [ "conditional_cast_functor< true, T >", "structxt_1_1conditional__cast__functor_3_01true_00_01_t_01_4.html", null ], + [ "const_array", "structxt_1_1const__array.html", null ], + [ "const_value", "structxt_1_1const__value.html", null ], + [ "const_xclosure", "structxt_1_1const__xclosure.html", null ], + [ "const_xclosure< E, disable_xexpression< std::decay_t< E > > >", "structxt_1_1const__xclosure_3_01_e_00_01disable__xexpression_3_01std_1_1decay__t_3_01_e_01_4_01_4_01_4.html", null ], + [ "const_xclosure< xshared_expression< E > &, std::enable_if_t< true > >", "structxt_1_1const__xclosure_3_01xshared__expression_3_01_e_01_4_01_6_00_01std_1_1enable__if__t_3_01true_01_4_01_4.html", null ], + [ "container_simd_return_type", "structxt_1_1container__simd__return__type.html", null ], + [ "decay_all", "structxt_1_1decay__all.html", null ], + [ "decay_all< S< X... > >", "structxt_1_1decay__all_3_01_s_3_01_x_8_8_8_01_4_01_4.html", null ], + [ "disable_indexed_stepper", "structxt_1_1disable__indexed__stepper.html", null ], + [ "driven_align_mode", "structxt_1_1driven__align__mode.html", null ], + [ "enable_indexed_stepper", "structxt_1_1enable__indexed__stepper.html", null ], + [ "filter_fixed_shape", "structxt_1_1filter__fixed__shape.html", null ], + [ "fixed_shape", "classxt_1_1fixed__shape.html", null ], + [ "fixed_xreducer_shape_type", "structxt_1_1fixed__xreducer__shape__type.html", null ], + [ "fixed_xreducer_shape_type< fixed_shape< I... >, fixed_shape< J... > >", "structxt_1_1fixed__xreducer__shape__type_3_01fixed__shape_3_01_i_8_8_8_01_4_00_01fixed__shape_3_01_j_8_8_8_01_4_01_4.html", null ], + [ "forbid_simd", "structxt_1_1forbid__simd.html", null ], + [ "forbid_simd< const std::vector< bool, A > >", "structxt_1_1forbid__simd_3_01const_01std_1_1vector_3_01bool_00_01_a_01_4_01_4.html", null ], + [ "forbid_simd< const xtl::xdynamic_bitset< B, A > >", "structxt_1_1forbid__simd_3_01const_01xtl_1_1xdynamic__bitset_3_01_b_00_01_a_01_4_01_4.html", null ], + [ "forbid_simd< std::vector< bool, A > >", "structxt_1_1forbid__simd_3_01std_1_1vector_3_01bool_00_01_a_01_4_01_4.html", null ], + [ "forbid_simd< xtl::xdynamic_bitset< B, A > >", "structxt_1_1forbid__simd_3_01xtl_1_1xdynamic__bitset_3_01_b_00_01_a_01_4_01_4.html", null ], + [ "get_init_type", "structxt_1_1get__init__type.html", null ], + [ "get_init_type< V, fixed_shape< X... > >", "structxt_1_1get__init__type_3_01_v_00_01fixed__shape_3_01_x_8_8_8_01_4_01_4.html", null ], + [ "get_rank", "structxt_1_1get__rank.html", null ], + [ "get_rank< E, decltype((void) E::rank, void())>", "structxt_1_1get__rank_3_01_e_00_01decltype_07_07void_08_01_e_1_1rank_00_01void_07_08_08_4.html", null ], + [ "get_strides_type", "structxt_1_1get__strides__type.html", null ], + [ "get_strides_type< fixed_shape< I... > >", "structxt_1_1get__strides__type_3_01fixed__shape_3_01_i_8_8_8_01_4_01_4.html", null ], + [ "get_strides_type< xbuffer_adaptor< CP, O, A > >", "structxt_1_1get__strides__type_3_01xbuffer__adaptor_3_01_c_p_00_01_o_00_01_a_01_4_01_4.html", null ], + [ "get_value_type", "structxt_1_1get__value__type.html", null ], + [ "get_value_type< T, void_t< typename T::value_type > >", "structxt_1_1get__value__type_3_01_t_00_01void__t_3_01typename_01_t_1_1value__type_01_4_01_4.html", null ], + [ "has_assign_conversion", "structxt_1_1has__assign__conversion.html", null ], + [ "has_assign_to", "structxt_1_1has__assign__to.html", null ], + [ "has_assign_to< E1, E2, void_t< decltype(std::declval< const E2 & >().assign_to(std::declval< E1 & >()))> >", "structxt_1_1has__assign__to_3_01_e1_00_01_e2_00_01void__t_3_01decltype_07std_1_1declval_3_01cons059ed553ffd14856020f06c40d9ce771.html", null ], + [ "has_data_interface", "structxt_1_1has__data__interface.html", null ], + [ "has_data_interface< E, void_t< decltype(std::declval< E >().data())> >", "structxt_1_1has__data__interface_3_01_e_00_01void__t_3_01decltype_07std_1_1declval_3_01_e_01_4_07_08_8data_07_08_08_4_01_4.html", null ], + [ "has_fixed_rank", "structxt_1_1has__fixed__rank.html", null ], + [ "has_iterator_interface", "structxt_1_1has__iterator__interface.html", null ], + [ "has_iterator_interface< E, void_t< decltype(std::declval< E >().begin())> >", "structxt_1_1has__iterator__interface_3_01_e_00_01void__t_3_01decltype_07std_1_1declval_3_01_e_01_4_07_08_8begin_07_08_08_4_01_4.html", null ], + [ "has_memory_address", "structxt_1_1has__memory__address.html", null ], + [ "has_memory_address< T, void_t< decltype(std::addressof(*std::declval< T >().begin()))> >", "structxt_1_1has__memory__address_3_01_t_00_01void__t_3_01decltype_07std_1_1addressof_07_5std_1_1e8ed49541169f10cfa05c619e2da0ead.html", null ], + [ "has_rank", "structxt_1_1has__rank.html", null ], + [ "has_sign_conversion", "structxt_1_1has__sign__conversion.html", null ], + [ "has_simd_apply", "structxt_1_1has__simd__apply.html", null ], + [ "has_simd_interface", "structxt_1_1has__simd__interface.html", null ], + [ "has_simd_interface< xfunction< F, CT... >, T >", "structxt_1_1has__simd__interface_3_01xfunction_3_01_f_00_01_c_t_8_8_8_01_4_00_01_t_01_4.html", null ], + [ "has_simd_interface< xfunctor_adaptor< F, CT >, T >", "structxt_1_1has__simd__interface_3_01xfunctor__adaptor_3_01_f_00_01_c_t_01_4_00_01_t_01_4.html", null ], + [ "has_simd_interface< xfunctor_applier_base< D >, T >", "structxt_1_1has__simd__interface_3_01xfunctor__applier__base_3_01_d_01_4_00_01_t_01_4.html", null ], + [ "has_simd_interface< xfunctor_view< F, CT >, T >", "structxt_1_1has__simd__interface_3_01xfunctor__view_3_01_f_00_01_c_t_01_4_00_01_t_01_4.html", null ], + [ "has_simd_interface< xtensor_view< EC, N, L, Tag > >", "structxt_1_1has__simd__interface_3_01xtensor__view_3_01_e_c_00_01_n_00_01_l_00_01_tag_01_4_01_4.html", null ], + [ "has_simd_type", "structxt_1_1has__simd__type.html", null ], + [ "has_storage_type", "structxt_1_1has__storage__type.html", null ], + [ "has_storage_type< T, void_t< typename xcontainer_inner_types< T >::storage_type > >", "structxt_1_1has__storage__type_3_01_t_00_01void__t_3_01typename_01xcontainer__inner__types_3_01_650a1762a9f827a241fdd5fca766bcf6.html", null ], + [ "has_strides", "structxt_1_1has__strides.html", null ], + [ "has_strides< E, void_t< decltype(std::declval< E >().strides())> >", "structxt_1_1has__strides_3_01_e_00_01void__t_3_01decltype_07std_1_1declval_3_01_e_01_4_07_08_8strides_07_08_08_4_01_4.html", null ], + [ "index_from_shape", "structxt_1_1index__from__shape.html", null ], + [ "index_mapper", "structxt_1_1index__mapper.html", null ], + [ "index_mapper< xt::xview< UnderlyingContainer, Slices... > >", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4" ], + [ "initializer_dimension", "structxt_1_1initializer__dimension.html", null ], + [ "inner_aligned_mode", "structxt_1_1inner__aligned__mode.html", null ], + [ "inner_reference", "structxt_1_1inner__reference.html", null ], + [ "invalid_type", "structxt_1_1invalid__type.html", null ], + [ "is_chunked_t", "structxt_1_1is__chunked__t.html", null ], + [ "is_contiguous_container", "structxt_1_1is__contiguous__container.html", null ], + [ "is_contiguous_container< xiterator< St, S, L > >", "structxt_1_1is__contiguous__container_3_01xiterator_3_01_st_00_01_s_00_01_l_01_4_01_4.html", null ], + [ "is_contiguous_container< xiterator_adaptor< I, CI > >", "structxt_1_1is__contiguous__container_3_01xiterator__adaptor_3_01_i_00_01_c_i_01_4_01_4.html", null ], + [ "is_contiguous_container< xiterator_owner_adaptor< C, IG > >", "structxt_1_1is__contiguous__container_3_01xiterator__owner__adaptor_3_01_c_00_01_i_g_01_4_01_4.html", null ], + [ "is_evaluation_strategy", "structxt_1_1is__evaluation__strategy.html", null ], + [ "is_indexed_stepper", "structxt_1_1is__indexed__stepper.html", null ], + [ "is_indexed_stepper< xindexed_stepper< T, B > >", "structxt_1_1is__indexed__stepper_3_01xindexed__stepper_3_01_t_00_01_b_01_4_01_4.html", null ], + [ "is_iterator", "structxt_1_1is__iterator.html", null ], + [ "is_iterator< E, void_t< decltype(*std::declval< const E >(), std::declval< const E >()==std::declval< const E >(), std::declval< const E >() !=std::declval< const E >(),++(*std::declval< E * >()),(*std::declval< E * >())++, std::true_type())> >", "structxt_1_1is__iterator_3_01_e_00_01void__t_3_01decltype_07_5std_1_1declval_3_01const_01_e_01_41da12c429c255d2c81e18d875fbe6e98.html", null ], + [ "is_narrowing_conversion", "structxt_1_1is__narrowing__conversion.html", null ], + [ "is_not_xdummy_iterator", "structxt_1_1is__not__xdummy__iterator.html", null ], + [ "is_not_xdummy_iterator< xdummy_iterator< is_const, CT > >", "structxt_1_1is__not__xdummy__iterator_3_01xdummy__iterator_3_01is__const_00_01_c_t_01_4_01_4.html", null ], + [ "is_reducer_options", "structxt_1_1is__reducer__options.html", null ], + [ "is_reducer_options_impl", "structxt_1_1is__reducer__options__impl.html", null ], + [ "is_reducer_options_impl< std::tuple< X... > >", "structxt_1_1is__reducer__options__impl_3_01std_1_1tuple_3_01_x_8_8_8_01_4_01_4.html", null ], + [ "is_specialization_of", "structxt_1_1is__specialization__of.html", null ], + [ "is_specialization_of< TT, TT< Ts... > >", "structxt_1_1is__specialization__of_3_01_t_t_00_01_t_t_3_01_ts_8_8_8_01_4_01_4.html", null ], + [ "is_xoptional_expression", "structxt_1_1is__xoptional__expression.html", null ], + [ "is_xtensor_expression", "structxt_1_1is__xtensor__expression.html", null ], + [ "keep_dims_type", "structxt_1_1keep__dims__type.html", null ], + [ "linear_assigner", "classxt_1_1linear__assigner.html", null ], + [ "linear_assigner< false >", "classxt_1_1linear__assigner_3_01false_01_4.html", null ], + [ "make_invalid_type", "structxt_1_1make__invalid__type.html", null ], + [ "make_void", "structxt_1_1make__void.html", null ], + [ "memory_range", "structxt_1_1memory__range.html", null ], + [ "meta_identity", "structxt_1_1meta__identity.html", null ], + [ "missing_type", "structxt_1_1missing__type.html", null ], + [ "nested_initializer_list", "structxt_1_1nested__initializer__list.html", null ], + [ "nested_initializer_list< T, 0 >", "structxt_1_1nested__initializer__list_3_01_t_00_010_01_4.html", null ], + [ "no_ownership", "structxt_1_1no__ownership.html", null ], + [ "noalias_proxy", "classxt_1_1noalias__proxy.html", null ], + [ "norm_type", "structxt_1_1norm__type.html", null ], + [ "numeric_constants", "structxt_1_1numeric__constants.html", null ], + [ "overlapping_memory_checker", "structxt_1_1overlapping__memory__checker.html", null ], + [ "overlapping_memory_checker< Dst, std::enable_if_t< has_memory_address< Dst >::value > >", "structxt_1_1overlapping__memory__checker_3_01_dst_00_01std_1_1enable__if__t_3_01has__memory__add979fb9a8b7b1983c9fb733f357d6c2fa.html", null ], + [ "overlapping_memory_checker_base", "structxt_1_1overlapping__memory__checker__base.html", null ], + [ "overlapping_memory_checker_traits", "structxt_1_1overlapping__memory__checker__traits.html", null ], + [ "overlapping_memory_checker_traits< E >", "structxt_1_1overlapping__memory__checker__traits_3_01_e_01_4.html", null ], + [ "overlapping_memory_checker_traits< E, std::enable_if_t< has_memory_address< E >::value > >", "structxt_1_1overlapping__memory__checker__traits_3_01_e_00_01std_1_1enable__if__t_3_01has__memor4c750fb1ec54f24555f6fb27c3a9d4ec.html", null ], + [ "overlapping_memory_checker_traits< E, std::enable_if_t::value &&is_crtp_base_of< xview_semantic, E >::value > >", "structxt_1_1overlapping__memory__checker__traits_3_01_e_00_01std_1_1enable__if__t_3_9has__memory9f28c8bceb6a84ea6f46c1fa50db17c9.html", null ], + [ "overlapping_memory_checker_traits< E, std::enable_if_t::value &&is_specialization_of< xfunction, E >::value > >", "structxt_1_1overlapping__memory__checker__traits_3_01_e_00_01std_1_1enable__if__t_3_9has__memory7631490e58e2e554d47f900b4789ad50.html", null ], + [ "promote_shape", "structxt_1_1promote__shape.html", null ], + [ "promote_strides", "structxt_1_1promote__strides.html", null ], + [ "rebind_container", "structxt_1_1rebind__container.html", null ], + [ "rebind_container< X, C< T, A > >", "structxt_1_1rebind__container_3_01_x_00_01_c_3_01_t_00_01_a_01_4_01_4.html", null ], + [ "rebind_container< X, C< T, N > >", "structxt_1_1rebind__container_3_01_x_00_01_c_3_01_t_00_01_n_01_4_01_4.html", null ], + [ "rebind_container< X, svector< T, N, A, B > >", "structxt_1_1rebind__container_3_01_x_00_01svector_3_01_t_00_01_n_00_01_a_00_01_b_01_4_01_4.html", null ], + [ "reducer_options", "structxt_1_1reducer__options.html", "structxt_1_1reducer__options" ], + [ "remove_class", "structxt_1_1remove__class.html", null ], + [ "remove_class< R(C::*)(Args...) const >", "structxt_1_1remove__class_3_01_r_07_c_1_1_5_08_07_args_8_8_8_08_01const_01_4.html", null ], + [ "remove_class< R(C::*)(Args...)>", "structxt_1_1remove__class_3_01_r_07_c_1_1_5_08_07_args_8_8_8_08_4.html", null ], + [ "select_dim_mapping_type", "structxt_1_1select__dim__mapping__type.html", null ], + [ "select_dim_mapping_type< fixed_shape< I... > >", "structxt_1_1select__dim__mapping__type_3_01fixed__shape_3_01_i_8_8_8_01_4_01_4.html", null ], + [ "select_iterable_base", "structxt_1_1select__iterable__base.html", null ], + [ "select_layout", "structxt_1_1select__layout.html", null ], + [ "sequence_view", "classxt_1_1sequence__view.html", null ], + [ "squared_norm_type", "structxt_1_1squared__norm__type.html", null ], + [ "static_dimension", "structxt_1_1static__dimension.html", null ], + [ "static_string", "structxt_1_1static__string.html", null ], + [ "stepper_assigner", "classxt_1_1stepper__assigner.html", null ], + [ "stepper_tools", "structxt_1_1stepper__tools.html", null ], + [ "strided_loop_assigner", "classxt_1_1strided__loop__assigner.html", null ], + [ "svector", "classxt_1_1svector.html", null ], + [ "temporary_container", "structxt_1_1temporary__container.html", null ], + [ "temporary_container< xbuffer_adaptor< CP, O, A > >", "structxt_1_1temporary__container_3_01xbuffer__adaptor_3_01_c_p_00_01_o_00_01_a_01_4_01_4.html", null ], + [ "temporary_container< xiterator_adaptor< I, CI > >", "structxt_1_1temporary__container_3_01xiterator__adaptor_3_01_i_00_01_c_i_01_4_01_4.html", null ], + [ "temporary_container< xiterator_owner_adaptor< C, IG > >", "structxt_1_1temporary__container_3_01xiterator__owner__adaptor_3_01_c_00_01_i_g_01_4_01_4.html", null ], + [ "temporary_type", "structxt_1_1temporary__type.html", null ], + [ "temporary_type< T, void_t< typename std::decay_t< T >::temporary_type > >", "structxt_1_1temporary__type_3_01_t_00_01void__t_3_01typename_01std_1_1decay__t_3_01_t_01_4_1_1temporary__type_01_4_01_4.html", null ], + [ "temporary_type_from_tag", "structxt_1_1temporary__type__from__tag.html", null ], + [ "temporary_type_from_tag< xtensor_expression_tag, T >", "structxt_1_1temporary__type__from__tag_3_01xtensor__expression__tag_00_01_t_01_4.html", null ], + [ "tracking_allocator", "structxt_1_1tracking__allocator.html", "structxt_1_1tracking__allocator" ], + [ "transpose_error", "classxt_1_1transpose__error.html", null ], + [ "tuple_idx_of", "structxt_1_1tuple__idx__of.html", null ], + [ "tuple_idx_of_impl", "structxt_1_1tuple__idx__of__impl.html", null ], + [ "tuple_idx_of_impl< I, T, std::tuple< T, Types... > >", "structxt_1_1tuple__idx__of__impl_3_01_i_00_01_t_00_01std_1_1tuple_3_01_t_00_01_types_8_8_8_01_4_01_4.html", null ], + [ "tuple_idx_of_impl< I, T, std::tuple< U, Types... > >", "structxt_1_1tuple__idx__of__impl_3_01_i_00_01_t_00_01std_1_1tuple_3_01_u_00_01_types_8_8_8_01_4_01_4.html", null ], + [ "tuple_idx_of_impl< I, T, std::tuple<> >", "structxt_1_1tuple__idx__of__impl_3_01_i_00_01_t_00_01std_1_1tuple_3_4_01_4.html", null ], + [ "unaligned_mode", "structxt_1_1unaligned__mode.html", null ], + [ "uvector", "classxt_1_1uvector.html", null ], + [ "view_temporary_type", "structxt_1_1view__temporary__type.html", null ], + [ "xaccessible", "classxt_1_1xaccessible.html", "classxt_1_1xaccessible" ], + [ "xaccumulator_functor", "structxt_1_1xaccumulator__functor.html", null ], + [ "xall", "classxt_1_1xall.html", null ], + [ "xall_tag", "structxt_1_1xall__tag.html", null ], + [ "xarray_adaptor", "classxt_1_1xarray__adaptor.html", "classxt_1_1xarray__adaptor" ], + [ "xarray_container", "classxt_1_1xarray__container.html", "classxt_1_1xarray__container" ], + [ "xassign_traits", "classxt_1_1xassign__traits.html", null ], + [ "xaxis_iterator", "classxt_1_1xaxis__iterator.html", "classxt_1_1xaxis__iterator" ], + [ "xaxis_slice_iterator", "classxt_1_1xaxis__slice__iterator.html", "classxt_1_1xaxis__slice__iterator" ], + [ "xblockwise_reducer", "classxt_1_1xblockwise__reducer.html", null ], + [ "xbounded_iterator", "classxt_1_1xbounded__iterator.html", null ], + [ "xbroadcast", "classxt_1_1xbroadcast.html", "classxt_1_1xbroadcast" ], + [ "xbuffer_adaptor", "classxt_1_1xbuffer__adaptor.html", null ], + [ "xbuffer_adaptor_base", "classxt_1_1xbuffer__adaptor__base.html", null ], + [ "xchunk_iterator", "classxt_1_1xchunk__iterator.html", null ], + [ "xchunked_array", "classxt_1_1xchunked__array.html", null ], + [ "xchunked_assigner", "classxt_1_1xchunked__assigner.html", null ], + [ "xchunked_semantic", "classxt_1_1xchunked__semantic.html", null ], + [ "xchunked_view", "classxt_1_1xchunked__view.html", null ], + [ "xclosure", "structxt_1_1xclosure.html", null ], + [ "xclosure< E, disable_xexpression< std::decay_t< E > > >", "structxt_1_1xclosure_3_01_e_00_01disable__xexpression_3_01std_1_1decay__t_3_01_e_01_4_01_4_01_4.html", null ], + [ "xclosure< xshared_expression< E >, std::enable_if_t< true > >", "structxt_1_1xclosure_3_01xshared__expression_3_01_e_01_4_00_01std_1_1enable__if__t_3_01true_01_4_01_4.html", null ], + [ "xconst_accessible", "classxt_1_1xconst__accessible.html", "classxt_1_1xconst__accessible" ], + [ "xconst_iterable", "classxt_1_1xconst__iterable.html", "classxt_1_1xconst__iterable" ], + [ "xcontainer", "classxt_1_1xcontainer.html", "classxt_1_1xcontainer" ], + [ "xcontainer_inner_types", "structxt_1_1xcontainer__inner__types.html", null ], + [ "xcontainer_inner_types< xarray_adaptor< EC, L, SC, Tag > >", "structxt_1_1xcontainer__inner__types_3_01xarray__adaptor_3_01_e_c_00_01_l_00_01_s_c_00_01_tag_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xarray_container< EC, L, SC, Tag > >", "structxt_1_1xcontainer__inner__types_3_01xarray__container_3_01_e_c_00_01_l_00_01_s_c_00_01_tag_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xbroadcast< CT, X > >", "structxt_1_1xcontainer__inner__types_3_01xbroadcast_3_01_c_t_00_01_x_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xchunked_array< chunk_storage > >", "structxt_1_1xcontainer__inner__types_3_01xchunked__array_3_01chunk__storage_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xdynamic_view< CT, S, L, FST > >", "structxt_1_1xcontainer__inner__types_3_01xdynamic__view_3_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xfixed_adaptor< EC, S, L, SH, Tag > >", "structxt_1_1xcontainer__inner__types_3_01xfixed__adaptor_3_01_e_c_00_01_s_00_01_l_00_01_s_h_00_01_tag_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xfixed_container< ET, S, L, SH, Tag > >", "structxt_1_1xcontainer__inner__types_3_01xfixed__container_3_01_e_t_00_01_s_00_01_l_00_01_s_h_00_01_tag_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xfunction< F, CT... > >", "structxt_1_1xcontainer__inner__types_3_01xfunction_3_01_f_00_01_c_t_8_8_8_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xfunctor_adaptor< F, CT > >", "structxt_1_1xcontainer__inner__types_3_01xfunctor__adaptor_3_01_f_00_01_c_t_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xfunctor_view< F, CT > >", "structxt_1_1xcontainer__inner__types_3_01xfunctor__view_3_01_f_00_01_c_t_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xgenerator< C, R, S > >", "structxt_1_1xcontainer__inner__types_3_01xgenerator_3_01_c_00_01_r_00_01_s_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xindex_view< CT, I > >", "structxt_1_1xcontainer__inner__types_3_01xindex__view_3_01_c_t_00_01_i_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xmasked_view< CTD, CTM > >", "structxt_1_1xcontainer__inner__types_3_01xmasked__view_3_01_c_t_d_00_01_c_t_m_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xoptional_assembly< VE, FE > >", "structxt_1_1xcontainer__inner__types_3_01xoptional__assembly_3_01_v_e_00_01_f_e_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xoptional_assembly_adaptor< VEC, FEC > >", "structxt_1_1xcontainer__inner__types_3_01xoptional__assembly__adaptor_3_01_v_e_c_00_01_f_e_c_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xreducer< F, CT, X, O > >", "structxt_1_1xcontainer__inner__types_3_01xreducer_3_01_f_00_01_c_t_00_01_x_00_01_o_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xscalar< CT > >", "structxt_1_1xcontainer__inner__types_3_01xscalar_3_01_c_t_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xstrided_view< CT, S, L, FST > >", "structxt_1_1xcontainer__inner__types_3_01xstrided__view_3_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xtensor_adaptor< EC, N, L, Tag > >", "structxt_1_1xcontainer__inner__types_3_01xtensor__adaptor_3_01_e_c_00_01_n_00_01_l_00_01_tag_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xtensor_container< EC, N, L, Tag > >", "structxt_1_1xcontainer__inner__types_3_01xtensor__container_3_01_e_c_00_01_n_00_01_l_00_01_tag_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xtensor_view< EC, N, L, Tag > >", "structxt_1_1xcontainer__inner__types_3_01xtensor__view_3_01_e_c_00_01_n_00_01_l_00_01_tag_01_4_01_4.html", null ], + [ "xcontainer_inner_types< xview< CT, S... > >", "structxt_1_1xcontainer__inner__types_3_01xview_3_01_c_t_00_01_s_8_8_8_01_4_01_4.html", null ], + [ "xcontainer_iterable_types", "structxt_1_1xcontainer__iterable__types.html", null ], + [ "xcontainer_semantic", "classxt_1_1xcontainer__semantic.html", "classxt_1_1xcontainer__semantic" ], + [ "xcontiguous_iterable", "classxt_1_1xcontiguous__iterable.html", "classxt_1_1xcontiguous__iterable" ], + [ "xcsv_config", "structxt_1_1xcsv__config.html", null ], + [ "xdrop_slice", "classxt_1_1xdrop__slice.html", null ], + [ "xdummy_iterator", "classxt_1_1xdummy__iterator.html", null ], + [ "xdynamic_view", "classxt_1_1xdynamic__view.html", "classxt_1_1xdynamic__view" ], + [ "xellipsis_tag", "structxt_1_1xellipsis__tag.html", null ], + [ "xexpression", "classxt_1_1xexpression.html", "classxt_1_1xexpression" ], + [ "xexpression_assigner", "classxt_1_1xexpression__assigner.html", null ], + [ "xexpression_assigner_base", "classxt_1_1xexpression__assigner__base.html", null ], + [ "xexpression_assigner_base< xoptional_expression_tag >", "classxt_1_1xexpression__assigner__base_3_01xoptional__expression__tag_01_4.html", null ], + [ "xexpression_assigner_base< xtensor_expression_tag >", "classxt_1_1xexpression__assigner__base_3_01xtensor__expression__tag_01_4.html", null ], + [ "xexpression_holder", "classxt_1_1xexpression__holder.html", null ], + [ "xexpression_tag", "structxt_1_1xexpression__tag.html", null ], + [ "xfiltration", "classxt_1_1xfiltration.html", "classxt_1_1xfiltration" ], + [ "xfixed_adaptor", "classxt_1_1xfixed__adaptor.html", "classxt_1_1xfixed__adaptor" ], + [ "xfixed_container", "classxt_1_1xfixed__container.html", "classxt_1_1xfixed__container" ], + [ "xfunction", "classxt_1_1xfunction.html", "classxt_1_1xfunction" ], + [ "xfunction_cache", "structxt_1_1xfunction__cache.html", null ], + [ "xfunction_iterator", "classxt_1_1xfunction__iterator.html", null ], + [ "xfunction_stepper", "classxt_1_1xfunction__stepper.html", null ], + [ "xfunctor_adaptor", "classxt_1_1xfunctor__adaptor.html", "classxt_1_1xfunctor__adaptor" ], + [ "xfunctor_applier_base", "classxt_1_1xfunctor__applier__base.html", "classxt_1_1xfunctor__applier__base" ], + [ "xfunctor_iterator", "classxt_1_1xfunctor__iterator.html", null ], + [ "xfunctor_stepper", "classxt_1_1xfunctor__stepper.html", null ], + [ "xfunctor_view", "classxt_1_1xfunctor__view.html", "classxt_1_1xfunctor__view" ], + [ "xfunctor_view_temporary_type", "structxt_1_1xfunctor__view__temporary__type.html", null ], + [ "xgenerator", "classxt_1_1xgenerator.html", "classxt_1_1xgenerator" ], + [ "xindex_view", "classxt_1_1xindex__view.html", "classxt_1_1xindex__view" ], + [ "xindexed_stepper", "classxt_1_1xindexed__stepper.html", null ], + [ "xinitial", "structxt_1_1xinitial.html", null ], + [ "xiterable", "classxt_1_1xiterable.html", "classxt_1_1xiterable" ], + [ "xiterable_inner_types", "structxt_1_1xiterable__inner__types.html", null ], + [ "xiterable_inner_types< xarray_adaptor< EC, L, SC, Tag > >", "structxt_1_1xiterable__inner__types_3_01xarray__adaptor_3_01_e_c_00_01_l_00_01_s_c_00_01_tag_01_4_01_4.html", null ], + [ "xiterable_inner_types< xarray_container< EC, L, SC, Tag > >", "structxt_1_1xiterable__inner__types_3_01xarray__container_3_01_e_c_00_01_l_00_01_s_c_00_01_tag_01_4_01_4.html", null ], + [ "xiterable_inner_types< xbroadcast< CT, X > >", "structxt_1_1xiterable__inner__types_3_01xbroadcast_3_01_c_t_00_01_x_01_4_01_4.html", null ], + [ "xiterable_inner_types< xchunked_array< chunk_storage > >", "structxt_1_1xiterable__inner__types_3_01xchunked__array_3_01chunk__storage_01_4_01_4.html", null ], + [ "xiterable_inner_types< xdynamic_view< CT, S, L, FST > >", "structxt_1_1xiterable__inner__types_3_01xdynamic__view_3_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4_01_4.html", null ], + [ "xiterable_inner_types< xfixed_adaptor< EC, S, L, SH, Tag > >", "structxt_1_1xiterable__inner__types_3_01xfixed__adaptor_3_01_e_c_00_01_s_00_01_l_00_01_s_h_00_01_tag_01_4_01_4.html", null ], + [ "xiterable_inner_types< xfixed_container< ET, S, L, SH, Tag > >", "structxt_1_1xiterable__inner__types_3_01xfixed__container_3_01_e_t_00_01_s_00_01_l_00_01_s_h_00_01_tag_01_4_01_4.html", null ], + [ "xiterable_inner_types< xfunction< F, CT... > >", "structxt_1_1xiterable__inner__types_3_01xfunction_3_01_f_00_01_c_t_8_8_8_01_4_01_4.html", null ], + [ "xiterable_inner_types< xgenerator< C, R, S > >", "structxt_1_1xiterable__inner__types_3_01xgenerator_3_01_c_00_01_r_00_01_s_01_4_01_4.html", null ], + [ "xiterable_inner_types< xindex_view< CT, I > >", "structxt_1_1xiterable__inner__types_3_01xindex__view_3_01_c_t_00_01_i_01_4_01_4.html", null ], + [ "xiterable_inner_types< xmasked_view< CTD, CTM > >", "structxt_1_1xiterable__inner__types_3_01xmasked__view_3_01_c_t_d_00_01_c_t_m_01_4_01_4.html", null ], + [ "xiterable_inner_types< xoptional_assembly< VE, FE > >", "structxt_1_1xiterable__inner__types_3_01xoptional__assembly_3_01_v_e_00_01_f_e_01_4_01_4.html", null ], + [ "xiterable_inner_types< xoptional_assembly_adaptor< VEC, FEC > >", "structxt_1_1xiterable__inner__types_3_01xoptional__assembly__adaptor_3_01_v_e_c_00_01_f_e_c_01_4_01_4.html", null ], + [ "xiterable_inner_types< xreducer< F, CT, X, O > >", "structxt_1_1xiterable__inner__types_3_01xreducer_3_01_f_00_01_c_t_00_01_x_00_01_o_01_4_01_4.html", null ], + [ "xiterable_inner_types< xrepeat< CT, R > >", "structxt_1_1xiterable__inner__types_3_01xrepeat_3_01_c_t_00_01_r_01_4_01_4.html", null ], + [ "xiterable_inner_types< xscalar< CT > >", "structxt_1_1xiterable__inner__types_3_01xscalar_3_01_c_t_01_4_01_4.html", null ], + [ "xiterable_inner_types< xstrided_view< CT, S, L, FST > >", "structxt_1_1xiterable__inner__types_3_01xstrided__view_3_01_c_t_00_01_s_00_01_l_00_01_f_s_t_01_4_01_4.html", null ], + [ "xiterable_inner_types< xtensor_adaptor< EC, N, L, Tag > >", "structxt_1_1xiterable__inner__types_3_01xtensor__adaptor_3_01_e_c_00_01_n_00_01_l_00_01_tag_01_4_01_4.html", null ], + [ "xiterable_inner_types< xtensor_container< EC, N, L, Tag > >", "structxt_1_1xiterable__inner__types_3_01xtensor__container_3_01_e_c_00_01_n_00_01_l_00_01_tag_01_4_01_4.html", null ], + [ "xiterable_inner_types< xtensor_view< EC, N, L, Tag > >", "structxt_1_1xiterable__inner__types_3_01xtensor__view_3_01_e_c_00_01_n_00_01_l_00_01_tag_01_4_01_4.html", null ], + [ "xiterable_inner_types< xview< CT, S... > >", "structxt_1_1xiterable__inner__types_3_01xview_3_01_c_t_00_01_s_8_8_8_01_4_01_4.html", null ], + [ "xiterator", "classxt_1_1xiterator.html", null ], + [ "xiterator_adaptor", "classxt_1_1xiterator__adaptor.html", null ], + [ "xiterator_owner_adaptor", "classxt_1_1xiterator__owner__adaptor.html", null ], + [ "xkeep_slice", "classxt_1_1xkeep__slice.html", null ], + [ "xmasked_value", "classxt_1_1xmasked__value.html", null ], + [ "xmasked_view", "classxt_1_1xmasked__view.html", "classxt_1_1xmasked__view" ], + [ "xmasked_view_stepper", "classxt_1_1xmasked__view__stepper.html", null ], + [ "xmultiindex_iterator", "classxt_1_1xmultiindex__iterator.html", null ], + [ "xnewaxis", "classxt_1_1xnewaxis.html", null ], + [ "xnewaxis_tag", "structxt_1_1xnewaxis__tag.html", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html", "classxt_1_1xoptional__assembly" ], + [ "xoptional_assembly_adaptor", "classxt_1_1xoptional__assembly__adaptor.html", "classxt_1_1xoptional__assembly__adaptor" ], + [ "xoptional_assembly_base", "classxt_1_1xoptional__assembly__base.html", "classxt_1_1xoptional__assembly__base" ], + [ "xoptional_assembly_linear_iterator", "classxt_1_1xoptional__assembly__linear__iterator.html", null ], + [ "xoptional_assembly_linear_iterator_traits", "structxt_1_1xoptional__assembly__linear__iterator__traits.html", null ], + [ "xoptional_assembly_stepper", "classxt_1_1xoptional__assembly__stepper.html", null ], + [ "xoptional_assembly_storage", "classxt_1_1xoptional__assembly__storage.html", null ], + [ "xoptional_comparable", "structxt_1_1xoptional__comparable.html", null ], + [ "xoptional_expression_tag", "structxt_1_1xoptional__expression__tag.html", null ], + [ "xproxy_inner_types", "structxt_1_1xproxy__inner__types.html", null ], + [ "xrange", "classxt_1_1xrange.html", null ], + [ "xrange_adaptor", "structxt_1_1xrange__adaptor.html", null ], + [ "xreducer", "classxt_1_1xreducer.html", "classxt_1_1xreducer" ], + [ "xreducer_functors", "structxt_1_1xreducer__functors.html", null ], + [ "xreducer_shape_type", "structxt_1_1xreducer__shape__type.html", null ], + [ "xreducer_shape_type< fixed_shape< I... >, fixed_shape< J... >, O >", "structxt_1_1xreducer__shape__type_3_01fixed__shape_3_01_i_8_8_8_01_4_00_01fixed__shape_3_01_j_8_8_8_01_4_00_01_o_01_4.html", null ], + [ "xreducer_shape_type< fixed_shape< I... >, std::array< I2, N2 >, std::false_type >", "structxt_1_1xreducer__shape__type_3_01fixed__shape_3_01_i_8_8_8_01_4_00_01std_1_1array_3_01_i2_0113732d5b63b22c20cb89d3a7b591d8f.html", null ], + [ "xreducer_shape_type< fixed_shape< I... >, std::array< I2, N2 >, std::true_type >", "structxt_1_1xreducer__shape__type_3_01fixed__shape_3_01_i_8_8_8_01_4_00_01std_1_1array_3_01_i2_06680ea94625f20ef8cb3bcfb83eeaa0c.html", null ], + [ "xreducer_shape_type< std::array< I1, N1 >, std::array< I2, N2 >, std::false_type >", "structxt_1_1xreducer__shape__type_3_01std_1_1array_3_01_i1_00_01_n1_01_4_00_01std_1_1array_3_01_f0fe2e231e25d4e5852b877ba4b36e02.html", null ], + [ "xreducer_shape_type< std::array< I1, N1 >, std::array< I2, N2 >, std::true_type >", "structxt_1_1xreducer__shape__type_3_01std_1_1array_3_01_i1_00_01_n1_01_4_00_01std_1_1array_3_01_c677fa36e83a1c564b51c5abf4a0c7d9.html", null ], + [ "xreducer_stepper", "classxt_1_1xreducer__stepper.html", null ], + [ "xrepeat", "classxt_1_1xrepeat.html", "classxt_1_1xrepeat" ], + [ "xrepeat_stepper", "classxt_1_1xrepeat__stepper.html", null ], + [ "xscalar", "classxt_1_1xscalar.html", "classxt_1_1xscalar" ], + [ "xscalar_stepper", "classxt_1_1xscalar__stepper.html", null ], + [ "xsemantic_base", "classxt_1_1xsemantic__base.html", "classxt_1_1xsemantic__base" ], + [ "xsharable_expression", "classxt_1_1xsharable__expression.html", null ], + [ "xshared_expression", "classxt_1_1xshared__expression.html", "classxt_1_1xshared__expression" ], + [ "xslice", "classxt_1_1xslice.html", null ], + [ "xstepped_range", "classxt_1_1xstepped__range.html", null ], + [ "xstepper", "classxt_1_1xstepper.html", null ], + [ "xstrided_container", "classxt_1_1xstrided__container.html", "classxt_1_1xstrided__container" ], + [ "xstrided_view", "classxt_1_1xstrided__view.html", "classxt_1_1xstrided__view" ], + [ "xstrided_view_base", "classxt_1_1xstrided__view__base.html", "classxt_1_1xstrided__view__base" ], + [ "xtensor_adaptor", "classxt_1_1xtensor__adaptor.html", "classxt_1_1xtensor__adaptor" ], + [ "xtensor_container", "classxt_1_1xtensor__container.html", "classxt_1_1xtensor__container" ], + [ "xtensor_expression_tag", "structxt_1_1xtensor__expression__tag.html", null ], + [ "xtensor_view", "classxt_1_1xtensor__view.html", "classxt_1_1xtensor__view" ], + [ "xvectorizer", "classxt_1_1xvectorizer.html", null ], + [ "xview", "classxt_1_1xview.html", "classxt_1_1xview" ], + [ "xview_semantic", "classxt_1_1xview__semantic.html", "classxt_1_1xview__semantic" ], + [ "xview_shape_type", "structxt_1_1xview__shape__type.html", null ], + [ "xview_shape_type< fixed_shape< I... >, S... >", "structxt_1_1xview__shape__type_3_01fixed__shape_3_01_i_8_8_8_01_4_00_01_s_8_8_8_01_4.html", null ], + [ "xview_shape_type< std::array< I, L >, S... >", "structxt_1_1xview__shape__type_3_01std_1_1array_3_01_i_00_01_l_01_4_00_01_s_8_8_8_01_4.html", null ], + [ "xview_stepper", "classxt_1_1xview__stepper.html", null ] + ] ], + [ "xt_simd", null, [ + [ "aligned_allocator", "classxt__simd_1_1aligned__allocator.html", null ], + [ "aligned_mode", "structxt__simd_1_1aligned__mode.html", null ], + [ "allocator_alignment", "structxt__simd_1_1allocator__alignment.html", null ], + [ "container_alignment", "structxt__simd_1_1container__alignment.html", null ], + [ "is_batch_bool", "structxt__simd_1_1is__batch__bool.html", null ], + [ "is_batch_complex", "structxt__simd_1_1is__batch__complex.html", null ], + [ "revert_simd_traits", "structxt__simd_1_1revert__simd__traits.html", null ], + [ "simd_condition", "structxt__simd_1_1simd__condition.html", null ], + [ "simd_traits", "structxt__simd_1_1simd__traits.html", null ], + [ "unaligned_mode", "structxt__simd_1_1unaligned__mode.html", null ] + ] ], + [ "xtl", null, [ + [ "conjunction", "structxtl_1_1conjunction.html", null ] + ] ] +]; \ No newline at end of file diff --git a/bc_s.png b/bc_s.png new file mode 100644 index 000000000..224b29aa9 Binary files /dev/null and b/bc_s.png differ diff --git a/bc_sd.png b/bc_sd.png new file mode 100644 index 000000000..31ca888dc Binary files /dev/null and b/bc_sd.png differ diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt deleted file mode 100644 index 9928eb155..000000000 --- a/benchmark/CMakeLists.txt +++ /dev/null @@ -1,146 +0,0 @@ -############################################################################ -# Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht # -# # -# Distributed under the terms of the BSD 3-Clause License. # -# # -# The full license is in the file LICENSE, distributed with this software. # -############################################################################ - -cmake_minimum_required(VERSION 3.22) -include(FetchContent) - -if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) - project(xtensor-benchmark) - - find_package(xtensor REQUIRED CONFIG) - set(XTENSOR_INCLUDE_DIR ${xtensor_INCLUDE_DIRS}) -endif () - -message(STATUS "Forcing tests build type to Release") -set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE) - -include(CheckCXXCompilerFlag) - -string(TOUPPER "${CMAKE_BUILD_TYPE}" U_CMAKE_BUILD_TYPE) - -if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Intel") - CHECK_CXX_COMPILER_FLAG(-march=native arch_native_supported) - if(arch_native_supported AND NOT CMAKE_CXX_FLAGS MATCHES "-march") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native") - endif() - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -g -Wunused-parameter -Wextra -Wreorder") - - if(NOT "${CMAKE_CXX_SIMULATE_ID}" STREQUAL "MSVC") - CHECK_CXX_COMPILER_FLAG("-std=c++20" HAS_CPP20_FLAG) - if (HAS_CPP20_FLAG) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20") - else() - message(FATAL_ERROR "Unsupported compiler -- xtensor requires C++17 support!") - endif() - endif() - - # Enable link time optimization and set the default symbol - # visibility to hidden (very important to obtain small binaries) - if (NOT ${U_CMAKE_BUILD_TYPE} MATCHES DEBUG) - # Default symbol visibility - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") - - # Check for Link Time Optimization support - # (GCC/Clang) - # LTO had to be removed as google benchmark doesn't build with it - # CHECK_CXX_COMPILER_FLAG("-flto" HAS_LTO_FLAG) - # if (HAS_LTO_FLAG) - # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto") - # endif() - - # Intel equivalent to LTO is called IPO - if (CMAKE_CXX_COMPILER_ID MATCHES "Intel") - CHECK_CXX_COMPILER_FLAG("-ipo" HAS_IPO_FLAG) - if (HAS_IPO_FLAG) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ipo") - endif() - endif() - endif() -endif() - -if(MSVC) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc /MP /bigobj") - set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO) - foreach(flag_var - CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE - CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) - string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}") - endforeach() -endif() - - -if(DOWNLOAD_GBENCHMARK OR GBENCHMARK_SRC_DIR) - FetchContent_Declare(googletest - GIT_REPOSITORY https://github.com/google/googletest.git - GIT_TAG main) - - FetchContent_Declare(googlebenchmark - GIT_REPOSITORY https://github.com/google/benchmark.git - GIT_TAG main) # need main for benchmark::benchmark - - FetchContent_MakeAvailable( - googletest - googlebenchmark) - set(GBENCHMARK_INCLUDE_DIRS "${googlebenchmark_SOURCE_DIR}/include") - set(GBENCHMARK_LIBRARIES benchmark) -else() - find_package(benchmark REQUIRED) -endif() - -find_package(xsimd) -if (xsimd_FOUND) - include_directories(${xsimd_INCLUDE_DIRS}) - add_definitions("-DXTENSOR_USE_XSIMD=1") -endif() - -include_directories(${XTENSOR_INCLUDE_DIR}) -include_directories(${GBENCHMARK_INCLUDE_DIRS}) - -set(XTENSOR_BENCHMARK - benchmark_assign.cpp - benchmark_builder.cpp - benchmark_container.cpp - benchmark_creation.cpp - benchmark_increment_stepper.cpp - benchmark_lambda_expressions.cpp - benchmark_math.cpp - benchmark_random.cpp - benchmark_reducer.cpp - benchmark_views.cpp - benchmark_xshape.cpp - benchmark_view_access.cpp - benchmark_view_assignment.cpp - benchmark_view_adapt.cpp - benchmark_stl.cpp - main.cpp -) - - -set(XTENSOR_BENCHMARK_TARGET benchmark_xtensor) -add_executable(${XTENSOR_BENCHMARK_TARGET} EXCLUDE_FROM_ALL ${XTENSOR_BENCHMARK} ${XTENSOR_HEADERS}) -target_link_libraries(${XTENSOR_BENCHMARK_TARGET} PUBLIC xtensor ${GBENCHMARK_LIBRARIES}) - -if(XTENSOR_USE_TBB) - target_compile_definitions(${XTENSOR_BENCHMARK_TARGET} PUBLIC XTENSOR_USE_TBB) - target_include_directories(${XTENSOR_BENCHMARK_TARGET} PUBLIC ${TBB_INCLUDE_DIRS}) - target_link_libraries(${XTENSOR_BENCHMARK_TARGET} PUBLIC ${TBB_LIBRARIES}) -endif() -if(XTENSOR_USE_OPENMP) - target_compile_definitions(${XTENSOR_BENCHMARK_TARGET} PUBLIC XTENSOR_USE_OPENMP) -endif() - -add_custom_target(xbenchmark - COMMAND benchmark_xtensor - DEPENDS ${XTENSOR_BENCHMARK_TARGET}) - -add_custom_target(xpowerbench - COMMAND echo "sudo needed to set cpu power governor to performance" - COMMAND sudo cpupower frequency-set --governor performance - COMMAND benchmark_xtensor --benchmark_out=results.csv --benchmark_out_format=csv - COMMAND sudo cpupower frequency-set --governor powersave - DEPENDS ${XTENSOR_BENCHMARK_TARGET}) diff --git a/benchmark/benchmark_adapter.cpp b/benchmark/benchmark_adapter.cpp deleted file mode 100644 index 3a76dcb7e..000000000 --- a/benchmark/benchmark_adapter.cpp +++ /dev/null @@ -1,146 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -// #include "xtensor/core/core/xshape.hpp" -#include "xtensor/containers/xadapt.hpp" -#include "xtensor/containers/xstorage.hpp" -#include "xtensor/core/xnoalias.hpp" -#include "xtensor/utils/xutils.hpp" - -namespace xt -{ - template - void shape_array_adapter(benchmark::State& state) - { - const V a({1, 2, 3, 4}); - const V b({1, 2, 3, 4}); - using value_type = typename V::value_type; - - for (auto _ : state) - { - xtensor result(std::array({4})); - auto aa = xt::adapt(a); - auto ab = xt::adapt(b); - xt::noalias(result) = aa + ab; - benchmark::DoNotOptimize(result.data()); - } - } - - template - void shape_array_adapter_result(benchmark::State& state) - { - const V a({1, 2, 3, 4}); - const V b({1, 2, 3, 4}); - - for (auto _ : state) - { - V res({0, 0, 0, 0}); - auto aa = xt::adapt(a); - auto ab = xt::adapt(b); - auto ar = xt::adapt(res); - xt::noalias(ar) = aa + ab; - benchmark::DoNotOptimize(ar.data()); - } - } - - template - void shape_array_adapter_result_copy(benchmark::State& state) - { - const V a({1, 2, 3, 4}); - const V b({1, 2, 3, 4}); - - for (auto _ : state) - { - V res({0, 0, 0, 0}); - auto aa = xt::adapt(a); - auto ab = xt::adapt(b); - auto ar = xt::adapt(res); - auto fun = aa + ab; - std::copy(fun.linear_cbegin(), fun.linear_cend(), ar.linear_begin()); - benchmark::DoNotOptimize(ar.data()); - } - } - - template - void shape_array_adapter_result_transform(benchmark::State& state) - { - const V a({1, 2, 3, 4}); - const V b({1, 2, 3, 4}); - - for (auto _ : state) - { - V res({0, 0, 0, 0}); - auto aa = xt::adapt(a); - auto ab = xt::adapt(b); - auto ar = xt::adapt(res); - auto fun = aa + ab; - std::transform( - fun.linear_cbegin(), - fun.linear_cend(), - ar.linear_begin(), - [](typename decltype(fun)::value_type x) - { - return static_cast(x); - } - ); - benchmark::DoNotOptimize(ar.data()); - } - } - - template - void shape_no_adapter(benchmark::State& state) - { - V a({1, 2, 3, 4}); - V b({1, 2, 3, 4}); - - for (auto _ : state) - { - V result({0, 0, 0, 0}); - auto n = std::distance(a.begin(), a.end()); - for (std::size_t i = 0; i < n; ++i) - { - result[i] = a[i] + b[i]; - } - benchmark::DoNotOptimize(result.data()); - } - } - - using array_type = std::array; - // using array_type_ll = std::array; - using array_type_ll = std::array; - using uvector_type = xt::uvector>; - using uvector_type_i64 = xt::uvector>; - using uvector_type_i64_16 = xt::uvector>; - using uvector_type_i64_ra = xt::uvector>; - - using small_type = xt::svector>; - using small_type_d = xt::svector>; - - // BENCHMARK_TEMPLATE(shape_array_adapter, array_type); - // BENCHMARK_TEMPLATE(shape_array_adapter, uvector_type); - // BENCHMARK_TEMPLATE(shape_array_adapter, uvector_type_i64); - // BENCHMARK_TEMPLATE(shape_array_adapter, uvector_type_i64_ra); - // BENCHMARK_TEMPLATE(shape_array_adapter, std::vector); - // BENCHMARK_TEMPLATE(shape_array_adapter, small_type); - // BENCHMARK_TEMPLATE(shape_array_adapter, small_type_d); - // BENCHMARK_TEMPLATE(shape_array_adapter_result, small_type); - // BENCHMARK_TEMPLATE(shape_array_adapter_result, small_type_d); - BENCHMARK_TEMPLATE(shape_array_adapter_result, array_type); - // BENCHMARK_TEMPLATE(shape_array_adapter_result, array_type_ll); - // BENCHMARK_TEMPLATE(shape_array_adapter_result_2, array_type); - BENCHMARK_TEMPLATE(shape_array_adapter_result_copy, array_type); - BENCHMARK_TEMPLATE(shape_array_adapter_result_transform, array_type); - // // BENCHMARK_TEMPLATE(shape_array_adapter_result_2, array_type_ll); - BENCHMARK_TEMPLATE(shape_no_adapter, array_type); - // BENCHMARK_TEMPLATE(shape_no_adapter, std::vector); - // BENCHMARK_TEMPLATE(shape_no_adapter, uvector_type_i64); - // BENCHMARK_TEMPLATE(shape_no_adapter, uvector_type_i64_ra); - // BENCHMARK_TEMPLATE(shape_no_adapter, uvector_type_i64_16); -} diff --git a/benchmark/benchmark_assign.cpp b/benchmark/benchmark_assign.cpp deleted file mode 100644 index b9efb341e..000000000 --- a/benchmark/benchmark_assign.cpp +++ /dev/null @@ -1,227 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#ifndef BENCHMARK_ASSIGN_HPP -#define BENCHMARK_ASSIGN_HPP - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xnoalias.hpp" - -namespace xt -{ - namespace assign - { - - /**************************** - * Benchmark initialization * - ****************************/ - - template - inline void init_benchmark_data(V& lhs, V& rhs, std::size_t size0, std::size_t size1) - { - using T = typename V::value_type; - for (std::size_t i = 0; i < size0; ++i) - { - for (std::size_t j = 0; j < size1; ++j) - { - lhs(i, j) = T(0.5) * T(j) / T(j + 1) + std::sqrt(T(i)) * T(9.) / T(size1); - rhs(i, j) = T(10.2) / T(i + 2) + T(0.25) * T(j); - } - } - } - - template - inline void init_xtensor_benchmark(V& lhs, V& rhs, V& res, std::size_t size0, size_t size1) - { - lhs.resize({size0, size1}); - rhs.resize({size0, size1}); - res.resize({size0, size1}); - init_benchmark_data(lhs, rhs, size0, size1); - } - - template - inline void init_dl_xtensor_benchmark(V& lhs, V& rhs, V& res, std::size_t size0, size_t size1) - { - using strides_type = typename V::strides_type; - strides_type str = {size1, 1}; - lhs.resize({size0, size1}, str); - rhs.resize({size0, size1}, str); - res.resize({size0, size1}, str); - init_benchmark_data(lhs, rhs, size0, size1); - } - - template - inline auto assign_c_assign(benchmark::State& state) - { - using size_type = typename E::size_type; - - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - - for (auto _ : state) - { - size_type csize = x.size(); - for (size_type i = 0; i < csize; ++i) - { - res.data()[i] = 3.0 * x.data()[i] - 2.0 * y.data()[i]; - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_x_assign(benchmark::State& state) - { - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - for (auto _ : state) - { - xt::noalias(res) = 3.0 * x - 2.0 * y; - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_c_assign_ii(benchmark::State& state) - { - using size_type = typename E::size_type; - - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - - for (auto _ : state) - { - size_type csize = x.size(); - for (size_type i = 0; i < csize; ++i) - { - res.data()[i] = 3.0 * x.data()[i]; - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_x_assign_ii(benchmark::State& state) - { - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - for (auto _ : state) - { - xt::noalias(res) = 3.0 * x; - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_x_assign_iii(benchmark::State& state) - { - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - for (auto _ : state) - { - xt::noalias(res) = y * x; - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_c_assign_iii(benchmark::State& state) - { - using size_type = typename E::size_type; - - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - - for (auto _ : state) - { - size_type csize = x.size(); - for (size_type i = 0; i < csize; ++i) - { - res.data()[i] = x.data()[i] * y.data()[i]; - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_xstorageiter_copy(benchmark::State& state) - { - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - for (auto _ : state) - { - auto fun = 3.0 * x - 2.0 * y; - std::copy(fun.linear_cbegin(), fun.linear_cend(), res.linear_begin()); - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_xiter_copy(benchmark::State& state) - { - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - for (auto _ : state) - { - auto fun = 3.0 * x - 2.0 * y; - std::copy(fun.cbegin(), fun.cend(), res.begin()); - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_c_scalar_computed(benchmark::State& state) - { - using size_type = typename E::size_type; - - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - - for (auto _ : state) - { - size_type csize = res.size(); - for (size_type i = 0; i < csize; ++i) - { - res.storage()[i] += 3.123; - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto assign_x_scalar_computed(benchmark::State& state) - { - E x, y, res; - init_xtensor_benchmark(x, y, res, state.range(0), state.range(0)); - for (auto _ : state) - { - res += 3.123; - benchmark::DoNotOptimize(res.data()); - } - } - - BENCHMARK_TEMPLATE(assign_c_assign, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_x_assign, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_xiter_copy, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_xstorageiter_copy, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_c_assign_ii, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_x_assign_ii, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_x_assign_iii, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_c_assign_iii, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_x_assign, xt::xarray)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_x_assign, xt::xarray)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_x_assign, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_c_scalar_computed, xt::xtensor)->Range(32, 32 << 3); - BENCHMARK_TEMPLATE(assign_x_scalar_computed, xt::xtensor)->Range(32, 32 << 3); - } -} - -#endif diff --git a/benchmark/benchmark_builder.cpp b/benchmark/benchmark_builder.cpp deleted file mode 100644 index e25de39cb..000000000 --- a/benchmark/benchmark_builder.cpp +++ /dev/null @@ -1,221 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xnoalias.hpp" - -namespace xt -{ - template - inline auto builder_xarange(benchmark::State& state) - { - for (auto _ : state) - { - T res = xt::arange(0, 10000); - benchmark::DoNotOptimize(res.storage().data()); - } - } - - template - inline auto builder_xarange_manual(benchmark::State& state) - { - for (auto _ : state) - { - T res = T::from_shape({10000}); - for (std::size_t i = 0; i < 10000; ++i) - { - res.storage()[i] = i; - } - benchmark::DoNotOptimize(res.data()); - } - } - - inline auto builder_iota_vector(benchmark::State& state) - { - for (auto _ : state) - { - xt::uvector a{}; - a.resize(10000); - std::iota(a.begin(), a.end(), 0); - benchmark::DoNotOptimize(a.data()); - } - } - - template - inline auto builder_arange_for_loop_assign(benchmark::State& state) - { - for (auto _ : state) - { - auto expr = xt::arange(0, 10000); - T res = T::from_shape({10000}); - for (std::size_t i = 0; i < 10000; ++i) - { - res(i) = expr(i); - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto builder_arange_for_loop_iter_assign(benchmark::State& state) - { - for (auto _ : state) - { - auto expr = xt::arange(0, 10000); - T res = T::from_shape({10000}); - auto xend = expr.cend(); - auto reit = res.begin(); - for (auto it = expr.cbegin(); it != xend; ++it) - { - *reit++ = *it; - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto builder_arange_for_loop_iter_assign_backward(benchmark::State& state) - { - for (auto _ : state) - { - auto expr = xt::arange(0, 10000); - T res = T::from_shape({10000}); - auto xend = expr.cend(); - auto reit = res.begin(); - auto it = expr.cbegin(); - for (ptrdiff_t n = 10000; n > 0; --n) - { - *reit = *it; - ++it; - ++reit; - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto builder_arange_assign_iterator(benchmark::State& state) - { - for (auto _ : state) - { - auto xa = xt::arange(0, 10000); - T res = T::from_shape({10000}); - std::copy(xa.cbegin(), xa.cend(), res.begin()); - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto builder_std_iota(benchmark::State& state) - { - for (auto _ : state) - { - T res = T::from_shape({10000}); - std::iota(res.begin(), res.end(), 0); - benchmark::DoNotOptimize(res.data()); - } - } - - inline auto builder_ones(benchmark::State& state) - { - for (auto _ : state) - { - xt::xarray res = xt::ones({200, 200}); - benchmark::DoNotOptimize(res.data()); - } - } - - inline auto builder_ones_assign_iterator(benchmark::State& state) - { - auto xo = xt::ones({200, 200}); - for (auto _ : state) - { - xt::xarray res(xt::dynamic_shape{200, 200}); - auto xo = xt::ones({200, 200}); - std::copy(xo.begin(), xo.end(), res.begin()); - benchmark::DoNotOptimize(res.storage().data()); - } - } - - inline auto builder_ones_expr_for(benchmark::State& state) - { - auto xo = xt::ones({200, 200}); - - for (auto _ : state) - { - xt::xtensor res(xt::static_shape({200, 200})); - auto xo = xt::ones({200, 200}) * 0.15; - for (std::size_t i = 0; i < xo.shape()[0]; ++i) - { - for (std::size_t j = 0; j < xo.shape()[1]; ++j) - { - res(i, j) = xo(i, j); - } - } - benchmark::DoNotOptimize(res.storage().data()); - } - } - - inline auto builder_ones_expr(benchmark::State& state) - { - auto xo = xt::ones({200, 200}); - - for (auto _ : state) - { - xt::xtensor res = xt::ones({200, 200}) * 0.15; - benchmark::DoNotOptimize(res.storage().data()); - } - } - - inline auto builder_ones_expr_fill(benchmark::State& state) - { - auto xo = xt::ones({200, 200}); - - for (auto _ : state) - { - xt::xtensor res = xt::xtensor::from_shape({200, 200}); - std::fill(res.begin(), res.end(), 0.15); - benchmark::DoNotOptimize(res.storage().data()); - } - } - - inline auto builder_std_fill(benchmark::State& state) - { - for (auto _ : state) - { - xt::xarray res(xt::dynamic_shape{200, 200}); - std::fill(res.begin(), res.end(), 1); - benchmark::DoNotOptimize(res.storage().data()); - } - } - - BENCHMARK_TEMPLATE(builder_xarange, xarray); - BENCHMARK_TEMPLATE(builder_xarange, xtensor); - BENCHMARK_TEMPLATE(builder_xarange_manual, xarray); - BENCHMARK_TEMPLATE(builder_xarange_manual, xtensor); - BENCHMARK_TEMPLATE(builder_arange_for_loop_assign, xarray); - BENCHMARK_TEMPLATE(builder_arange_for_loop_assign, xtensor); - - BENCHMARK_TEMPLATE(builder_arange_assign_iterator, xarray); - BENCHMARK_TEMPLATE(builder_arange_assign_iterator, xtensor); - BENCHMARK_TEMPLATE(builder_arange_for_loop_iter_assign, xarray); - BENCHMARK_TEMPLATE(builder_arange_for_loop_iter_assign_backward, xarray); - BENCHMARK_TEMPLATE(builder_arange_for_loop_iter_assign, xtensor); - BENCHMARK_TEMPLATE(builder_arange_for_loop_iter_assign_backward, xtensor); - BENCHMARK_TEMPLATE(builder_std_iota, xarray); - BENCHMARK(builder_iota_vector); - BENCHMARK(builder_ones); - BENCHMARK(builder_ones_assign_iterator); - BENCHMARK(builder_ones_expr); - BENCHMARK(builder_ones_expr_fill); - BENCHMARK(builder_ones_expr_for); - BENCHMARK(builder_std_fill); -} diff --git a/benchmark/benchmark_container.cpp b/benchmark/benchmark_container.cpp deleted file mode 100644 index af51d1d19..000000000 --- a/benchmark/benchmark_container.cpp +++ /dev/null @@ -1,112 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include -#include -#include - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" - -namespace xt -{ - - namespace axpy_1d - { - - // BENCHMARK Initialization - template - inline void init_benchmark(E& x, E& y, E& res, typename E::size_type size) - { - x.resize({size}); - y.resize({size}); - res.resize({size}); - - using value_type = typename E::value_type; - using size_type = typename E::size_type; - for (size_type i = 0; i < size; ++i) - { - x(i) = 0.5 + value_type(i); - y(i) = 0.25 * value_type(i); - } - } - - template - inline auto container_iteration(benchmark::State& state) - { - using value_type = typename E::value_type; - E x, y, res; - init_benchmark(x, y, res, state.range(0)); - value_type a = value_type(2.7); - for (auto _ : state) - { - auto iterx = x.begin(); - auto itery = y.begin(); - for (auto iter = res.begin(); iter != res.end(); ++iter, ++iterx, ++itery) - { - *iter = a * (*iterx) + (*itery); - } - } - } - - BENCHMARK_TEMPLATE(container_iteration, xarray_container>)->Arg(1000); - BENCHMARK_TEMPLATE(container_iteration, xarray_container>)->Arg(1000); - BENCHMARK_TEMPLATE(container_iteration, xtensor_container, 1>)->Arg(1000); - BENCHMARK_TEMPLATE(container_iteration, xtensor_container, 1>)->Arg(1000); - - template - inline auto container_xiteration(benchmark::State& state) - { - using value_type = typename E::value_type; - E x, y, res; - init_benchmark(x, y, res, state.range(0)); - value_type a = value_type(2.7); - - for (auto _ : state) - { - auto iterx = x.begin(); - auto itery = y.begin(); - for (auto iter = res.begin(); iter != res.end(); ++iter, ++iterx, ++itery) - { - *iter = a * (*iterx) + (*itery); - } - } - } - - BENCHMARK_TEMPLATE(container_xiteration, xarray_container>)->Arg(1000); - BENCHMARK_TEMPLATE(container_xiteration, xarray_container>)->Arg(1000); - BENCHMARK_TEMPLATE(container_xiteration, xtensor_container, 1>)->Arg(1000); - BENCHMARK_TEMPLATE(container_xiteration, xtensor_container, 1>)->Arg(1000); - - template - inline auto container_indexing(benchmark::State& state) - { - using size_type = typename E::size_type; - using value_type = typename E::value_type; - E x, y, res; - init_benchmark(x, y, res, state.range(0)); - value_type a = value_type(2.7); - - for (auto _ : state) - { - size_type n = x.size(); - for (size_type i = 0; i < n; ++i) - { - res(i) = a * x(i) + y(i); - } - } - } - - BENCHMARK_TEMPLATE(container_indexing, xarray_container>)->Arg(1000); - BENCHMARK_TEMPLATE(container_indexing, xarray_container>)->Arg(1000); - BENCHMARK_TEMPLATE(container_indexing, xtensor_container, 1>)->Arg(1000); - BENCHMARK_TEMPLATE(container_indexing, xtensor_container, 1>)->Arg(1000); - } -} diff --git a/benchmark/benchmark_creation.cpp b/benchmark/benchmark_creation.cpp deleted file mode 100644 index 4410d2325..000000000 --- a/benchmark/benchmark_creation.cpp +++ /dev/null @@ -1,67 +0,0 @@ -/**************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xfixed.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/generators/xbuilder.hpp" - -namespace xt -{ - void benchmark_empty(benchmark::State& state) - { - for (auto _ : state) - { - auto e = xt::empty({5, 5}); - } - } - - template - void benchmark_from_shape(benchmark::State& state) - { - for (auto _ : state) - { - T e = T::from_shape({5, 5}); - } - } - - template - void benchmark_creation(benchmark::State& state) - { - for (auto _ : state) - { - T e(typename T::shape_type({5, 5})); - } - } - - void benchmark_empty_to_xtensor(benchmark::State& state) - { - for (auto _ : state) - { - xtensor e = xt::empty({5, 5}); - } - } - - void benchmark_empty_to_xarray(benchmark::State& state) - { - for (auto _ : state) - { - xarray e = xt::empty({5, 5}); - } - } - - BENCHMARK(benchmark_empty); - BENCHMARK(benchmark_empty_to_xtensor); - BENCHMARK(benchmark_empty_to_xarray); - BENCHMARK_TEMPLATE(benchmark_from_shape, xarray); - BENCHMARK_TEMPLATE(benchmark_from_shape, xtensor); - BENCHMARK_TEMPLATE(benchmark_creation, xarray); - BENCHMARK_TEMPLATE(benchmark_creation, xtensor); -} diff --git a/benchmark/benchmark_increment_stepper.cpp b/benchmark/benchmark_increment_stepper.cpp deleted file mode 100644 index 1557692e2..000000000 --- a/benchmark/benchmark_increment_stepper.cpp +++ /dev/null @@ -1,72 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/generators/xrandom.hpp" - -#define SHAPE 30, 30 -#define RANGE 3, 100 - -namespace xt -{ - namespace benchmark_xstepper - { - void stepper_stepper(benchmark::State& state) - { - std::vector shape = {SHAPE, std::size_t(state.range(0))}; - xt::xarray a = xt::random::rand(shape); - xt::xarray b = xt::random::rand(shape); - volatile double c = 0; - for (auto _ : state) - { - auto end = compute_size(shape); - auto it = a.stepper_begin(shape); - auto bit = b.stepper_begin(shape); - - xindex index(shape.size()); - xindex bindex(shape.size()); - - for (std::size_t i = 0; i < end; ++i) - { - c += *it + *bit; - stepper_tools::increment_stepper(bit, bindex, shape); - stepper_tools::increment_stepper(it, index, shape); - } - benchmark::DoNotOptimize(c); - } - } - - BENCHMARK(stepper_stepper)->Range(RANGE); - - void stepper_stepper_ref(benchmark::State& state) - { - std::vector shape = {SHAPE, std::size_t(state.range(0))}; - xt::xarray a = xt::random::rand(shape); - xt::xarray b = xt::random::rand(shape); - xindex index; - xindex bindex; - volatile double c = 0; - for (auto _ : state) - { - auto it = a.storage().begin(); - auto bit = b.storage().begin(); - auto end = a.storage().end(); - for (; it != end; ++it) - { - c += *it + *bit; - ++bit; - } - benchmark::DoNotOptimize(c); - } - } - - BENCHMARK(stepper_stepper_ref)->Range(RANGE); - } -} diff --git a/benchmark/benchmark_lambda_expressions.cpp b/benchmark/benchmark_lambda_expressions.cpp deleted file mode 100644 index 6c6c40a49..000000000 --- a/benchmark/benchmark_lambda_expressions.cpp +++ /dev/null @@ -1,74 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xmath.hpp" -#include "xtensor/core/xnoalias.hpp" -#include "xtensor/generators/xbuilder.hpp" - -namespace xt -{ - void lambda_cube(benchmark::State& state) - { - xtensor x = empty({state.range(0), state.range(0)}); - for (auto _ : state) - { - xtensor res = xt::cube(x); - benchmark::DoNotOptimize(res.data()); - } - } - - void xexpression_cube(benchmark::State& state) - { - xtensor x = empty({state.range(0), state.range(0)}); - for (auto _ : state) - { - xtensor res = x * x * x; - benchmark::DoNotOptimize(res.data()); - } - } - - void lambda_higher_pow(benchmark::State& state) - { - xtensor x = empty({state.range(0), state.range(0)}); - for (auto _ : state) - { - xtensor res = xt::pow<16>(x); - benchmark::DoNotOptimize(res.data()); - } - } - - void xsimd_higher_pow(benchmark::State& state) - { - xtensor x = empty({state.range(0), state.range(0)}); - for (auto _ : state) - { - xtensor res = xt::pow(x, 16); - benchmark::DoNotOptimize(res.data()); - } - } - - void xexpression_higher_pow(benchmark::State& state) - { - xtensor x = empty({state.range(0), state.range(0)}); - for (auto _ : state) - { - xtensor res = x * x * x * x * x * x * x * x * x * x * x * x * x * x * x * x; - benchmark::DoNotOptimize(res.data()); - } - } - - BENCHMARK(lambda_cube)->Range(32, 32 << 3); - BENCHMARK(xexpression_cube)->Range(32, 32 << 3); - BENCHMARK(lambda_higher_pow)->Range(32, 32 << 3); - BENCHMARK(xsimd_higher_pow)->Range(32, 32 << 3); - BENCHMARK(xexpression_higher_pow)->Range(32, 32 << 3); -} diff --git a/benchmark/benchmark_math.cpp b/benchmark/benchmark_math.cpp deleted file mode 100644 index c365551ea..000000000 --- a/benchmark/benchmark_math.cpp +++ /dev/null @@ -1,398 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include -#include -#include -#include - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xnoalias.hpp" - -// For how many sizes should math functions be tested? -#define MATH_RANGE 64, 64 - -namespace xt -{ - namespace math - { - // TODO use a fixture here to avoid initializing arrays everytime anew ... - - /**************************** - * Benchmark initialization * - ****************************/ - - template - inline void init_benchmark_data(V& lhs, V& rhs, std::size_t size0, std::size_t size1) - { - using T = typename V::value_type; - for (std::size_t i = 0; i < size0; ++i) - { - for (std::size_t j = 0; j < size1; ++j) - { - lhs(i, j) = T(0.5) * T(j) / T(j + 1) + std::sqrt(T(i)) * T(9.) / T(size1); - rhs(i, j) = T(10.2) / T(i + 2) + T(0.25) * T(j); - } - } - } - - template - inline void init_xtensor_benchmark(V& lhs, V& rhs, V& res, std::size_t size0, size_t size1) - { - lhs.resize({size0, size1}); - rhs.resize({size0, size1}); - res.resize({size0, size1}); - init_benchmark_data(lhs, rhs, size0, size1); - } - - template - inline void init_ext_benchmark(V& lhs, V& rhs, V& res, std::size_t size0, size_t size1) - { - lhs.resize(size0, size1); - rhs.resize(size0, size1); - res.resize(size0, size1); - init_benchmark_data(lhs, rhs, size0, size1); - } - - /*********************** - * Benchmark functions * - ***********************/ - - template - inline void math_xtensor_2(benchmark::State& state) - { - xtensor lhs, rhs, res; - init_xtensor_benchmark(lhs, rhs, res, state.range(0), state.range(0)); - - auto f = F(); - - for (auto _ : state) - { - xt::noalias(res) = f(lhs, rhs); - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline void math_xtensor_cpy_2(benchmark::State& state) - { - xtensor lhs, rhs, res; - init_xtensor_benchmark(lhs, rhs, res, state.range(0), state.range(0)); - - auto f = F(); - - for (auto _ : state) - { - auto fct = f(lhs, rhs); - std::copy(fct.linear_begin(), fct.linear_end(), res.linear_begin()); - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline void math_xtensor_1(benchmark::State& state) - { - xtensor lhs, rhs, res; - init_xtensor_benchmark(lhs, rhs, res, state.range(0), state.range(0)); - - auto f = F(); - - for (auto _ : state) - { - xt::noalias(res) = f(lhs); - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline auto math_ref_2(benchmark::State& state) - { - auto f = F(); - xtensor lhs, rhs, res; - init_xtensor_benchmark(lhs, rhs, res, state.range(0), state.range(0)); - size_t size = lhs.shape()[0] * lhs.shape()[1]; - - for (auto _ : state) - { - for (std::size_t i = 0; i < size; ++i) - { - res.data()[i] = f(lhs.data()[i], res.data()[i]); - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - inline void math_ref_1(benchmark::State& state) - { - auto f = F(); - xtensor lhs, rhs, res; - init_xtensor_benchmark(lhs, rhs, res, state.range(0), state.range(0)); - size_t size = lhs.shape()[0] * lhs.shape()[1]; - - for (auto _ : state) - { - for (std::size_t i = 0; i < size; ++i) - { - res.data()[i] = f(lhs.data()[i]); - } - benchmark::DoNotOptimize(res.data()); - } - } - - /********************** - * Benchmark functors * - **********************/ - -#define DEFINE_OP_FUNCTOR_2OP(OP, NAME) \ - struct NAME##_fn \ - { \ - template \ - inline auto operator()(const T& lhs, const T& rhs) const \ - { \ - return lhs OP rhs; \ - } \ - inline static std::string name() \ - { \ - return #NAME; \ - } \ - } - -#define DEFINE_FUNCTOR_1OP(FN) \ - struct FN##_fn \ - { \ - template \ - inline auto operator()(const T& x) const \ - { \ - using std::FN; \ - using xt::FN; \ - return FN(x); \ - } \ - inline static std::string name() \ - { \ - return #FN; \ - } \ - } - -#define DEFINE_FUNCTOR_2OP(FN) \ - struct FN##_fn \ - { \ - template \ - inline auto operator()(const T& lhs, const T& rhs) const \ - { \ - using std::FN; \ - using xt::FN; \ - return FN(lhs, rhs); \ - } \ - inline static std::string name() \ - { \ - return #FN; \ - } \ - } - - DEFINE_OP_FUNCTOR_2OP(+, add); - DEFINE_OP_FUNCTOR_2OP(-, sub); - DEFINE_OP_FUNCTOR_2OP(*, mul); - DEFINE_OP_FUNCTOR_2OP(/, div); - - DEFINE_FUNCTOR_1OP(exp); - DEFINE_FUNCTOR_1OP(exp2); - DEFINE_FUNCTOR_1OP(expm1); - DEFINE_FUNCTOR_1OP(log); - DEFINE_FUNCTOR_1OP(log10); - DEFINE_FUNCTOR_1OP(log2); - DEFINE_FUNCTOR_1OP(log1p); - - DEFINE_FUNCTOR_1OP(sin); - DEFINE_FUNCTOR_1OP(cos); - DEFINE_FUNCTOR_1OP(tan); - DEFINE_FUNCTOR_1OP(asin); - DEFINE_FUNCTOR_1OP(acos); - DEFINE_FUNCTOR_1OP(atan); - - DEFINE_FUNCTOR_1OP(sinh); - DEFINE_FUNCTOR_1OP(cosh); - DEFINE_FUNCTOR_1OP(tanh); - DEFINE_FUNCTOR_1OP(asinh); - DEFINE_FUNCTOR_1OP(acosh); - DEFINE_FUNCTOR_1OP(atanh); - - DEFINE_FUNCTOR_2OP(pow); - DEFINE_FUNCTOR_1OP(sqrt); - DEFINE_FUNCTOR_1OP(cbrt); - DEFINE_FUNCTOR_2OP(hypot); - - DEFINE_FUNCTOR_1OP(ceil); - DEFINE_FUNCTOR_1OP(floor); - DEFINE_FUNCTOR_1OP(trunc); - DEFINE_FUNCTOR_1OP(round); - DEFINE_FUNCTOR_1OP(nearbyint); - DEFINE_FUNCTOR_1OP(rint); - - /******************** - * benchmark groups * - ********************/ - - BENCHMARK_TEMPLATE(math_ref_2, add_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_2, add_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_cpy_2, add_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_2, sub_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_2, sub_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_cpy_2, sub_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_2, mul_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_2, mul_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_cpy_2, mul_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_2, div_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_2, div_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_cpy_2, div_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_1, exp_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, exp_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, exp2_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, exp2_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, expm1_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, expm1_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, log_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, log_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, log2_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, log2_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, log10_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, log10_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, log1p_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, log1p_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_1, sin_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, sin_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, cos_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, cos_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, tan_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, tan_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, asin_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, asin_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, acos_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, acos_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, atan_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, atan_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_1, sinh_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, sinh_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, cosh_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, cosh_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, tanh_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, tanh_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, asinh_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, asinh_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, acosh_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, acosh_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, atanh_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, atanh_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_2, pow_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_2, pow_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, sqrt_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, sqrt_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, cbrt_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, cbrt_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_2, hypot_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_2, hypot_fn, xtensor)->Range(MATH_RANGE); - - BENCHMARK_TEMPLATE(math_ref_1, ceil_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, ceil_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, floor_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, floor_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, trunc_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, trunc_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, round_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, round_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, nearbyint_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, nearbyint_fn, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_ref_1, rint_fn)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(math_xtensor_1, rint_fn, xtensor)->Range(MATH_RANGE); - } - - template - void scalar_assign(benchmark::State& state) - { - T res; - std::size_t sz = static_cast(state.range(0)); - res.resize({sz, sz}); - for (auto _ : state) - { - res += typename T::value_type(1); - benchmark::DoNotOptimize(res.data()); - } - } - - template - void scalar_assign_ref(benchmark::State& state) - { - T res; - std::size_t sz = static_cast(state.range(0)); - res.resize({sz, sz}); - for (auto _ : state) - { - auto szt = res.size(); - for (std::size_t i = 0; i < szt; ++i) - { - res.data()[i] += typename T::value_type(1); - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - void boolean_func(benchmark::State& state) - { - T a, b; - std::size_t sz = static_cast(state.range(0)); - - a.resize({sz, sz}); - b.resize({sz, sz}); - xtensor res; - res.resize({sz, sz}); - - for (auto _ : state) - { - res = equal(a, b); - benchmark::DoNotOptimize(res.data()); - } - } - - template - void boolean_func_ref(benchmark::State& state) - { - T a, b; - std::size_t sz = static_cast(state.range(0)); - - a.resize({sz, sz}); - b.resize({sz, sz}); - xtensor res; - res.resize({sz, sz}); - - for (auto _ : state) - { - auto szt = res.size(); - for (std::size_t i = 0; i < szt; ++i) - { - res.data()[i] = (a.data()[i] == b.data()[i]); - } - benchmark::DoNotOptimize(res.data()); - } - } - - BENCHMARK_TEMPLATE(scalar_assign, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(scalar_assign_ref, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(boolean_func, xtensor)->Range(MATH_RANGE); - BENCHMARK_TEMPLATE(boolean_func_ref, xtensor)->Range(MATH_RANGE); -} diff --git a/benchmark/benchmark_random.cpp b/benchmark/benchmark_random.cpp deleted file mode 100644 index e5279988d..000000000 --- a/benchmark/benchmark_random.cpp +++ /dev/null @@ -1,63 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#ifndef BENCHMARK_RANDOM_HPP -#define BENCHMARK_RANDOM_HPP - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xnoalias.hpp" -#include "xtensor/generators/xrandom.hpp" - -namespace xt -{ - namespace random_bench - { - void random_assign_xtensor(benchmark::State& state) - { - for (auto _ : state) - { - xtensor result = xt::random::rand({20, 20}); - benchmark::DoNotOptimize(result.data()); - } - } - - void random_assign_forloop(benchmark::State& state) - { - for (auto _ : state) - { - xtensor result; - result.resize({20, 20}); - std::uniform_real_distribution dist(0, 1); - auto& engine = xt::random::get_default_random_engine(); - for (auto& el : result.storage()) - { - el = dist(engine); - } - benchmark::DoNotOptimize(result.data()); - } - } - - void random_assign_xarray(benchmark::State& state) - { - for (auto _ : state) - { - xarray result = xt::random::rand({20, 20}); - benchmark::DoNotOptimize(result.data()); - } - } - - BENCHMARK(random_assign_xarray); - BENCHMARK(random_assign_xtensor); - BENCHMARK(random_assign_forloop); - } -} - -#endif diff --git a/benchmark/benchmark_reducer.cpp b/benchmark/benchmark_reducer.cpp deleted file mode 100644 index c4304782f..000000000 --- a/benchmark/benchmark_reducer.cpp +++ /dev/null @@ -1,100 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/reducers/xreducer.hpp" - -namespace xt -{ - namespace reducer - { - template - void reducer_reducer(benchmark::State& state, const E& x, E& res, const X& axes) - { - for (auto _ : state) - { - res = sum(x, axes); - benchmark::DoNotOptimize(res.data()); - } - } - - template - void reducer_immediate_reducer(benchmark::State& state, const E& x, E& res, const X& axes) - { - for (auto _ : state) - { - res = sum(x, axes, evaluation_strategy::immediate); - benchmark::DoNotOptimize(res.data()); - } - } - - xarray u = ones({10, 100000}); - xarray v = ones({100000, 10}); - xarray res2 = ones({1}); - - std::vector axis0 = {0}; - std::vector axis1 = {1}; - std::vector axis_both = {0, 1}; - - static auto res0 = xarray::from_shape({100000}); - static auto res1 = xarray::from_shape({10}); - - BENCHMARK_CAPTURE(reducer_reducer, 10x100000 / axis 0, u, res0, axis0); - BENCHMARK_CAPTURE(reducer_reducer, 10x100000 / axis 1, u, res1, axis1); - BENCHMARK_CAPTURE(reducer_reducer, 100000x10 / axis 1, v, res1, axis0); - BENCHMARK_CAPTURE(reducer_reducer, 100000x10 / axis 0, v, res0, axis1); - BENCHMARK_CAPTURE(reducer_reducer, 100000x10 / axis both, v, res2, axis_both); - - BENCHMARK_CAPTURE(reducer_immediate_reducer, 10x100000 / axis 0, u, res0, axis0); - BENCHMARK_CAPTURE(reducer_immediate_reducer, 10x100000 / axis 1, u, res1, axis1); - BENCHMARK_CAPTURE(reducer_immediate_reducer, 100000x10 / axis 1, v, res1, axis0); - BENCHMARK_CAPTURE(reducer_immediate_reducer, 100000x10 / axis 0, v, res0, axis1); - BENCHMARK_CAPTURE(reducer_immediate_reducer, 100000x10 / axis both, v, res2, axis_both); - - template - inline auto reducer_manual_strided_reducer(benchmark::State& state, const E& x, E& res, const X& axes) - { - using value_type = typename E::value_type; - std::size_t stride = x.strides()[axes[0]]; - std::size_t offset_end = x.strides()[axes[0]] * x.shape()[axes[0]]; - std::size_t offset_iter = 0; - if (axes[0] == 1) - { - offset_iter = x.strides()[0]; - } - else if (axes[0] == 0) - { - offset_iter = x.strides()[1]; - } - - for (auto _ : state) - { - for (std::size_t j = 0; j < res.shape()[0]; ++j) - { - auto begin = x.data() + (offset_iter * j); - auto end = begin + offset_end; - value_type temp = *begin; - begin += stride; - for (; begin < end; begin += stride) - { - temp += *begin; - } - res(j) = temp; - } - benchmark::DoNotOptimize(res.data()); - } - } - - BENCHMARK_CAPTURE(reducer_manual_strided_reducer, 10x100000 / axis 0, u, res0, axis0); - BENCHMARK_CAPTURE(reducer_manual_strided_reducer, 10x100000 / axis 1, u, res1, axis1); - BENCHMARK_CAPTURE(reducer_manual_strided_reducer, 100000x10 / axis 1, v, res1, axis0); - BENCHMARK_CAPTURE(reducer_manual_strided_reducer, 100000x10 / axis 0, v, res0, axis1); - } -} diff --git a/benchmark/benchmark_stl.cpp b/benchmark/benchmark_stl.cpp deleted file mode 100644 index 9ae160712..000000000 --- a/benchmark/benchmark_stl.cpp +++ /dev/null @@ -1,157 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xmath.hpp" -#include "xtensor/generators/xrandom.hpp" - -namespace xt -{ - namespace - { - constexpr std::array cContainerAssignShape{2000, 2000}; - - template - auto generateRandomInt16From0To100(Shape&& x) - { - return xt::random::randint(x, 0, 100); - } - } - - static void Xtensor_Uint16_2000x2000_DivideBy2_StdTransform(benchmark::State& aState) - { - xt::xtensor vInput = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - std::transform( - vInput.begin(), - vInput.end(), - vOutput.begin(), - [](auto&& aInputValue) - { - return aInputValue / 2; - } - ); - } - } - - static void Xtensor_Uint16_2000x2000_DivideBy2_Xtensor(benchmark::State& aState) - { - xt::xtensor vInput = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - vOutput = vInput / 2; - } - } - - static void Xtensor_Uint16_2000x2000_DivideBy2Double_StdTransform(benchmark::State& aState) - { - xt::xtensor vInput = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - std::transform( - vInput.begin(), - vInput.end(), - vOutput.begin(), - [](auto&& aInputValue) - { - return aInputValue / 2.0; - } - ); - } - } - - static void Xtensor_Uint16_2000x2000_DivideBy2Double_Xtensor(benchmark::State& aState) - { - xt::xtensor vInput = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - vOutput = vInput / 2.0; - } - } - - static void Xtensor_Uint16_2000x2000_MultiplyBy2_StdTransform(benchmark::State& aState) - { - xt::xtensor vInput = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - std::transform( - vInput.begin(), - vInput.end(), - vOutput.begin(), - [](auto&& aInputValue) - { - return aInputValue * 2; - } - ); - } - } - - static void Xtensor_Uint16_2000x2000_MultiplyBy2_Xtensor(benchmark::State& aState) - { - xt::xtensor vInput = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - vOutput = vInput * 2; - } - } - - static void Xtensor_Uint16_2000x2000_Maximum_StdTransform(benchmark::State& aState) - { - xt::xtensor vInput1 = generateRandomInt16From0To100(cContainerAssignShape); - xt::xtensor vInput2 = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - auto vInput2It = vInput2.begin(); - std::transform( - vInput1.begin(), - vInput1.end(), - vOutput.begin(), - [&vInput2It](auto&& aInput1Value) - { - return std::max(aInput1Value, *vInput2It++); - } - ); - } - } - - static void Xtensor_Uint16_2000x2000_Maximum_Xtensor(benchmark::State& aState) - { - xt::xtensor vInput1 = generateRandomInt16From0To100(cContainerAssignShape); - xt::xtensor vInput2 = generateRandomInt16From0To100(cContainerAssignShape); - auto vOutput = xt::xtensor::from_shape(cContainerAssignShape); - - for (auto _ : aState) - { - vOutput = xt::maximum(vInput1, vInput2); - } - } - - BENCHMARK(Xtensor_Uint16_2000x2000_Maximum_Xtensor); - BENCHMARK(Xtensor_Uint16_2000x2000_Maximum_StdTransform); - BENCHMARK(Xtensor_Uint16_2000x2000_MultiplyBy2_Xtensor); - BENCHMARK(Xtensor_Uint16_2000x2000_MultiplyBy2_StdTransform); - BENCHMARK(Xtensor_Uint16_2000x2000_DivideBy2Double_Xtensor); - BENCHMARK(Xtensor_Uint16_2000x2000_DivideBy2Double_StdTransform); -} diff --git a/benchmark/benchmark_view_access.cpp b/benchmark/benchmark_view_access.cpp deleted file mode 100644 index 78569955e..000000000 --- a/benchmark/benchmark_view_access.cpp +++ /dev/null @@ -1,334 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -// #include "xtensor/core/core/xshape.hpp" -#include "xtensor/containers/xadapt.hpp" -#include "xtensor/containers/xstorage.hpp" -#include "xtensor/core/xnoalias.hpp" -#include "xtensor/generators/xbuilder.hpp" -#include "xtensor/generators/xrandom.hpp" -#include "xtensor/utils/xutils.hpp" -#include "xtensor/views/xview.hpp" - -namespace xt -{ - template - class simple_array - { - public: - - using self_type = simple_array; - using shape_type = std::array; - - simple_array() = default; - - explicit simple_array(const std::array& shape) - : m_shape(shape) - { - ptrdiff_t data_size = 1; - m_strides[N - 1] = 1; - for (std::ptrdiff_t i = N - 1; i > 0; --i) - { - data_size *= static_cast(shape[i]); - m_strides[i - 1] = data_size; - } - data_size *= shape[0]; - memory.resize(data_size); - } - - template - self_type& operator=(const xexpression& e) - { - const E& de = e.derived_cast(); - std::copy(de.cbegin(), de.cend(), memory.begin()); - return *this; - } - - void fill(T val) - { - std::fill(memory.begin(), memory.end(), val); - } - - template - T& operator()(Args... args) - { - std::array idx({static_cast(args)...}); - static_assert(sizeof...(Args) == N, "too few or too many indices!"); - ptrdiff_t offset = 0; - for (std::size_t i = 0; i < N; ++i) - { - offset += m_strides[i] * idx[i]; - } - return memory[offset]; - } - - xt::uvector memory; - std::array m_shape, m_strides; - }; - - void xview_access_calc(benchmark::State& state) - { - xt::xtensor A = xt::random::rand({100, 100, 4, 4}); - xt::xtensor elemvec = xt::random::rand({100, 4, 4}); - xt::xtensor eps = xt::empty({2, 2}); - - for (auto _ : state) - { - for (size_t e = 0; e < 100; ++e) - { - // alias element vector (e.g. nodal displacements) - auto u = xt::view(elemvec, e, xt::all(), xt::all()); - for (size_t k = 0; k < 100; ++k) - { - auto dNx = xt::view(A, e, k, xt::all(), xt::all()); - // - evaluate symmetrized dyadic product (loops unrolled for efficiency) - // grad(i,j) += dNx(m,i) * u(m,j) - // eps (j,i) = 0.5 * ( grad(i,j) + grad(j,i) ) - eps(0, 0) = dNx(0, 0) * u(0, 0) + dNx(1, 0) * u(1, 0) + dNx(2, 0) * u(2, 0) - + dNx(3, 0) * u(3, 0); - eps(1, 1) = dNx(0, 1) * u(0, 1) + dNx(1, 1) * u(1, 1) + dNx(2, 1) * u(2, 1) - + dNx(3, 1) * u(3, 1); - eps(0, 1) = (dNx(0, 1) * u(0, 0) + dNx(1, 1) * u(1, 0) + dNx(2, 1) * u(2, 0) - + dNx(3, 1) * u(3, 0) + dNx(0, 0) * u(0, 1) + dNx(1, 0) * u(1, 1) - + dNx(2, 0) * u(2, 1) + dNx(3, 0) * u(3, 1)) - / 2.; - eps(1, 0) = eps(0, 1); - benchmark::DoNotOptimize(eps.storage()); - } - } - } - } - - void raw_access_calc(benchmark::State& state) - { - xt::xtensor A = xt::random::rand({100, 100, 4, 4}); - xt::xtensor elemvec = xt::random::rand({100, 4, 4}); - xt::xtensor eps = xt::empty({2, 2}); - - for (auto _ : state) - { - for (size_t e = 0; e < 100; ++e) - { - for (size_t k = 0; k < 100; ++k) - { - // - evaluate symmetrized dyadic product (loops unrolled for efficiency) - // grad(i,j) += dNx(m,i) * u(m,j) - // eps (j,i) = 0.5 * ( grad(i,j) + grad(j,i) ) - eps(0, 0) = A(e, k, 0, 0) * elemvec(e, 0, 0) + A(e, k, 1, 0) * elemvec(e, 1, 0) - + A(e, k, 2, 0) * elemvec(e, 2, 0) + A(e, k, 3, 0) * elemvec(e, 3, 0); - eps(1, 1) = A(e, k, 0, 1) * elemvec(e, 0, 1) + A(e, k, 1, 1) * elemvec(e, 1, 1) - + A(e, k, 2, 1) * elemvec(e, 2, 1) + A(e, k, 3, 1) * elemvec(e, 3, 1); - eps(0, 1) = (A(e, k, 0, 1) * elemvec(e, 0, 0) + A(e, k, 1, 1) * elemvec(e, 1, 0) - + A(e, k, 2, 1) * elemvec(e, 2, 0) + A(e, k, 3, 1) * elemvec(e, 3, 0) - + A(e, k, 0, 0) * elemvec(e, 0, 1) + A(e, k, 1, 0) * elemvec(e, 1, 1) - + A(e, k, 2, 0) * elemvec(e, 2, 1) + A(e, k, 3, 0) * elemvec(e, 3, 1)) - / 2.; - eps(1, 0) = eps(0, 1); - benchmark::DoNotOptimize(eps.storage()); - } - } - } - } - - void unchecked_access_calc(benchmark::State& state) - { - xt::xtensor A = xt::random::rand({100, 100, 4, 4}); - xt::xtensor elemvec = xt::random::rand({100, 4, 4}); - xt::xtensor eps = xt::empty({2, 2}); - - for (auto _ : state) - { - for (size_t e = 0; e < 100; ++e) - { - for (size_t k = 0; k < 100; ++k) - { - // - evaluate symmetrized dyadic product (loops unrolled for efficiency) - // grad(i,j) += dNx(m,i) * u(m,j) - // eps (j,i) = 0.5 * ( grad(i,j) + grad(j,i) ) - eps.unchecked(0, 0) = A.unchecked(e, k, 0, 0) * elemvec.unchecked(e, 0, 0) - + A.unchecked(e, k, 1, 0) * elemvec.unchecked(e, 1, 0) - + A.unchecked(e, k, 2, 0) * elemvec.unchecked(e, 2, 0) - + A.unchecked(e, k, 3, 0) * elemvec.unchecked(e, 3, 0); - eps.unchecked(1, 1) = A.unchecked(e, k, 0, 1) * elemvec.unchecked(e, 0, 1) - + A.unchecked(e, k, 1, 1) * elemvec.unchecked(e, 1, 1) - + A.unchecked(e, k, 2, 1) * elemvec.unchecked(e, 2, 1) - + A.unchecked(e, k, 3, 1) * elemvec.unchecked(e, 3, 1); - eps.unchecked(0, 1) = (A.unchecked(e, k, 0, 1) * elemvec.unchecked(e, 0, 0) - + A.unchecked(e, k, 1, 1) * elemvec.unchecked(e, 1, 0) - + A.unchecked(e, k, 2, 1) * elemvec.unchecked(e, 2, 0) - + A.unchecked(e, k, 3, 1) * elemvec.unchecked(e, 3, 0) - + A.unchecked(e, k, 0, 0) * elemvec.unchecked(e, 0, 1) - + A.unchecked(e, k, 1, 0) * elemvec.unchecked(e, 1, 1) - + A.unchecked(e, k, 2, 0) * elemvec.unchecked(e, 2, 1) - + A.unchecked(e, k, 3, 0) * elemvec.unchecked(e, 3, 1)) - / 2.; - eps.unchecked(1, 0) = eps.unchecked(0, 1); - benchmark::DoNotOptimize(eps.storage()); - } - } - } - } - - void simplearray_access_calc(benchmark::State& state) - { - simple_array A(std::array{100, 100, 4, 2}); - simple_array elemvec(std::array{100, 4, 2}); - simple_array eps(std::array{2, 2}); - - for (auto _ : state) - { - for (size_t e = 0; e < 100; ++e) - { - for (size_t k = 0; k < 100; ++k) - { - // - evaluate sy mmetrized dyadic product (loops unrolled for efficiency) - // grad(i,j) += dNx(m,i) * u(m,j) - // eps (j,i) = 0.5 * ( grad(i,j) + grad(j,i) ) - eps(0, 0) = A(e, k, 0, 0) * elemvec(e, 0, 0) + A(e, k, 1, 0) * elemvec(e, 1, 0) - + A(e, k, 2, 0) * elemvec(e, 2, 0) + A(e, k, 3, 0) * elemvec(e, 3, 0); - eps(1, 1) = A(e, k, 0, 1) * elemvec(e, 0, 1) + A(e, k, 1, 1) * elemvec(e, 1, 1) - + A(e, k, 2, 1) * elemvec(e, 2, 1) + A(e, k, 3, 1) * elemvec(e, 3, 1); - eps(0, 1) = (A(e, k, 0, 1) * elemvec(e, 0, 0) + A(e, k, 1, 1) * elemvec(e, 1, 0) - + A(e, k, 2, 1) * elemvec(e, 2, 0) + A(e, k, 3, 1) * elemvec(e, 3, 0) - + A(e, k, 0, 0) * elemvec(e, 0, 1) + A(e, k, 1, 0) * elemvec(e, 1, 1) - + A(e, k, 2, 0) * elemvec(e, 2, 1) + A(e, k, 3, 0) * elemvec(e, 3, 1)) - / 2.; - eps(1, 0) = eps(0, 1); - benchmark::DoNotOptimize(eps.memory); - } - } - } - } - -#define M_NELEM 3600 -#define M_NNE 4 -#define M_NDIM 2 - - template - class jumping_random - { - public: - - using shape_type = typename X::shape_type; - - jumping_random() - : m_dofs(shape_type{3721, 2}) - , m_conn(shape_type{3600, 4}) - { - m_dofs = xt::clip(xt::reshape_view(xt::arange(2 * 3721), {3721, 2}), 0, 7199); - - for (std::size_t i = 0; i < 3600; ++i) - { - m_conn(i, 0) = i; - m_conn(i, 1) = i + 1; - m_conn(i, 2) = i + 62; - m_conn(i, 3) = i + 61; - } - } - - auto calc_dofval(xt::xtensor& elemvec, xt::xtensor& dofval) - { - dofval.fill(0.0); - for (size_t e = 0; e < M_NELEM; ++e) - { - for (size_t m = 0; m < M_NNE; ++m) - { - for (size_t i = 0; i < M_NDIM; ++i) - { - dofval(m_dofs(m_conn(e, m), i)) += elemvec(e, m, i); - } - } - } - } - - auto calc_dofval_simple(simple_array& elemvec, simple_array& dofval) - { - dofval.fill(0.0); - for (size_t e = 0; e < M_NELEM; ++e) - { - for (size_t m = 0; m < M_NNE; ++m) - { - for (size_t i = 0; i < M_NDIM; ++i) - { - dofval(m_dofs(m_conn(e, m), i)) += elemvec(e, m, i); - } - } - } - } - - auto calc_unchecked_dofval(xt::xtensor& elemvec, xt::xtensor& dofval) - { - dofval.fill(0.0); - for (size_t e = 0; e < M_NELEM; ++e) - { - for (size_t m = 0; m < M_NNE; ++m) - { - for (size_t i = 0; i < M_NDIM; ++i) - { - auto d = m_dofs.unchecked(m_conn.unchecked(e, m), i); - dofval.unchecked(d) += elemvec.unchecked(e, m, i); - } - } - } - } - - X m_dofs, m_conn; - }; - - template - void jumping_access(benchmark::State& state) - { - auto rx = jumping_random, L>(); - xt::xtensor elemvec = xt::random::rand({M_NELEM, M_NNE, M_NDIM}); - xt::xtensor dofval = xt::empty({7200}); - for (auto _ : state) - { - rx.calc_dofval(elemvec, dofval); - benchmark::DoNotOptimize(dofval.data()); - } - } - - template - void jumping_access_unchecked(benchmark::State& state) - { - auto rx = jumping_random, L>(); - xt::xtensor elemvec = xt::random::rand({M_NELEM, M_NNE, M_NDIM}); - xt::xtensor dofval = xt::empty({7200}); - for (auto _ : state) - { - rx.calc_unchecked_dofval(elemvec, dofval); - benchmark::DoNotOptimize(dofval.data()); - } - } - - void jumping_access_simplearray(benchmark::State& state) - { - auto rx = jumping_random, layout_type::row_major>(); - simple_array elemvec({M_NELEM, M_NNE, M_NDIM}); - elemvec = xt::random::rand({M_NELEM, M_NNE, M_NDIM}); - simple_array dofval({7200}); - - for (auto _ : state) - { - rx.calc_dofval_simple(elemvec, dofval); - benchmark::DoNotOptimize(dofval.memory); - } - } - - BENCHMARK(raw_access_calc); - BENCHMARK(unchecked_access_calc); - BENCHMARK(simplearray_access_calc); - BENCHMARK(xview_access_calc); - BENCHMARK_TEMPLATE(jumping_access, layout_type::row_major); - BENCHMARK_TEMPLATE(jumping_access, layout_type::column_major); - BENCHMARK_TEMPLATE(jumping_access_unchecked, layout_type::row_major); - BENCHMARK_TEMPLATE(jumping_access_unchecked, layout_type::column_major); - BENCHMARK(jumping_access_simplearray); -} diff --git a/benchmark/benchmark_view_adapt.cpp b/benchmark/benchmark_view_adapt.cpp deleted file mode 100644 index 2523cb725..000000000 --- a/benchmark/benchmark_view_adapt.cpp +++ /dev/null @@ -1,79 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#ifndef BENCHMARK_VIEW_ADAPT_HPP -#define BENCHMARK_VIEW_ADAPT_HPP - -#include - -#include "xtensor/containers/xadapt.hpp" -#include "xtensor/containers/xfixed.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xnoalias.hpp" -#include "xtensor/generators/xrandom.hpp" -#include "xtensor/views/xview.hpp" - -namespace xt -{ - namespace benchmark_view_adapt - { - using T2 = xt::xtensor_fixed>; - - T2 foo(const T2& A) - { - return 2. * A; - } - - void random_view(benchmark::State& state) - { - xt::xtensor A = xt::random::randn({2000, 8, 2, 2}); - xt::xtensor B = xt::empty(A.shape()); - - for (auto _ : state) - { - for (size_t i = 0; i < A.shape()[0]; ++i) - { - for (size_t j = 0; j < A.shape()[1]; ++j) - { - auto a = xt::view(A, i, j); - auto b = xt::view(B, i, j); - - xt::noalias(b) = foo(a); - } - } - benchmark::DoNotOptimize(B.data()); - } - } - - void random_adapt(benchmark::State& state) - { - xt::xtensor A = xt::random::randn({2000, 8, 2, 2}); - xt::xtensor B = xt::empty(A.shape()); - - for (auto _ : state) - { - for (size_t i = 0; i < A.shape()[0]; ++i) - { - for (size_t j = 0; j < A.shape()[1]; ++j) - { - auto a = xt::adapt(&A(i, j, 0, 0), xt::xshape<2, 2>()); - auto b = xt::adapt(&B(i, j, 0, 0), xt::xshape<2, 2>()); - - xt::noalias(b) = foo(a); - } - } - benchmark::DoNotOptimize(B.data()); - } - } - - BENCHMARK(random_view); - BENCHMARK(random_adapt); - } -} - -#endif diff --git a/benchmark/benchmark_view_assignment.cpp b/benchmark/benchmark_view_assignment.cpp deleted file mode 100644 index 3d5ae314b..000000000 --- a/benchmark/benchmark_view_assignment.cpp +++ /dev/null @@ -1,160 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xfixed.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xnoalias.hpp" -#include "xtensor/generators/xrandom.hpp" - -namespace xt -{ - inline void create_xview(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - for (auto _ : state) - { - auto v = xt::view(tens, 1, 2, all(), all()); - } - } - - inline void create_strided_view_outofplace(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - xstrided_slice_vector sv = {1, 2, all(), all()}; - for (auto _ : state) - { - auto v = xt::strided_view(tens, sv); - } - } - - inline void create_strided_view_inplace(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - for (auto _ : state) - { - auto v = xt::strided_view(tens, {1, 2, all(), all()}); - } - } - - inline void assign_create_view(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - for (auto _ : state) - { - for (std::size_t i = 0; i < tens.shape()[0]; ++i) - { - for (std::size_t j = 0; j < tens.shape()[1]; ++j) - { - auto v = xt::view(tens, i, j, all(), all()); - xt::xtensor vas = v; - benchmark::ClobberMemory(); - } - } - } - } - - /** - * inline void assign_create_strided_view(benchmark::State& state) - * { - * xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - * for (auto _ : state) - * { - * for (std::size_t i = 0; i < tens.shape()[0]; ++i) - * { - * for (std::size_t j = 0; j < tens.shape()[1]; ++j) - * { - * auto v = xt::strided_view(tens, {i, j, all(), all()}); - * xt::xtensor vas = v; - * benchmark::ClobberMemory(); - * } - * } - * } - * } - */ - inline void assign_create_manual_view(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - for (auto _ : state) - { - for (std::size_t i = 0; i < tens.shape()[0]; ++i) - { - for (std::size_t j = 0; j < tens.shape()[1]; ++j) - { - auto v = xt::view(tens, i, j, all(), all()); - xt::xtensor vas(std::array({3, 3})); - std::copy(v.data() + v.data_offset(), v.data() + v.data_offset() + vas.size(), vas.begin()); - benchmark::ClobberMemory(); - } - } - } - } - - inline void assign_create_manual_noview(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - for (auto _ : state) - { - for (std::size_t i = 0; i < tens.shape()[0]; ++i) - { - for (std::size_t j = 0; j < tens.shape()[1]; ++j) - { - ptrdiff_t offset = i * tens.strides()[0] + j * tens.strides()[1]; - xt::xtensor vas(std::array({3, 3})); - std::copy(tens.data() + offset, tens.data() + offset + vas.size(), vas.begin()); - benchmark::ClobberMemory(); - } - } - } - } - - inline void data_offset(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - for (auto _ : state) - { - for (std::size_t i = 0; i < tens.shape()[0]; ++i) - { - for (std::size_t j = 0; j < tens.shape()[1]; ++j) - { - volatile ptrdiff_t offset = i * tens.strides()[0] + j * tens.strides()[1]; - static_cast(offset); - } - } - } - } - - inline void data_offset_view(benchmark::State& state) - { - xt::xtensor tens = xt::random::rand({100, 100, 3, 3}); - for (auto _ : state) - { - for (std::size_t i = 0; i < tens.shape()[0]; ++i) - { - for (std::size_t j = 0; j < tens.shape()[1]; ++j) - { - auto v = xt::view(tens, i, j, all(), all()); - volatile ptrdiff_t offset = v.data_offset(); - static_cast(offset); - } - } - } - } - - BENCHMARK(create_xview); - BENCHMARK(create_strided_view_outofplace); - BENCHMARK(create_strided_view_inplace); - BENCHMARK(assign_create_manual_noview); - // BENCHMARK(assign_create_strided_view); - BENCHMARK(assign_create_view); - BENCHMARK(assign_create_manual_view); - // BENCHMARK(data_offset); - BENCHMARK(data_offset_view); -} diff --git a/benchmark/benchmark_views.cpp b/benchmark/benchmark_views.cpp deleted file mode 100644 index f2c34d510..000000000 --- a/benchmark/benchmark_views.cpp +++ /dev/null @@ -1,296 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include -#include -#include - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" -#include "xtensor/core/xnoalias.hpp" -#include "xtensor/core/xstrides.hpp" -#include "xtensor/misc/xmanipulation.hpp" -#include "xtensor/views/xstrided_view.hpp" -#include "xtensor/views/xview.hpp" - -namespace xt -{ - // Thanks to Ullrich Koethe for these benchmarks - // https://github.com/xtensor-stack/xtensor/issues/695 - namespace view_benchmarks - { - constexpr int SIZE = 1000; - - template - void view_dynamic_iterator(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE / 2}); - for (auto _ : state) - { - std::copy(v.begin(), v.end(), res.begin()); - benchmark::DoNotOptimize(res.data()); - } - } - - template - void view_iterator(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::view(data, xt::all(), SIZE / 2); - for (auto _ : state) - { - std::copy(v.begin(), v.end(), res.begin()); - benchmark::DoNotOptimize(res.data()); - } - } - - template - void view_loop(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE / 2}); - for (auto _ : state) - { - for (std::size_t k = 0; k < v.shape()[0]; ++k) - { - res(k) = v(k); - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - void view_loop_view(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::view(data, xt::all(), SIZE / 2); - for (auto _ : state) - { - for (std::size_t k = 0; k < v.shape()[0]; ++k) - { - res(k) = v(k); - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - void view_loop_raw(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - for (auto _ : state) - { - std::size_t j = SIZE / 2; - for (std::size_t k = 0; k < SIZE; ++k) - { - res(k) = data(k, j); - } - benchmark::DoNotOptimize(res.data()); - } - } - - template - void view_assign(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE / 2}); - for (auto _ : state) - { - xt::noalias(res) = v; - benchmark::DoNotOptimize(res.data()); - } - } - - template - void view_assign_view(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::view(data, xt::all(), SIZE / 2); - auto r = xt::view(res, xt::all()); - for (auto _ : state) - { - r = v; - benchmark::DoNotOptimize(r.data()); - } - } - - template - void view_assign_strided_view(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE / 2}); - auto r = xt::strided_view(res, xt::xstrided_slice_vector{xt::all()}); - - for (auto _ : state) - { - r = v; - benchmark::DoNotOptimize(r.data()); - } - } - - template - void view_assign_view_noalias(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::view(data, xt::all(), SIZE / 2); - auto r = xt::view(res, xt::all()); - for (auto _ : state) - { - xt::noalias(r) = v; - benchmark::DoNotOptimize(r.data()); - } - } - - template - void view_assign_strided_view_noalias(benchmark::State& state) - { - xt::xtensor data = xt::ones({SIZE, SIZE}); - xt::xtensor res = xt::ones({SIZE}); - - auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE / 2}); - auto r = xt::strided_view(res, xt::xstrided_slice_vector{xt::all()}); - - for (auto _ : state) - { - xt::noalias(r) = v; - benchmark::DoNotOptimize(r.data()); - } - } - - BENCHMARK_TEMPLATE(view_dynamic_iterator, float); - BENCHMARK_TEMPLATE(view_iterator, float); - BENCHMARK_TEMPLATE(view_loop, float); - BENCHMARK_TEMPLATE(view_loop_view, float); - BENCHMARK_TEMPLATE(view_loop_raw, float); - BENCHMARK_TEMPLATE(view_assign, float); - BENCHMARK_TEMPLATE(view_assign_view, float); - BENCHMARK_TEMPLATE(view_assign_strided_view, float); - BENCHMARK_TEMPLATE(view_assign_view_noalias, float); - BENCHMARK_TEMPLATE(view_assign_strided_view_noalias, float); - } - - namespace finite_diff - { - inline auto stencil_threedirections(benchmark::State& state, size_t size) - { - for (auto _ : state) - { - const std::array shape = {size, size, size}; - xt::xtensor a(shape), b(shape); - auto core = xt::range(1, size - 1); - xt::noalias(xt::view(b, core, core, core) - ) = 1.0 / 7.0 - * (xt::view(a, core, core, core) + xt::view(a, core, core, xt::range(2, size)) - + xt::view(a, core, core, xt::range(0, size - 2)) - + xt::view(a, core, xt::range(2, size), core) - + xt::view(a, core, xt::range(0, size - 2), core) - + xt::view(a, xt::range(2, size), core, core) - + xt::view(a, xt::range(0, size - 2), core, core)); - benchmark::DoNotOptimize(b); - } - } - - inline auto stencil_twodirections(benchmark::State& state, size_t size) - { - for (auto _ : state) - { - const std::array shape = {size, size, size}; - xt::xtensor a(shape), b(shape); - auto core = xt::range(1, size - 1); - xt::noalias(xt::view(b, core, core, core) - ) = 1.0 / 7.0 - * (xt::view(a, core, core, core) + xt::view(a, core, xt::range(2, size), core) - + xt::view(a, core, xt::range(0, size - 2), core) - + xt::view(a, xt::range(2, size), core, core) - + xt::view(a, xt::range(0, size - 2), core, core)); - benchmark::DoNotOptimize(b); - } - } - - inline auto stencil_onedirection(benchmark::State& state, size_t size) - { - for (auto _ : state) - { - const std::array shape = {size, size, size}; - xt::xtensor a(shape), b(shape); - auto core = xt::range(1, size - 1); - xt::noalias(xt::view(b, core, core, core) - ) = 1.0 / 2.0 - * (xt::view(a, xt::range(2, size), core, core) - - xt::view(a, xt::range(0, size - 2), core, core)); - benchmark::DoNotOptimize(b); - } - } - - BENCHMARK_CAPTURE(stencil_threedirections, stencil_threedirections_50, 50); - BENCHMARK_CAPTURE(stencil_threedirections, stencil_threedirections_100, 100); - BENCHMARK_CAPTURE(stencil_threedirections, stencil_threedirections_200, 200); - BENCHMARK_CAPTURE(stencil_threedirections, stencil_threedirections_300, 300); - BENCHMARK_CAPTURE(stencil_threedirections, stencil_threedirections_500, 500); - BENCHMARK_CAPTURE(stencil_twodirections, stencil_twodirections_50, 50); - BENCHMARK_CAPTURE(stencil_twodirections, stencil_twodirections_100, 100); - BENCHMARK_CAPTURE(stencil_twodirections, stencil_twodirections_200, 200); - BENCHMARK_CAPTURE(stencil_twodirections, stencil_twodirections_300, 300); - BENCHMARK_CAPTURE(stencil_twodirections, stencil_twodirections_500, 500); - BENCHMARK_CAPTURE(stencil_onedirection, stencil_onedirections_50, 50); - BENCHMARK_CAPTURE(stencil_onedirection, stencil_onedirections_100, 100); - BENCHMARK_CAPTURE(stencil_onedirection, stencil_onedirections_200, 200); - BENCHMARK_CAPTURE(stencil_onedirection, stencil_onedirections_300, 300); - BENCHMARK_CAPTURE(stencil_onedirection, stencil_onedirections_500, 500); - } - - namespace stridedview - { - - template - inline auto transpose_assign(benchmark::State& state, std::vector shape) - { - xarray x = xt::arange(compute_size(shape)); - x.resize(shape); - - xarray res; - res.resize(std::vector(shape.rbegin(), shape.rend())); - - for (auto _ : state) - { - res = transpose(x); - } - } - - auto transpose_assign_rm_rm = transpose_assign; - auto transpose_assign_cm_cm = transpose_assign; - auto transpose_assign_rm_cm = transpose_assign; - auto transpose_assign_cm_rm = transpose_assign; - - BENCHMARK_CAPTURE(transpose_assign_rm_rm, 10x20x500, {10, 20, 500}); - BENCHMARK_CAPTURE(transpose_assign_cm_cm, 10x20x500, {10, 20, 500}); - BENCHMARK_CAPTURE(transpose_assign_rm_cm, 10x20x500, {10, 20, 500}); - BENCHMARK_CAPTURE(transpose_assign_cm_rm, 10x20x500, {10, 20, 500}); - } -} diff --git a/benchmark/benchmark_xshape.cpp b/benchmark/benchmark_xshape.cpp deleted file mode 100644 index 6656b912f..000000000 --- a/benchmark/benchmark_xshape.cpp +++ /dev/null @@ -1,69 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - - -#ifndef BENCHMARK_SHAPE_HPP -#define BENCHMARK_SHAPE_HPP - -#include - -#include "xtensor/containers/xstorage.hpp" -#include "xtensor/core/xshape.hpp" - -namespace xt -{ - namespace benchmark_xshape - { - template - void xshape_initializer(benchmark::State& state) - { - for (auto _ : state) - { - T sv({2, 3, 1}); - benchmark::DoNotOptimize(sv.data()); - } - } - - template - void xshape_initializer_long(benchmark::State& state) - { - for (auto _ : state) - { - T sv({2, 3, 1, 2, 6, 1, 2, 3, 45, 6, 12, 3, 5, 45, 5, 6}); - benchmark::DoNotOptimize(sv.data()); - } - } - - template - void xshape_access(benchmark::State& state) - { - T a({3, 2, 1, 3}); - for (auto _ : state) - { - a[0] = a[1] * a[2] + a[3]; - a[3] = a[1]; - a[1] = a[2] + a[3]; - a[2] = a[3]; - benchmark::DoNotOptimize(a.data()); - } - } - - BENCHMARK_TEMPLATE(xshape_initializer, std::vector); - BENCHMARK_TEMPLATE(xshape_initializer, xt::svector); - BENCHMARK_TEMPLATE(xshape_initializer, std::array); - BENCHMARK_TEMPLATE(xshape_initializer_long, xt::svector); - BENCHMARK_TEMPLATE(xshape_initializer_long, xt::uvector); - BENCHMARK_TEMPLATE(xshape_initializer_long, std::vector); - BENCHMARK_TEMPLATE(xshape_access, xt::uvector); - BENCHMARK_TEMPLATE(xshape_access, std::vector); - BENCHMARK_TEMPLATE(xshape_access, xt::svector); - BENCHMARK_TEMPLATE(xshape_access, std::array); - } -} - -#endif diff --git a/benchmark/copyGBenchmark.cmake.in b/benchmark/copyGBenchmark.cmake.in deleted file mode 100644 index e11eaed96..000000000 --- a/benchmark/copyGBenchmark.cmake.in +++ /dev/null @@ -1,22 +0,0 @@ -############################################################################ -# Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht # -# # -# Distributed under the terms of the BSD 3-Clause License. # -# # -# The full license is in the file LICENSE, distributed with this software. # -############################################################################ - -cmake_minimum_required(VERSION 3.5) - -project(googlebenchmark-download NONE) - -include(ExternalProject) -ExternalProject_Add(benchmark - URL "${googlebenchmark_SRC_DIR}" - SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-src" - BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build" - CONFIGURE_COMMAND "" - BUILD_COMMAND "" - INSTALL_COMMAND "" - TEST_COMMAND "" -) diff --git a/benchmark/downloadGBenchmark.cmake.in b/benchmark/downloadGBenchmark.cmake.in deleted file mode 100644 index 7af348b1e..000000000 --- a/benchmark/downloadGBenchmark.cmake.in +++ /dev/null @@ -1,24 +0,0 @@ -############################################################################ -# Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht # -# # -# Distributed under the terms of the BSD 3-Clause License. # -# # -# The full license is in the file LICENSE, distributed with this software. # -############################################################################ - -cmake_minimum_required(VERSION 3.5) - -project(googlebenchmark-download NONE) - -include(ExternalProject) -ExternalProject_Add(googlebenchmark - GIT_REPOSITORY https://github.com/google/benchmark.git - GIT_TAG v1.9.4 - SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-src" - BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build" - CONFIGURE_COMMAND "" - BUILD_COMMAND "" - CMAKE_ARGS "BENCHMARK_DOWNLOAD_DEPENDENCIES=TRUE" - INSTALL_COMMAND "" - TEST_COMMAND "" -) diff --git a/benchmark/main.cpp b/benchmark/main.cpp deleted file mode 100644 index 39491c225..000000000 --- a/benchmark/main.cpp +++ /dev/null @@ -1,50 +0,0 @@ -/*************************************************************************** - * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht * - * * - * Distributed under the terms of the BSD 3-Clause License. * - * * - * The full license is in the file LICENSE, distributed with this software. * - ****************************************************************************/ - -#include - -#include - -#include "xtensor/containers/xarray.hpp" -#include "xtensor/containers/xtensor.hpp" - -#ifdef XTENSOR_USE_XSIMD -#ifdef __GNUC__ -template -void print_type(T&& /*t*/) -{ - std::cout << __PRETTY_FUNCTION__ << std::endl; -} -#endif -void print_stats() -{ - std::cout << "USING XSIMD\nSIMD SIZE: " << xsimd::simd_traits::size << "\n\n"; -#ifdef __GNUC__ - print_type(xt::xarray()); - print_type(xt::xtensor()); -#endif -} -#else -void print_stats() -{ - std::cout << "NOT USING XSIMD\n\n"; -}; -#endif - - -// Custom main function to print SIMD config -int main(int argc, char** argv) -{ - print_stats(); - benchmark::Initialize(&argc, argv); - if (benchmark::ReportUnrecognizedArguments(argc, argv)) - { - return 1; - } - benchmark::RunSpecifiedBenchmarks(); -} diff --git a/classes.html b/classes.html new file mode 100644 index 000000000..ada8d34cf --- /dev/null +++ b/classes.html @@ -0,0 +1,183 @@ + + + + + + + +xtensor: Class Index + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Class Index
+
+
+
A | B | C | D | E | F | G | H | I | K | L | M | N | O | P | R | S | T | U | V | X
+
+
+
A
+
abs_fun (xt::math)
acos_fun (xt::math)
acosh_fun (xt::math)
acquire_ownership (xt)
aligned_allocator (xt_simd)
aligned_array (xt)
aligned_mode (xt)
aligned_mode (xt_simd)
allocator_alignment (xt_simd)
arg_fun (xt::math)
asin_fun (xt::math)
asinh_fun (xt::math)
atan2_fun (xt::math)
atan_fun (xt::math)
atanh_fun (xt::math)
+
+
B
+
big_promote_value_type (xt)
broadcast_error (xt)
buffer_inner_types (xt)
buffer_inner_types< xbuffer_adaptor< CP, O, A > > (xt)
buffer_inner_types< xiterator_adaptor< I, CI > > (xt)
buffer_inner_types< xiterator_owner_adaptor< C, IG > > (xt)
+
+
C
+
can_assign (xt)
can_assign< xstrided_view< CT, S, L, FST >, RHS > (xt)
cbrt_fun (xt::math)
ceil_fun (xt::math)
check_strides_functor (xt::strided_assign_detail)
check_strides_overlap (xt)
check_strides_overlap< layout_type::column_major > (xt)
check_strides_overlap< layout_type::row_major > (xt)
clamp_fun (xt::math)
common_difference_type (xt)
common_difference_type<> (xt)
common_size_type (xt)
common_size_type<> (xt)
common_tensor_type (xt)
common_value_type (xt)
concatenate_error (xt)
conditional_cast_functor (xt)
conditional_cast_functor< false, T > (xt)
conditional_cast_functor< true, T > (xt)
conj_fun (xt::math)
conj_impl_fun (xt::math)
conjunction (xtl)
const_array (xt)
const_value (xt)
const_xclosure (xt)
const_xclosure< E, disable_xexpression< std::decay_t< E > > > (xt)
const_xclosure< xshared_expression< E > &, std::enable_if_t< true > > (xt)
container_alignment (xt_simd)
container_simd_return_type (xt)
cos_fun (xt::math)
cosh_fun (xt::math)
+
+
D
+
decay_all (xt)
decay_all< S< X... > > (xt)
deg2rad (xt::math)
disable_indexed_stepper (xt)
driven_align_mode (xt)
+
+
E
+
edge_items (xt::print_options)
enable_indexed_stepper (xt)
erf_fun (xt::math)
erfc_fun (xt::math)
exp2_fun (xt::math)
exp_fun (xt::math)
expm1_fun (xt::math)
expression_tag_and (xt::extension)
expression_tag_and< T > (xt::extension)
expression_tag_and< T, T > (xt::extension)
expression_tag_and< T, xtensor_expression_tag > (xt::extension)
expression_tag_and< T1, T... > (xt::extension)
expression_tag_and< xtensor_expression_tag, T > (xt::extension)
expression_tag_and< xtensor_expression_tag, xtensor_expression_tag > (xt::extension)
expression_tag_and<> (xt::extension)
+
+
F
+
fabs_fun (xt::math)
fdim_fun (xt::math)
filter_fixed_shape (xt)
fixed_shape (xt)
fixed_xreducer_shape_type (xt)
fixed_xreducer_shape_type< fixed_shape< I... >, fixed_shape< J... > > (xt)
floor_fun (xt::math)
fma_fun (xt::math)
fmax_fun (xt::math)
fmin_fun (xt::math)
fmod_fun (xt::math)
forbid_simd (xt)
forbid_simd< const std::vector< bool, A > > (xt)
forbid_simd< const xtl::xdynamic_bitset< B, A > > (xt)
forbid_simd< std::vector< bool, A > > (xt)
forbid_simd< xtl::xdynamic_bitset< B, A > > (xt)
full (xt::check_policy)
full (xt::convolve_mode)
+
+
G
+
get_expression_tag (xt::extension)
get_expression_tag< xtl::xoptional< T, B > > (xt::extension)
get_expression_tag_impl (xt::extension)
get_expression_tag_impl< E, void_t< typename std::decay_t< E >::expression_tag > > (xt::extension)
get_init_type (xt)
get_init_type< V, fixed_shape< X... > > (xt)
get_rank (xt)
get_rank< E, decltype((void) E::rank, void())> (xt)
get_strides_type (xt)
get_strides_type< fixed_shape< I... > > (xt)
get_strides_type< xbuffer_adaptor< CP, O, A > > (xt)
get_value_type (xt)
get_value_type< T, void_t< typename T::value_type > > (xt)
+
+
H
+
has_assign_conversion (xt)
has_assign_to (xt)
has_assign_to< E1, E2, void_t< decltype(std::declval< const E2 & >().assign_to(std::declval< E1 & >()))> > (xt)
has_data_interface (xt)
has_data_interface< E, void_t< decltype(std::declval< E >().data())> > (xt)
has_fixed_rank (xt)
has_iterator_interface (xt)
has_iterator_interface< E, void_t< decltype(std::declval< E >().begin())> > (xt)
has_memory_address (xt)
has_memory_address< T, void_t< decltype(std::addressof(*std::declval< T >().begin()))> > (xt)
has_rank (xt)
has_sign_conversion (xt)
has_simd_apply (xt)
has_simd_interface (xt)
has_simd_interface< xfunction< F, CT... >, T > (xt)
has_simd_interface< xfunctor_adaptor< F, CT >, T > (xt)
has_simd_interface< xfunctor_applier_base< D >, T > (xt)
has_simd_interface< xfunctor_view< F, CT >, T > (xt)
has_simd_interface< xtensor_view< EC, N, L, Tag > > (xt)
has_simd_type (xt)
has_storage_type (xt)
has_storage_type< T, void_t< typename xcontainer_inner_types< T >::storage_type > > (xt)
has_strides (xt)
has_strides< E, void_t< decltype(std::declval< E >().strides())> > (xt)
hypot_fun (xt::math)
+
+
I
+
idx_tools (xt::strided_assign_detail)
idx_tools< layout_type::column_major > (xt::strided_assign_detail)
idx_tools< layout_type::row_major > (xt::strided_assign_detail)
immediate_type (xt::evaluation_strategy)
index_from_shape (xt)
index_mapper (xt)
index_mapper< xt::xview< UnderlyingContainer, Slices... > > (xt)
reducer_options::initial_tester (xt)
reducer_options::initial_tester< const xinitial< X > > (xt)
reducer_options::initial_tester< xinitial< X > > (xt)
initializer_dimension (xt)
inner_aligned_mode (xt)
inner_reference (xt)
invalid_type (xt)
is_batch_bool (xt_simd)
is_batch_complex (xt_simd)
is_chunked_t (xt)
is_contiguous_container (xt)
is_contiguous_container< xiterator< St, S, L > > (xt)
is_contiguous_container< xiterator_adaptor< I, CI > > (xt)
is_contiguous_container< xiterator_owner_adaptor< C, IG > > (xt)
is_evaluation_strategy (xt)
is_indexed_stepper (xt)
is_indexed_stepper< xindexed_stepper< T, B > > (xt)
is_iterator (xt)
is_iterator< E, void_t< decltype(*std::declval< const E >(), std::declval< const E >()==std::declval< const E >(), std::declval< const E >() !=std::declval< const E >(),++(*std::declval< E * >()),(*std::declval< E * >())++, std::true_type())> > (xt)
is_narrowing_conversion (xt)
is_not_xdummy_iterator (xt)
is_not_xdummy_iterator< xdummy_iterator< is_const, CT > > (xt)
is_reducer_options (xt)
is_reducer_options_impl (xt)
is_reducer_options_impl< std::tuple< X... > > (xt)
is_specialization_of (xt)
is_specialization_of< TT, TT< Ts... > > (xt)
is_xoptional_expression (xt)
is_xtensor_expression (xt)
isfinite_fun (xt::math)
isinf_fun (xt::math)
isnan_fun (xt::math)
+
+
K
+
keep_dims_type (xt)
+
+
L
+
lazy_type (xt::evaluation_strategy)
lgamma_fun (xt::math)
line_width (xt::print_options)
linear_assigner (xt)
linear_assigner< false > (xt)
log10_fun (xt::math)
log1p_fun (xt::math)
log2_fun (xt::math)
log_fun (xt::math)
loop_sizes_t (xt::strided_assign_detail)
+
+
M
+
make_invalid_type (xt)
make_void (xt)
maximum (xt::math)
memory_range (xt)
meta_identity (xt)
minimum (xt::math)
missing_type (xt)
+
+
N
+
nearbyint_fun (xt::math)
nested_initializer_list (xt)
nested_initializer_list< T, 0 > (xt)
no_ownership (xt)
noalias_proxy (xt)
none (xt::check_policy)
norm_fun (xt::math)
norm_of_array_elements_impl (xt::traits_detail)
norm_of_array_elements_impl< long double, false, true > (xt::traits_detail)
norm_of_array_elements_impl< T, false, false > (xt::traits_detail)
norm_of_array_elements_impl< T, false, true > (xt::traits_detail)
norm_of_array_elements_impl< T, true, false > (xt::traits_detail)
norm_of_array_elements_impl< void *, false, false > (xt::traits_detail)
norm_of_scalar_impl (xt::traits_detail)
norm_of_scalar_impl< T, false > (xt::traits_detail)
norm_of_scalar_impl< T, true > (xt::traits_detail)
norm_of_vector_impl (xt::traits_detail)
norm_type (xt)
norm_type_base (xt::traits_detail)
numeric_constants (xt)
+
+
O
+
overlapping_memory_checker (xt)
overlapping_memory_checker< Dst, std::enable_if_t< has_memory_address< Dst >::value > > (xt)
overlapping_memory_checker_base (xt)
overlapping_memory_checker_traits (xt)
overlapping_memory_checker_traits< E > (xt)
overlapping_memory_checker_traits< E, std::enable_if_t< has_memory_address< E >::value > > (xt)
overlapping_memory_checker_traits< E, std::enable_if_t<!has_memory_address< E >::value &&is_crtp_base_of< xview_semantic, E >::value > > (xt)
overlapping_memory_checker_traits< E, std::enable_if_t<!has_memory_address< E >::value &&is_specialization_of< xfunction, E >::value > > (xt)
+
+
P
+
pow_fun (xt::math)
precision (xt::print_options)
print_options_impl (xt::print_options)
promote_shape (xt)
promote_strides (xt)
+
+
R
+
rad2deg (xt::math)
rangemaker (xt::placeholders)
rangemaker< A, B > (xt::placeholders)
rangemaker< A, B, C > (xt::placeholders)
tracking_allocator::rebind (xt)
rebind_container (xt)
rebind_container< X, C< T, A > > (xt)
rebind_container< X, C< T, N > > (xt)
rebind_container< X, svector< T, N, A, B > > (xt)
reducer_options (xt)
remainder_fun (xt::math)
remove_class (xt)
remove_class< R(C::*)(Args...) const > (xt)
remove_class< R(C::*)(Args...)> (xt)
revert_simd_traits (xt_simd)
rint_fun (xt::math)
round_fun (xt::math)
+
+
S
+
select_dim_mapping_type (xt)
select_dim_mapping_type< fixed_shape< I... > > (xt)
select_iterable_base (xt)
select_layout (xt)
sequence_view (xt)
sign_fun (xt::math)
sign_impl (xt::math)
sign_impl< xtl::xoptional< T, B > > (xt::math)
simd_condition (xt_simd)
simd_traits (xt_simd)
sin_fun (xt::math)
sinh_fun (xt::math)
sqrt_fun (xt::math)
squared_norm_type (xt)
static_dimension (xt)
static_string (xt)
stepper_assigner (xt)
stepper_tools (xt)
strided_loop_assigner (xt)
svector (xt)
+
+
T
+
tan_fun (xt::math)
tanh_fun (xt::math)
temporary_container (xt)
temporary_container< xbuffer_adaptor< CP, O, A > > (xt)
temporary_container< xiterator_adaptor< I, CI > > (xt)
temporary_container< xiterator_owner_adaptor< C, IG > > (xt)
temporary_type (xt)
temporary_type< T, void_t< typename std::decay_t< T >::temporary_type > > (xt)
temporary_type_from_tag (xt)
temporary_type_from_tag< xtensor_expression_tag, T > (xt)
tgamma_fun (xt::math)
threshold (xt::print_options)
tracking_allocator (xt)
transpose_error (xt)
trunc_fun (xt::math)
tuple_idx_of (xt)
tuple_idx_of_impl (xt)
tuple_idx_of_impl< I, T, std::tuple< T, Types... > > (xt)
tuple_idx_of_impl< I, T, std::tuple< U, Types... > > (xt)
tuple_idx_of_impl< I, T, std::tuple<> > (xt)
tuple_size< xt::const_array< T, N > > (std)
tuple_size< xt::fixed_shape< N... > > (std)
tuple_size< xt::sequence_view< T, Start, End > > (std)
+
+
U
+
unaligned_mode (xt)
unaligned_mode (xt_simd)
uvector (xt)
+
+
V
+
valid (xt::convolve_mode)
view_temporary_type (xt)
+
+
X
+
xaccessible (xt)
xaccumulator_functor (xt)
xall (xt)
xall_tag (xt)
xarray_adaptor (xt)
xarray_adaptor_base (xt::extension)
xarray_adaptor_base< EC, L, SC, xoptional_expression_tag > (xt::extension)
xarray_adaptor_base< EC, L, SC, xtensor_expression_tag > (xt::extension)
xarray_adaptor_optional_traits (xt::extension)
xarray_container (xt)
xarray_container_base (xt::extension)
xarray_container_base< EC, L, SC, xoptional_expression_tag > (xt::extension)
xarray_container_base< EC, L, SC, xtensor_expression_tag > (xt::extension)
xarray_container_optional_traits (xt::extension)
xarray_optional_traits (xt::extension)
xassign_traits (xt)
xaxis_iterator (xt)
xaxis_slice_iterator (xt)
xblockwise_reducer (xt)
xbounded_iterator (xt)
xbroadcast (xt)
xbroadcast_base (xt::extension)
xbroadcast_base_impl (xt::extension)
xbroadcast_base_impl< xoptional_expression_tag, CT, X > (xt::extension)
xbroadcast_base_impl< xtensor_expression_tag, CT, X > (xt::extension)
xbroadcast_optional (xt::extension)
xbuffer_adaptor (xt)
xbuffer_adaptor_base (xt)
xchunk_iterator (xt)
xchunked_array (xt)
xchunked_assigner (xt)
xchunked_semantic (xt)
xchunked_view (xt)
xclosure (xt)
xclosure< E, disable_xexpression< std::decay_t< E > > > (xt)
xclosure< xshared_expression< E >, std::enable_if_t< true > > (xt)
xconst_accessible (xt)
xconst_iterable (xt)
xcontainer (xt)
xcontainer_inner_types (xt)
xcontainer_inner_types< xarray_adaptor< EC, L, SC, Tag > > (xt)
xcontainer_inner_types< xarray_container< EC, L, SC, Tag > > (xt)
xcontainer_inner_types< xbroadcast< CT, X > > (xt)
xcontainer_inner_types< xchunked_array< chunk_storage > > (xt)
xcontainer_inner_types< xdynamic_view< CT, S, L, FST > > (xt)
xcontainer_inner_types< xfixed_adaptor< EC, S, L, SH, Tag > > (xt)
xcontainer_inner_types< xfixed_container< ET, S, L, SH, Tag > > (xt)
xcontainer_inner_types< xfunction< F, CT... > > (xt)
xcontainer_inner_types< xfunctor_adaptor< F, CT > > (xt)
xcontainer_inner_types< xfunctor_view< F, CT > > (xt)
xcontainer_inner_types< xgenerator< C, R, S > > (xt)
xcontainer_inner_types< xindex_view< CT, I > > (xt)
xcontainer_inner_types< xmasked_view< CTD, CTM > > (xt)
xcontainer_inner_types< xoptional_assembly< VE, FE > > (xt)
xcontainer_inner_types< xoptional_assembly_adaptor< VEC, FEC > > (xt)
xcontainer_inner_types< xreducer< F, CT, X, O > > (xt)
xcontainer_inner_types< xscalar< CT > > (xt)
xcontainer_inner_types< xstrided_view< CT, S, L, FST > > (xt)
xcontainer_inner_types< xtensor_adaptor< EC, N, L, Tag > > (xt)
xcontainer_inner_types< xtensor_container< EC, N, L, Tag > > (xt)
xcontainer_inner_types< xtensor_view< EC, N, L, Tag > > (xt)
xcontainer_inner_types< xview< CT, S... > > (xt)
xcontainer_iterable_types (xt)
xcontainer_optional_base (xt::extension)
xcontainer_semantic (xt)
xcontiguous_iterable (xt)
xcsv_config (xt)
xdrop_slice (xt)
xdummy_iterator (xt)
xdynamic_view (xt)
xdynamic_view_base (xt::extension)
xdynamic_view_base_impl (xt::extension)
xdynamic_view_base_impl< xoptional_expression_tag, CT, S, L, FST > (xt::extension)
xdynamic_view_base_impl< xtensor_expression_tag, CT, S, L, FST > (xt::extension)
xdynamic_view_optional (xt::extension)
xellipsis_tag (xt)
xexpression (xt)
xexpression_assigner (xt)
xexpression_assigner_base (xt)
xexpression_assigner_base< xoptional_expression_tag > (xt)
xexpression_assigner_base< xtensor_expression_tag > (xt)
xexpression_holder (xt)
xexpression_tag (xt)
xfiltration (xt)
xfixed_adaptor (xt)
xfixed_container (xt)
xfunction (xt)
xfunction_base (xt::extension)
xfunction_base_impl (xt::extension)
xfunction_base_impl< xoptional_expression_tag, F, CT... > (xt::extension)
xfunction_base_impl< xtensor_expression_tag, F, CT... > (xt::extension)
xfunction_cache (xt)
xfunction_iterator (xt)
xfunction_optional_base (xt::extension)
xfunction_stepper (xt)
xfunctor_adaptor (xt)
xfunctor_applier_base (xt)
xfunctor_iterator (xt)
xfunctor_stepper (xt)
xfunctor_view (xt)
xfunctor_view_base (xt::extension)
xfunctor_view_base_impl (xt::extension)
xfunctor_view_base_impl< xoptional_expression_tag, F, CT > (xt::extension)
xfunctor_view_base_impl< xtensor_expression_tag, F, CT > (xt::extension)
xfunctor_view_optional (xt::extension)
xfunctor_view_temporary_type (xt)
xgenerator (xt)
xgenerator_base (xt::extension)
xgenerator_base_impl (xt::extension)
xgenerator_base_impl< xoptional_expression_tag, F, R, S > (xt::extension)
xgenerator_base_impl< xtensor_expression_tag, F, R, S > (xt::extension)
xgenerator_optional (xt::extension)
xindex_view (xt)
xindex_view_base (xt::extension)
xindex_view_base_impl (xt::extension)
xindex_view_base_impl< xoptional_expression_tag, CT, I > (xt::extension)
xindex_view_base_impl< xtensor_expression_tag, CT, I > (xt::extension)
xindex_view_optional (xt::extension)
xindexed_stepper (xt)
xinitial (xt)
xiterable (xt)
xiterable_inner_types (xt)
xiterable_inner_types< xarray_adaptor< EC, L, SC, Tag > > (xt)
xiterable_inner_types< xarray_container< EC, L, SC, Tag > > (xt)
xiterable_inner_types< xbroadcast< CT, X > > (xt)
xiterable_inner_types< xchunked_array< chunk_storage > > (xt)
xiterable_inner_types< xdynamic_view< CT, S, L, FST > > (xt)
xiterable_inner_types< xfixed_adaptor< EC, S, L, SH, Tag > > (xt)
xiterable_inner_types< xfixed_container< ET, S, L, SH, Tag > > (xt)
xiterable_inner_types< xfunction< F, CT... > > (xt)
xiterable_inner_types< xgenerator< C, R, S > > (xt)
xiterable_inner_types< xindex_view< CT, I > > (xt)
xiterable_inner_types< xmasked_view< CTD, CTM > > (xt)
xiterable_inner_types< xoptional_assembly< VE, FE > > (xt)
xiterable_inner_types< xoptional_assembly_adaptor< VEC, FEC > > (xt)
xiterable_inner_types< xreducer< F, CT, X, O > > (xt)
xiterable_inner_types< xrepeat< CT, R > > (xt)
xiterable_inner_types< xscalar< CT > > (xt)
xiterable_inner_types< xstrided_view< CT, S, L, FST > > (xt)
xiterable_inner_types< xtensor_adaptor< EC, N, L, Tag > > (xt)
xiterable_inner_types< xtensor_container< EC, N, L, Tag > > (xt)
xiterable_inner_types< xtensor_view< EC, N, L, Tag > > (xt)
xiterable_inner_types< xview< CT, S... > > (xt)
xiterator (xt)
xiterator_adaptor (xt)
xiterator_owner_adaptor (xt)
xkeep_slice (xt)
xmasked_value (xt)
xmasked_view (xt)
xmasked_view_stepper (xt)
xmultiindex_iterator (xt)
xnewaxis (xt)
xnewaxis_tag (xt)
xoptional_assembly (xt)
xoptional_assembly_adaptor (xt)
xoptional_assembly_base (xt)
xoptional_assembly_linear_iterator (xt)
xoptional_assembly_linear_iterator_traits (xt)
xoptional_assembly_stepper (xt)
xoptional_assembly_storage (xt)
xoptional_comparable (xt)
xoptional_empty_base (xt::extension)
xoptional_expression_tag (xt)
xproxy_inner_types (xt)
xrange (xt)
xrange_adaptor (xt)
xreducer (xt)
xreducer_base (xt::extension)
xreducer_base_impl (xt::extension)
xreducer_base_impl< xoptional_expression_tag, F, CT, X, O > (xt::extension)
xreducer_base_impl< xtensor_expression_tag, F, CT, X, O > (xt::extension)
xreducer_functors (xt)
xreducer_optional (xt::extension)
xreducer_shape_type (xt)
xreducer_shape_type< fixed_shape< I... >, fixed_shape< J... >, O > (xt)
xreducer_shape_type< fixed_shape< I... >, std::array< I2, N2 >, std::false_type > (xt)
xreducer_shape_type< fixed_shape< I... >, std::array< I2, N2 >, std::true_type > (xt)
xreducer_shape_type< std::array< I1, N1 >, std::array< I2, N2 >, std::false_type > (xt)
xreducer_shape_type< std::array< I1, N1 >, std::array< I2, N2 >, std::true_type > (xt)
xreducer_stepper (xt)
xrepeat (xt)
xrepeat_base (xt::extension)
xrepeat_base_impl (xt::extension)
xrepeat_base_impl< xoptional_expression_tag, CT, X > (xt::extension)
xrepeat_base_impl< xtensor_expression_tag, CT, X > (xt::extension)
xrepeat_optional (xt::extension)
xrepeat_stepper (xt)
xscalar (xt)
xscalar_base (xt::extension)
xscalar_base_impl (xt::extension)
xscalar_base_impl< xoptional_expression_tag, CT > (xt::extension)
xscalar_base_impl< xtensor_expression_tag, CT > (xt::extension)
xscalar_optional_base (xt::extension)
xscalar_optional_traits (xt::extension)
xscalar_stepper (xt)
xsemantic_base (xt)
xsharable_expression (xt)
xshared_expression (xt)
xslice (xt)
xstepped_range (xt)
xstepper (xt)
xstrided_container (xt)
xstrided_view (xt)
xstrided_view_base (xt::extension)
xstrided_view_base (xt)
xstrided_view_base_impl (xt::extension)
xstrided_view_base_impl< xoptional_expression_tag, CT, S, L, FST > (xt::extension)
xstrided_view_base_impl< xtensor_expression_tag, CT, S, L, FST > (xt::extension)
xstrided_view_optional (xt::extension)
xtensor_adaptor (xt)
xtensor_adaptor_base (xt::extension)
xtensor_adaptor_base< EC, N, L, xoptional_expression_tag > (xt::extension)
xtensor_adaptor_base< EC, N, L, xtensor_expression_tag > (xt::extension)
xtensor_adaptor_optional_traits (xt::extension)
xtensor_container (xt)
xtensor_container_base (xt::extension)
xtensor_container_base< EC, N, L, xoptional_expression_tag > (xt::extension)
xtensor_container_base< EC, N, L, xtensor_expression_tag > (xt::extension)
xtensor_container_optional_traits (xt::extension)
xtensor_empty_base (xt::extension)
xtensor_expression_tag (xt)
xtensor_optional_traits (xt::extension)
xtensor_view (xt)
xtensor_view_base (xt::extension)
xtensor_view_base< EC, N, L, xoptional_expression_tag > (xt::extension)
xtensor_view_base< EC, N, L, xtensor_expression_tag > (xt::extension)
xtensor_view_optional_traits (xt::extension)
xtuph (xt::placeholders)
xvectorizer (xt)
xview (xt)
xview_base (xt::extension)
xview_base_impl (xt::extension)
xview_base_impl< xoptional_expression_tag, CT, S... > (xt::extension)
xview_base_impl< xtensor_expression_tag, CT, S... > (xt::extension)
xview_optional (xt::extension)
xview_semantic (xt)
xview_shape_type (xt)
xview_shape_type< fixed_shape< I... >, S... > (xt)
xview_shape_type< std::array< I, L >, S... > (xt)
xview_stepper (xt)
+
+
+
+ + + + diff --git a/classstd_1_1tuple__size_3_01xt_1_1const__array_3_01_t_00_01_n_01_4_01_4.html b/classstd_1_1tuple__size_3_01xt_1_1const__array_3_01_t_00_01_n_01_4_01_4.html new file mode 100644 index 000000000..da6306d2c --- /dev/null +++ b/classstd_1_1tuple__size_3_01xt_1_1const__array_3_01_t_00_01_n_01_4_01_4.html @@ -0,0 +1,131 @@ + + + + + + + +xtensor: std::tuple_size< xt::const_array< T, N > > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
std::tuple_size< xt::const_array< T, N > > Class Template Reference
+
+
+
+Inheritance diagram for std::tuple_size< xt::const_array< T, N > >:
+
+
+ +
+

Detailed Description

+
template<class T, std::size_t N>
+class std::tuple_size< xt::const_array< T, N > >
+

Definition at line 1946 of file xstorage.hpp.

+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classstd_1_1tuple__size_3_01xt_1_1const__array_3_01_t_00_01_n_01_4_01_4.png b/classstd_1_1tuple__size_3_01xt_1_1const__array_3_01_t_00_01_n_01_4_01_4.png new file mode 100644 index 000000000..2534f3c05 Binary files /dev/null and b/classstd_1_1tuple__size_3_01xt_1_1const__array_3_01_t_00_01_n_01_4_01_4.png differ diff --git a/classstd_1_1tuple__size_3_01xt_1_1fixed__shape_3_01_n_8_8_8_01_4_01_4.html b/classstd_1_1tuple__size_3_01xt_1_1fixed__shape_3_01_n_8_8_8_01_4_01_4.html new file mode 100644 index 000000000..0fb793684 --- /dev/null +++ b/classstd_1_1tuple__size_3_01xt_1_1fixed__shape_3_01_n_8_8_8_01_4_01_4.html @@ -0,0 +1,131 @@ + + + + + + + +xtensor: std::tuple_size< xt::fixed_shape< N... > > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
std::tuple_size< xt::fixed_shape< N... > > Class Template Reference
+
+
+
+Inheritance diagram for std::tuple_size< xt::fixed_shape< N... > >:
+
+
+ +
+

Detailed Description

+
template<std::size_t... N>
+class std::tuple_size< xt::fixed_shape< N... > >
+

Definition at line 1951 of file xstorage.hpp.

+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classstd_1_1tuple__size_3_01xt_1_1fixed__shape_3_01_n_8_8_8_01_4_01_4.png b/classstd_1_1tuple__size_3_01xt_1_1fixed__shape_3_01_n_8_8_8_01_4_01_4.png new file mode 100644 index 000000000..c623ccf1e Binary files /dev/null and b/classstd_1_1tuple__size_3_01xt_1_1fixed__shape_3_01_n_8_8_8_01_4_01_4.png differ diff --git a/classstd_1_1tuple__size_3_01xt_1_1sequence__view_3_01_t_00_01_start_00_01_end_01_4_01_4.html b/classstd_1_1tuple__size_3_01xt_1_1sequence__view_3_01_t_00_01_start_00_01_end_01_4_01_4.html new file mode 100644 index 000000000..10d1b5c6d --- /dev/null +++ b/classstd_1_1tuple__size_3_01xt_1_1sequence__view_3_01_t_00_01_start_00_01_end_01_4_01_4.html @@ -0,0 +1,131 @@ + + + + + + + +xtensor: std::tuple_size< xt::sequence_view< T, Start, End > > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
std::tuple_size< xt::sequence_view< T, Start, End > > Class Template Reference
+
+
+
+Inheritance diagram for std::tuple_size< xt::sequence_view< T, Start, End > >:
+
+
+ +
+

Detailed Description

+
template<class T, std::ptrdiff_t Start, std::ptrdiff_t End>
+class std::tuple_size< xt::sequence_view< T, Start, End > >
+

Definition at line 1956 of file xstorage.hpp.

+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classstd_1_1tuple__size_3_01xt_1_1sequence__view_3_01_t_00_01_start_00_01_end_01_4_01_4.png b/classstd_1_1tuple__size_3_01xt_1_1sequence__view_3_01_t_00_01_start_00_01_end_01_4_01_4.png new file mode 100644 index 000000000..7e89f3f9c Binary files /dev/null and b/classstd_1_1tuple__size_3_01xt_1_1sequence__view_3_01_t_00_01_start_00_01_end_01_4_01_4.png differ diff --git a/classxt_1_1aligned__array-members.html b/classxt_1_1aligned__array-members.html new file mode 100644 index 000000000..d3aae7a82 --- /dev/null +++ b/classxt_1_1aligned__array-members.html @@ -0,0 +1,121 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::aligned_array< T, N, Align > Member List
+
+
+ +

This is the complete list of members for xt::aligned_array< T, N, Align >, including all inherited members.

+ + +
allocator_type typedef (defined in xt::aligned_array< T, N, Align >)xt::aligned_array< T, N, Align >
+
+ + + + diff --git a/classxt_1_1aligned__array.html b/classxt_1_1aligned__array.html new file mode 100644 index 000000000..882c1d02c --- /dev/null +++ b/classxt_1_1aligned__array.html @@ -0,0 +1,166 @@ + + + + + + + +xtensor: xt::aligned_array< T, N, Align > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::aligned_array< T, N, Align > Class Template Reference
+
+
+ +

This array class is modeled after std::array but adds optional alignment through a template parameter. + More...

+ +

#include <xstorage.hpp>

+
+Inheritance diagram for xt::aligned_array< T, N, Align >:
+
+
+ +
+ + + + +

+Public Types

using allocator_type = std::conditional_t<Align != 0, xt_simd::aligned_allocator<T, Align>, std::allocator<T>>
 
+

Detailed Description

+
template<class T, std::size_t N, std::size_t Align = ( 0 != 0 ? 0: alignof(T))>
+class xt::aligned_array< T, N, Align >

This array class is modeled after std::array but adds optional alignment through a template parameter.

+

To be moved to xtl, along with the rest of xstorage.hpp

+ +

Definition at line 1425 of file xstorage.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class T, std::size_t N, std::size_t Align = ( 0 != 0 ? 0: alignof(T))>
+ + + + +
using xt::aligned_array< T, N, Align >::allocator_type = std::conditional_t<Align != 0, xt_simd::aligned_allocator<T, Align>, std::allocator<T>>
+
+ +

Definition at line 1431 of file xstorage.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1aligned__array.png b/classxt_1_1aligned__array.png new file mode 100644 index 000000000..c1cf335d6 Binary files /dev/null and b/classxt_1_1aligned__array.png differ diff --git a/classxt_1_1broadcast__error-members.html b/classxt_1_1broadcast__error-members.html new file mode 100644 index 000000000..a26dabc37 --- /dev/null +++ b/classxt_1_1broadcast__error-members.html @@ -0,0 +1,121 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::broadcast_error Member List
+
+
+ +

This is the complete list of members for xt::broadcast_error, including all inherited members.

+ + +
broadcast_error(const char *msg) (defined in xt::broadcast_error)xt::broadcast_errorinlineexplicit
+
+ + + + diff --git a/classxt_1_1broadcast__error.html b/classxt_1_1broadcast__error.html new file mode 100644 index 000000000..3d9cf8c62 --- /dev/null +++ b/classxt_1_1broadcast__error.html @@ -0,0 +1,167 @@ + + + + + + + +xtensor: xt::broadcast_error Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +List of all members
+
xt::broadcast_error Class Reference
+
+
+
+Inheritance diagram for xt::broadcast_error:
+
+
+ +
+ + + + +

+Public Member Functions

 broadcast_error (const char *msg)
 
+

Detailed Description

+
+

Definition at line 63 of file xexception.hpp.

+

Constructor & Destructor Documentation

+ +

◆ broadcast_error()

+ +
+
+ + + + + +
+ + + + + + + +
xt::broadcast_error::broadcast_error (const char * msg)
+ 		+inlineexplicit
+
+ +

Definition at line 67 of file xexception.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/utils/xexception.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1broadcast__error.png b/classxt_1_1broadcast__error.png new file mode 100644 index 000000000..54810cc48 Binary files /dev/null and b/classxt_1_1broadcast__error.png differ diff --git a/classxt_1_1concatenate__error-members.html b/classxt_1_1concatenate__error-members.html new file mode 100644 index 000000000..3b54ea3de --- /dev/null +++ b/classxt_1_1concatenate__error-members.html @@ -0,0 +1,121 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::concatenate_error Member List
+
+
+ +

This is the complete list of members for xt::concatenate_error, including all inherited members.

+ + +
concatenate_error(const char *msg) (defined in xt::concatenate_error)xt::concatenate_errorinlineexplicit
+
+ + + + diff --git a/classxt_1_1concatenate__error.html b/classxt_1_1concatenate__error.html new file mode 100644 index 000000000..51496ce0e --- /dev/null +++ b/classxt_1_1concatenate__error.html @@ -0,0 +1,167 @@ + + + + + + + +xtensor: xt::concatenate_error Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +List of all members
+
xt::concatenate_error Class Reference
+
+
+
+Inheritance diagram for xt::concatenate_error:
+
+
+ +
+ + + + +

+Public Member Functions

 concatenate_error (const char *msg)
 
+

Detailed Description

+
+

Definition at line 80 of file xexception.hpp.

+

Constructor & Destructor Documentation

+ +

◆ concatenate_error()

+ +
+
+ + + + + +
+ + + + + + + +
xt::concatenate_error::concatenate_error (const char * msg)
+ 		+inlineexplicit
+
+ +

Definition at line 84 of file xexception.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/utils/xexception.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1concatenate__error.png b/classxt_1_1concatenate__error.png new file mode 100644 index 000000000..a6b2baac9 Binary files /dev/null and b/classxt_1_1concatenate__error.png differ diff --git a/classxt_1_1extension_1_1xbroadcast__optional-members.html b/classxt_1_1extension_1_1xbroadcast__optional-members.html new file mode 100644 index 000000000..069ff9c7d --- /dev/null +++ b/classxt_1_1extension_1_1xbroadcast__optional-members.html @@ -0,0 +1,127 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xbroadcast_optional< CT, X > Member List
+
+
+ +

This is the complete list of members for xt::extension::xbroadcast_optional< CT, X >, including all inherited members.

+ + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xbroadcast_optional< CT, X >)xt::extension::xbroadcast_optional< CT, X >
const_value_expression typedef (defined in xt::extension::xbroadcast_optional< CT, X >)xt::extension::xbroadcast_optional< CT, X >
expression_tag typedef (defined in xt::extension::xbroadcast_optional< CT, X >)xt::extension::xbroadcast_optional< CT, X >
flag_expression typedef (defined in xt::extension::xbroadcast_optional< CT, X >)xt::extension::xbroadcast_optional< CT, X >
has_value() const (defined in xt::extension::xbroadcast_optional< CT, X >)xt::extension::xbroadcast_optional< CT, X >inline
value() const (defined in xt::extension::xbroadcast_optional< CT, X >)xt::extension::xbroadcast_optional< CT, X >inline
value_expression typedef (defined in xt::extension::xbroadcast_optional< CT, X >)xt::extension::xbroadcast_optional< CT, X >
+
+ + + + diff --git a/classxt_1_1extension_1_1xbroadcast__optional.html b/classxt_1_1extension_1_1xbroadcast__optional.html new file mode 100644 index 000000000..275b4e02f --- /dev/null +++ b/classxt_1_1extension_1_1xbroadcast__optional.html @@ -0,0 +1,320 @@ + + + + + + + +xtensor: xt::extension::xbroadcast_optional< CT, X > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xbroadcast_optional< CT, X > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xbroadcast_optional< CT, X >:
+
+
+ + +xt::extension::xoptional_empty_base< xbroadcast< CT, X > > + +
+ + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using value_expression = xbroadcast<xt::detail::value_expression_t<CT>, X>
 
using flag_expression = xbroadcast<xt::detail::flag_expression_t<CT>, X>
 
using const_value_expression = value_expression
 
using const_flag_expression = flag_expression
 
- Public Types inherited from xt::extension::xoptional_empty_base< xbroadcast< CT, X > >
using expression_tag
 
+ + + + + +

+Public Member Functions

const_value_expression value () const
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xbroadcast< CT, X > >
xbroadcast< CT, X > & derived_cast () noexcept
 
const xbroadcast< CT, X > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class CT, class X>
+class xt::extension::xbroadcast_optional< CT, X >
+

Definition at line 559 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xbroadcast_optional< CT, X >::const_flag_expression = flag_expression
+
+ +

Definition at line 567 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xbroadcast_optional< CT, X >::const_value_expression = value_expression
+
+ +

Definition at line 566 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xbroadcast_optional< CT, X >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 563 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xbroadcast_optional< CT, X >::flag_expression = xbroadcast<xt::detail::flag_expression_t<CT>, X>
+
+ +

Definition at line 565 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xbroadcast_optional< CT, X >::value_expression = xbroadcast<xt::detail::value_expression_t<CT>, X>
+
+ +

Definition at line 564 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value()

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + + + + +
auto xt::extension::xbroadcast_optional< CT, X >::has_value () const
+ 		+inline
+
+ +

Definition at line 1047 of file xoptional.hpp.

+ +
+
+ +

◆ value()

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + + + + +
auto xt::extension::xbroadcast_optional< CT, X >::value () const
+ 		+inline
+
+ +

Definition at line 1041 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xbroadcast__optional.png b/classxt_1_1extension_1_1xbroadcast__optional.png new file mode 100644 index 000000000..83b366476 Binary files /dev/null and b/classxt_1_1extension_1_1xbroadcast__optional.png differ diff --git a/classxt_1_1extension_1_1xcontainer__optional__base-members.html b/classxt_1_1extension_1_1xcontainer__optional__base-members.html new file mode 100644 index 000000000..2272f4a81 --- /dev/null +++ b/classxt_1_1extension_1_1xcontainer__optional__base-members.html @@ -0,0 +1,130 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xcontainer_optional_base< T > Member List
+
+
+ +

This is the complete list of members for xt::extension::xcontainer_optional_base< T >, including all inherited members.

+ + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >
const_value_expression typedef (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >
expression_tag typedef (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >
flag_expression typedef (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >
has_value() (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >inline
has_value() const (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >inline
traits typedef (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >
value() (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >inline
value() const (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >inline
value_expression typedef (defined in xt::extension::xcontainer_optional_base< T >)xt::extension::xcontainer_optional_base< T >
+
+ + + + diff --git a/classxt_1_1extension_1_1xcontainer__optional__base.html b/classxt_1_1extension_1_1xcontainer__optional__base.html new file mode 100644 index 000000000..93a366ad3 --- /dev/null +++ b/classxt_1_1extension_1_1xcontainer__optional__base.html @@ -0,0 +1,402 @@ + + + + + + + +xtensor: xt::extension::xcontainer_optional_base< T > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xcontainer_optional_base< T > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xcontainer_optional_base< T >:
+
+
+ + +xt::extension::xoptional_empty_base< T::derived_type > + +
+ + + + + + + + + + + + + + + + + +

+Public Types

using traits = T
 
using value_expression = typename traits::value_expression
 
using flag_expression = typename traits::flag_expression
 
using const_value_expression = typename traits::const_value_expression
 
using const_flag_expression = typename traits::const_flag_expression
 
using expression_tag = xoptional_expression_tag
 
- Public Types inherited from xt::extension::xoptional_empty_base< T::derived_type >
using expression_tag
 
+ + + + + + + + + +

+Public Member Functions

value_expression value ()
 
const_value_expression value () const
 
flag_expression has_value ()
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< T::derived_type >
T::derived_type & derived_cast () noexcept
 
const T::derived_type & derived_cast () const noexcept
 
+

Detailed Description

+
template<class T>
+class xt::extension::xcontainer_optional_base< T >
+

Definition at line 337 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class T>
+ + + + +
using xt::extension::xcontainer_optional_base< T >::const_flag_expression = typename traits::const_flag_expression
+
+ +

Definition at line 345 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class T>
+ + + + +
using xt::extension::xcontainer_optional_base< T >::const_value_expression = typename traits::const_value_expression
+
+ +

Definition at line 344 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class T>
+ + + + +
using xt::extension::xcontainer_optional_base< T >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 346 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class T>
+ + + + +
using xt::extension::xcontainer_optional_base< T >::flag_expression = typename traits::flag_expression
+
+ +

Definition at line 343 of file xoptional.hpp.

+ +
+
+ +

◆ traits

+ +
+
+
+template<class T>
+ + + + +
using xt::extension::xcontainer_optional_base< T >::traits = T
+
+ +

Definition at line 341 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class T>
+ + + + +
using xt::extension::xcontainer_optional_base< T >::value_expression = typename traits::value_expression
+
+ +

Definition at line 342 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value() [1/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::extension::xcontainer_optional_base< T >::has_value ()
+ 		+inline
+
+ +

Definition at line 948 of file xoptional.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::extension::xcontainer_optional_base< T >::has_value () const
+ 		+inline
+
+ +

Definition at line 954 of file xoptional.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::extension::xcontainer_optional_base< T >::value ()
+ 		+inline
+
+ +

Definition at line 936 of file xoptional.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::extension::xcontainer_optional_base< T >::value () const
+ 		+inline
+
+ +

Definition at line 942 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xcontainer__optional__base.png b/classxt_1_1extension_1_1xcontainer__optional__base.png new file mode 100644 index 000000000..c82fe6929 Binary files /dev/null and b/classxt_1_1extension_1_1xcontainer__optional__base.png differ diff --git a/classxt_1_1extension_1_1xdynamic__view__optional-members.html b/classxt_1_1extension_1_1xdynamic__view__optional-members.html new file mode 100644 index 000000000..a0d8149b4 --- /dev/null +++ b/classxt_1_1extension_1_1xdynamic__view__optional-members.html @@ -0,0 +1,133 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xdynamic_view_optional< CT, S, L, FST > Member List
+
+
+ +

This is the complete list of members for xt::extension::xdynamic_view_optional< CT, S, L, FST >, including all inherited members.

+ + + + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
const_value_expression typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
expression_tag typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
flag_expression typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
has_value() (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >inline
has_value() const (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >inline
ucft typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
ucvt typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
uft typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
uvt typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
value() (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >inline
value() const (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >inline
value_expression typedef (defined in xt::extension::xdynamic_view_optional< CT, S, L, FST >)xt::extension::xdynamic_view_optional< CT, S, L, FST >
+
+ + + + diff --git a/classxt_1_1extension_1_1xdynamic__view__optional.html b/classxt_1_1extension_1_1xdynamic__view__optional.html new file mode 100644 index 000000000..2f6058c3b --- /dev/null +++ b/classxt_1_1extension_1_1xdynamic__view__optional.html @@ -0,0 +1,462 @@ + + + + + + + +xtensor: xt::extension::xdynamic_view_optional< CT, S, L, FST > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xdynamic_view_optional< CT, S, L, FST > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xdynamic_view_optional< CT, S, L, FST >:
+
+
+ + +xt::extension::xoptional_empty_base< xdynamic_view< CT, S, L, FST > > + +
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using uvt = typename std::decay_t<CT>::value_expression
 
using uft = typename std::decay_t<CT>::flag_expression
 
using ucvt = typename std::decay_t<CT>::const_value_expression
 
using ucft = typename std::decay_t<CT>::const_flag_expression
 
using value_expression = xdynamic_view<uvt, S, L, typename FST::template rebind_t<uvt>>
 
using flag_expression = xdynamic_view<uft, S, L, typename FST::template rebind_t<uft>>
 
using const_value_expression = xdynamic_view<ucvt, S, L, typename FST::template rebind_t<ucvt>>
 
using const_flag_expression = xdynamic_view<ucft, S, L, typename FST::template rebind_t<ucft>>
 
- Public Types inherited from xt::extension::xoptional_empty_base< xdynamic_view< CT, S, L, FST > >
using expression_tag
 
+ + + + + + + + + +

+Public Member Functions

value_expression value ()
 
const_value_expression value () const
 
flag_expression has_value ()
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xdynamic_view< CT, S, L, FST > >
xdynamic_view< CT, S, L, FST > & derived_cast () noexcept
 
const xdynamic_view< CT, S, L, FST > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class CT, class S, layout_type L, class FST>
+class xt::extension::xdynamic_view_optional< CT, S, L, FST >
+

Definition at line 524 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::const_flag_expression = xdynamic_view<ucft, S, L, typename FST::template rebind_t<ucft>>
+
+ +

Definition at line 536 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::const_value_expression = xdynamic_view<ucvt, S, L, typename FST::template rebind_t<ucvt>>
+
+ +

Definition at line 535 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 528 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::flag_expression = xdynamic_view<uft, S, L, typename FST::template rebind_t<uft>>
+
+ +

Definition at line 534 of file xoptional.hpp.

+ +
+
+ +

◆ ucft

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::ucft = typename std::decay_t<CT>::const_flag_expression
+
+ +

Definition at line 532 of file xoptional.hpp.

+ +
+
+ +

◆ ucvt

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::ucvt = typename std::decay_t<CT>::const_value_expression
+
+ +

Definition at line 531 of file xoptional.hpp.

+ +
+
+ +

◆ uft

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::uft = typename std::decay_t<CT>::flag_expression
+
+ +

Definition at line 530 of file xoptional.hpp.

+ +
+
+ +

◆ uvt

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::uvt = typename std::decay_t<CT>::value_expression
+
+ +

Definition at line 529 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xdynamic_view_optional< CT, S, L, FST >::value_expression = xdynamic_view<uvt, S, L, typename FST::template rebind_t<uvt>>
+
+ +

Definition at line 533 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xdynamic_view_optional< CT, S, L, FST >::has_value ()
+ 		+inline
+
+ +

Definition at line 1022 of file xoptional.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xdynamic_view_optional< CT, S, L, FST >::has_value () const
+ 		+inline
+
+ +

Definition at line 1028 of file xoptional.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xdynamic_view_optional< CT, S, L, FST >::value ()
+ 		+inline
+
+ +

Definition at line 1010 of file xoptional.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xdynamic_view_optional< CT, S, L, FST >::value () const
+ 		+inline
+
+ +

Definition at line 1016 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xdynamic__view__optional.png b/classxt_1_1extension_1_1xdynamic__view__optional.png new file mode 100644 index 000000000..62e62c516 Binary files /dev/null and b/classxt_1_1extension_1_1xdynamic__view__optional.png differ diff --git a/classxt_1_1extension_1_1xfunction__optional__base-members.html b/classxt_1_1extension_1_1xfunction__optional__base-members.html new file mode 100644 index 000000000..19583a0d2 --- /dev/null +++ b/classxt_1_1extension_1_1xfunction__optional__base-members.html @@ -0,0 +1,131 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xfunction_optional_base< F, CT > Member List
+
+
+ +

This is the complete list of members for xt::extension::xfunction_optional_base< F, CT >, including all inherited members.

+ + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >
const_value_expression typedef (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >
expression_tag typedef (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >
flag_expression typedef (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >
flag_functor typedef (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >
has_value() const (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >inline
has_value_impl(std::index_sequence< I... >) const -> const_flag_expression (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >inline
value() const (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >inline
value_expression typedef (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >
value_functor typedef (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >
value_impl(std::index_sequence< I... >) const -> const_value_expression (defined in xt::extension::xfunction_optional_base< F, CT >)xt::extension::xfunction_optional_base< F, CT >inline
+
+ + + + diff --git a/classxt_1_1extension_1_1xfunction__optional__base.html b/classxt_1_1extension_1_1xfunction__optional__base.html new file mode 100644 index 000000000..9e9fd956c --- /dev/null +++ b/classxt_1_1extension_1_1xfunction__optional__base.html @@ -0,0 +1,430 @@ + + + + + + + +xtensor: xt::extension::xfunction_optional_base< F, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xfunction_optional_base< F, CT > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xfunction_optional_base< F, CT >:
+
+
+ + +xt::extension::xoptional_empty_base< xfunction< F, CT... > > + +
+ + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using value_functor = F
 
using flag_functor = xt::detail::optional_bitwise<bool>
 
using value_expression = xfunction<value_functor, xt::detail::value_expression_t<CT>...>
 
using flag_expression = xfunction<flag_functor, xt::detail::flag_expression_t<CT>...>
 
using const_value_expression = value_expression
 
using const_flag_expression = flag_expression
 
- Public Types inherited from xt::extension::xoptional_empty_base< xfunction< F, CT... > >
using expression_tag
 
+ + + + + + + + + + + +

+Public Member Functions

const_value_expression value () const
 
const_flag_expression has_value () const
 
template<std::size_t... I>
auto value_impl (std::index_sequence< I... >) const -> const_value_expression
 
template<std::size_t... I>
auto has_value_impl (std::index_sequence< I... >) const -> const_flag_expression
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xfunction< F, CT... > >
xfunction< F, CT... > & derived_cast () noexcept
 
const xfunction< F, CT... > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class F, class... CT>
+class xt::extension::xfunction_optional_base< F, CT >
+

Definition at line 485 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::extension::xfunction_optional_base< F, CT >::const_flag_expression = flag_expression
+
+ +

Definition at line 496 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::extension::xfunction_optional_base< F, CT >::const_value_expression = value_expression
+
+ +

Definition at line 495 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::extension::xfunction_optional_base< F, CT >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 489 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::extension::xfunction_optional_base< F, CT >::flag_expression = xfunction<flag_functor, xt::detail::flag_expression_t<CT>...>
+
+ +

Definition at line 494 of file xoptional.hpp.

+ +
+
+ +

◆ flag_functor

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::extension::xfunction_optional_base< F, CT >::flag_functor = xt::detail::optional_bitwise<bool>
+
+ +

Definition at line 491 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::extension::xfunction_optional_base< F, CT >::value_expression = xfunction<value_functor, xt::detail::value_expression_t<CT>...>
+
+ +

Definition at line 493 of file xoptional.hpp.

+ +
+
+ +

◆ value_functor

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::extension::xfunction_optional_base< F, CT >::value_functor = F
+
+ +

Definition at line 490 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunction_optional_base< F, CT >::has_value () const
+ 		+inline
+
+ +

Definition at line 973 of file xoptional.hpp.

+ +
+
+ +

◆ has_value_impl()

+ +
+
+
+template<class F, class... CT>
+
+template<std::size_t... I>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunction_optional_base< F, CT >::has_value_impl (std::index_sequence< I... > ) const -> const_flag_expression +
+ 		+inline
+
+ +

Definition at line 991 of file xoptional.hpp.

+ +
+
+ +

◆ value()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunction_optional_base< F, CT >::value () const
+ 		+inline
+
+ +

Definition at line 967 of file xoptional.hpp.

+ +
+
+ +

◆ value_impl()

+ +
+
+
+template<class F, class... CT>
+
+template<std::size_t... I>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunction_optional_base< F, CT >::value_impl (std::index_sequence< I... > ) const -> const_value_expression +
+ 		+inline
+
+ +

Definition at line 980 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xfunction__optional__base.png b/classxt_1_1extension_1_1xfunction__optional__base.png new file mode 100644 index 000000000..9efec1d14 Binary files /dev/null and b/classxt_1_1extension_1_1xfunction__optional__base.png differ diff --git a/classxt_1_1extension_1_1xfunctor__view__optional-members.html b/classxt_1_1extension_1_1xfunctor__view__optional-members.html new file mode 100644 index 000000000..a515360bc --- /dev/null +++ b/classxt_1_1extension_1_1xfunctor__view__optional-members.html @@ -0,0 +1,133 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xfunctor_view_optional< F, CT > Member List
+
+
+ +

This is the complete list of members for xt::extension::xfunctor_view_optional< F, CT >, including all inherited members.

+ + + + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
const_value_expression typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
expression_tag typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
flag_expression typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
has_value() (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >inline
has_value() const (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >inline
ucft typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
ucvt typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
uft typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
uvt typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
value() (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >inline
value() const (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >inline
value_expression typedef (defined in xt::extension::xfunctor_view_optional< F, CT >)xt::extension::xfunctor_view_optional< F, CT >
+
+ + + + diff --git a/classxt_1_1extension_1_1xfunctor__view__optional.html b/classxt_1_1extension_1_1xfunctor__view__optional.html new file mode 100644 index 000000000..212a25e59 --- /dev/null +++ b/classxt_1_1extension_1_1xfunctor__view__optional.html @@ -0,0 +1,462 @@ + + + + + + + +xtensor: xt::extension::xfunctor_view_optional< F, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xfunctor_view_optional< F, CT > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xfunctor_view_optional< F, CT >:
+
+
+ + +xt::extension::xoptional_empty_base< xfunctor_view< F, CT > > + +
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using uvt = typename std::decay_t<CT>::value_expression
 
using uft = typename std::decay_t<CT>::flag_expression
 
using ucvt = typename std::decay_t<CT>::const_value_expression
 
using ucft = typename std::decay_t<CT>::const_flag_expression
 
using value_expression = xfunctor_view<F, uvt>
 
using flag_expression = uft
 
using const_value_expression = xfunctor_view<F, ucvt>
 
using const_flag_expression = ucft
 
- Public Types inherited from xt::extension::xoptional_empty_base< xfunctor_view< F, CT > >
using expression_tag
 
+ + + + + + + + + +

+Public Member Functions

value_expression value ()
 
const_value_expression value () const
 
flag_expression has_value ()
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xfunctor_view< F, CT > >
xfunctor_view< F, CT > & derived_cast () noexcept
 
const xfunctor_view< F, CT > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class F, class CT>
+class xt::extension::xfunctor_view_optional< F, CT >
+

Definition at line 587 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::const_flag_expression = ucft
+
+ +

Definition at line 599 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::const_value_expression = xfunctor_view<F, ucvt>
+
+ +

Definition at line 598 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 591 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::flag_expression = uft
+
+ +

Definition at line 597 of file xoptional.hpp.

+ +
+
+ +

◆ ucft

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::ucft = typename std::decay_t<CT>::const_flag_expression
+
+ +

Definition at line 595 of file xoptional.hpp.

+ +
+
+ +

◆ ucvt

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::ucvt = typename std::decay_t<CT>::const_value_expression
+
+ +

Definition at line 594 of file xoptional.hpp.

+ +
+
+ +

◆ uft

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::uft = typename std::decay_t<CT>::flag_expression
+
+ +

Definition at line 593 of file xoptional.hpp.

+ +
+
+ +

◆ uvt

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::uvt = typename std::decay_t<CT>::value_expression
+
+ +

Definition at line 592 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::extension::xfunctor_view_optional< F, CT >::value_expression = xfunctor_view<F, uvt>
+
+ +

Definition at line 596 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value() [1/2]

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunctor_view_optional< F, CT >::has_value ()
+ 		+inline
+
+ +

Definition at line 1072 of file xoptional.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunctor_view_optional< F, CT >::has_value () const
+ 		+inline
+
+ +

Definition at line 1078 of file xoptional.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunctor_view_optional< F, CT >::value ()
+ 		+inline
+
+ +

Definition at line 1060 of file xoptional.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xfunctor_view_optional< F, CT >::value () const
+ 		+inline
+
+ +

Definition at line 1066 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xfunctor__view__optional.png b/classxt_1_1extension_1_1xfunctor__view__optional.png new file mode 100644 index 000000000..df46cd7a9 Binary files /dev/null and b/classxt_1_1extension_1_1xfunctor__view__optional.png differ diff --git a/classxt_1_1extension_1_1xgenerator__optional-members.html b/classxt_1_1extension_1_1xgenerator__optional-members.html new file mode 100644 index 000000000..67c790797 --- /dev/null +++ b/classxt_1_1extension_1_1xgenerator__optional-members.html @@ -0,0 +1,131 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xgenerator_optional< F, R, S > Member List
+
+
+ +

This is the complete list of members for xt::extension::xgenerator_optional< F, R, S >, including all inherited members.

+ + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
const_value_expression typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
expression_tag typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
flag_closure typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
flag_expression typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
flag_functor typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
has_value() const (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >inline
value() const (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >inline
value_closure typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
value_expression typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
value_functor typedef (defined in xt::extension::xgenerator_optional< F, R, S >)xt::extension::xgenerator_optional< F, R, S >
+
+ + + + diff --git a/classxt_1_1extension_1_1xgenerator__optional.html b/classxt_1_1extension_1_1xgenerator__optional.html new file mode 100644 index 000000000..89884f3f1 --- /dev/null +++ b/classxt_1_1extension_1_1xgenerator__optional.html @@ -0,0 +1,400 @@ + + + + + + + +xtensor: xt::extension::xgenerator_optional< F, R, S > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xgenerator_optional< F, R, S > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xgenerator_optional< F, R, S >:
+
+
+ + +xt::extension::xoptional_empty_base< xgenerator< F, R, S > > + +
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using value_closure = typename R::value_closure
 
using flag_closure = typename R::flag_closure
 
using value_functor = detail::value_functor_t<F>
 
using flag_functor = detail::flag_functor_t<F>
 
using value_expression = xgenerator<value_functor, value_closure, S>
 
using flag_expression = xgenerator<flag_functor, flag_closure, S>
 
using const_value_expression = value_expression
 
using const_flag_expression = flag_expression
 
- Public Types inherited from xt::extension::xoptional_empty_base< xgenerator< F, R, S > >
using expression_tag
 
+ + + + + +

+Public Member Functions

const_value_expression value () const
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xgenerator< F, R, S > >
xgenerator< F, R, S > & derived_cast () noexcept
 
const xgenerator< F, R, S > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class F, class R, class S>
+class xt::extension::xgenerator_optional< F, R, S >
+

Definition at line 854 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::const_flag_expression = flag_expression
+
+ +

Definition at line 866 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::const_value_expression = value_expression
+
+ +

Definition at line 865 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 858 of file xoptional.hpp.

+ +
+
+ +

◆ flag_closure

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::flag_closure = typename R::flag_closure
+
+ +

Definition at line 860 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::flag_expression = xgenerator<flag_functor, flag_closure, S>
+
+ +

Definition at line 864 of file xoptional.hpp.

+ +
+
+ +

◆ flag_functor

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::flag_functor = detail::flag_functor_t<F>
+
+ +

Definition at line 862 of file xoptional.hpp.

+ +
+
+ +

◆ value_closure

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::value_closure = typename R::value_closure
+
+ +

Definition at line 859 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::value_expression = xgenerator<value_functor, value_closure, S>
+
+ +

Definition at line 863 of file xoptional.hpp.

+ +
+
+ +

◆ value_functor

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::extension::xgenerator_optional< F, R, S >::value_functor = detail::value_functor_t<F>
+
+ +

Definition at line 861 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value()

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + + + + +
auto xt::extension::xgenerator_optional< F, R, S >::has_value () const
+ 		+inline
+
+ +

Definition at line 1230 of file xoptional.hpp.

+ +
+
+ +

◆ value()

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + + + + +
auto xt::extension::xgenerator_optional< F, R, S >::value () const
+ 		+inline
+
+ +

Definition at line 1222 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xgenerator__optional.png b/classxt_1_1extension_1_1xgenerator__optional.png new file mode 100644 index 000000000..706c10b0d Binary files /dev/null and b/classxt_1_1extension_1_1xgenerator__optional.png differ diff --git a/classxt_1_1extension_1_1xindex__view__optional-members.html b/classxt_1_1extension_1_1xindex__view__optional-members.html new file mode 100644 index 000000000..669c0da92 --- /dev/null +++ b/classxt_1_1extension_1_1xindex__view__optional-members.html @@ -0,0 +1,133 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xindex_view_optional< CT, I > Member List
+
+
+ +

This is the complete list of members for xt::extension::xindex_view_optional< CT, I >, including all inherited members.

+ + + + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
const_value_expression typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
expression_tag typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
flag_expression typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
has_value() (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >inline
has_value() const (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >inline
ucft typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
ucvt typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
uft typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
uvt typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
value() (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >inline
value() const (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >inline
value_expression typedef (defined in xt::extension::xindex_view_optional< CT, I >)xt::extension::xindex_view_optional< CT, I >
+
+ + + + diff --git a/classxt_1_1extension_1_1xindex__view__optional.html b/classxt_1_1extension_1_1xindex__view__optional.html new file mode 100644 index 000000000..b61253e59 --- /dev/null +++ b/classxt_1_1extension_1_1xindex__view__optional.html @@ -0,0 +1,462 @@ + + + + + + + +xtensor: xt::extension::xindex_view_optional< CT, I > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xindex_view_optional< CT, I > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xindex_view_optional< CT, I >:
+
+
+ + +xt::extension::xoptional_empty_base< xindex_view< CT, I > > + +
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using uvt = typename std::decay_t<CT>::value_expression
 
using ucvt = typename std::decay_t<CT>::const_value_expression
 
using uft = typename std::decay_t<CT>::flag_expression
 
using ucft = typename std::decay_t<CT>::const_flag_expression
 
using value_expression = xindex_view<uvt, I>
 
using flag_expression = xindex_view<uft, I>
 
using const_value_expression = xindex_view<ucvt, I>
 
using const_flag_expression = xindex_view<ucft, I>
 
- Public Types inherited from xt::extension::xoptional_empty_base< xindex_view< CT, I > >
using expression_tag
 
+ + + + + + + + + +

+Public Member Functions

value_expression value ()
 
const_value_expression value () const
 
flag_expression has_value ()
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xindex_view< CT, I > >
xindex_view< CT, I > & derived_cast () noexcept
 
const xindex_view< CT, I > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class CT, class I>
+class xt::extension::xindex_view_optional< CT, I >
+

Definition at line 622 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::const_flag_expression = xindex_view<ucft, I>
+
+ +

Definition at line 634 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::const_value_expression = xindex_view<ucvt, I>
+
+ +

Definition at line 633 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 626 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::flag_expression = xindex_view<uft, I>
+
+ +

Definition at line 632 of file xoptional.hpp.

+ +
+
+ +

◆ ucft

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::ucft = typename std::decay_t<CT>::const_flag_expression
+
+ +

Definition at line 630 of file xoptional.hpp.

+ +
+
+ +

◆ ucvt

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::ucvt = typename std::decay_t<CT>::const_value_expression
+
+ +

Definition at line 628 of file xoptional.hpp.

+ +
+
+ +

◆ uft

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::uft = typename std::decay_t<CT>::flag_expression
+
+ +

Definition at line 629 of file xoptional.hpp.

+ +
+
+ +

◆ uvt

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::uvt = typename std::decay_t<CT>::value_expression
+
+ +

Definition at line 627 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::extension::xindex_view_optional< CT, I >::value_expression = xindex_view<uvt, I>
+
+ +

Definition at line 631 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value() [1/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::extension::xindex_view_optional< CT, I >::has_value ()
+ 		+inline
+
+ +

Definition at line 1103 of file xoptional.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::extension::xindex_view_optional< CT, I >::has_value () const
+ 		+inline
+
+ +

Definition at line 1109 of file xoptional.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::extension::xindex_view_optional< CT, I >::value ()
+ 		+inline
+
+ +

Definition at line 1091 of file xoptional.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::extension::xindex_view_optional< CT, I >::value () const
+ 		+inline
+
+ +

Definition at line 1097 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xindex__view__optional.png b/classxt_1_1extension_1_1xindex__view__optional.png new file mode 100644 index 000000000..783164bd1 Binary files /dev/null and b/classxt_1_1extension_1_1xindex__view__optional.png differ diff --git a/classxt_1_1extension_1_1xoptional__empty__base-members.html b/classxt_1_1extension_1_1xoptional__empty__base-members.html new file mode 100644 index 000000000..a881ab426 --- /dev/null +++ b/classxt_1_1extension_1_1xoptional__empty__base-members.html @@ -0,0 +1,123 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xoptional_empty_base< D > Member List
+
+
+ +

This is the complete list of members for xt::extension::xoptional_empty_base< D >, including all inherited members.

+ + + + +
derived_cast() noexcept (defined in xt::extension::xoptional_empty_base< D >)xt::extension::xoptional_empty_base< D >inlineprotected
derived_cast() const noexcept (defined in xt::extension::xoptional_empty_base< D >)xt::extension::xoptional_empty_base< D >inlineprotected
expression_tag typedef (defined in xt::extension::xoptional_empty_base< D >)xt::extension::xoptional_empty_base< D >
+
+ + + + diff --git a/classxt_1_1extension_1_1xoptional__empty__base.html b/classxt_1_1extension_1_1xoptional__empty__base.html new file mode 100644 index 000000000..da15d57dc --- /dev/null +++ b/classxt_1_1extension_1_1xoptional__empty__base.html @@ -0,0 +1,229 @@ + + + + + + + +xtensor: xt::extension::xoptional_empty_base< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Protected Member Functions | +List of all members
+
xt::extension::xoptional_empty_base< D > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xoptional_empty_base< D >:
+
+
+ + +xt::extension::xcontainer_optional_base< traits > + +
+ + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
+ + + + + +

+Protected Member Functions

D & derived_cast () noexcept
 
const D & derived_cast () const noexcept
 
+

Detailed Description

+
template<class D>
+class xt::extension::xoptional_empty_base< D >
+

Definition at line 57 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ expression_tag

+ +
+
+
+template<class D>
+ + + + +
using xt::extension::xoptional_empty_base< D >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 61 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ derived_cast() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
const D & xt::extension::xoptional_empty_base< D >::derived_cast () const
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 892 of file xoptional.hpp.

+ +
+
+ +

◆ derived_cast() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
D & xt::extension::xoptional_empty_base< D >::derived_cast ()
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 886 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xoptional__empty__base.png b/classxt_1_1extension_1_1xoptional__empty__base.png new file mode 100644 index 000000000..385a8f1c4 Binary files /dev/null and b/classxt_1_1extension_1_1xoptional__empty__base.png differ diff --git a/classxt_1_1extension_1_1xreducer__optional-members.html b/classxt_1_1extension_1_1xreducer__optional-members.html new file mode 100644 index 000000000..2a45fedf4 --- /dev/null +++ b/classxt_1_1extension_1_1xreducer__optional-members.html @@ -0,0 +1,133 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xreducer_optional< F, CT, X, O > Member List
+
+
+ +

This is the complete list of members for xt::extension::xreducer_optional< F, CT, X, O >, including all inherited members.

+ + + + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
const_value_expression typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
expression_tag typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
flag_expression typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
flag_reducer typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
has_value() const (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >inline
rebound_functors_type typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
rebound_reduce_options_flag typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
rebound_reduce_options_values typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
rebound_result_type typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
result_type typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
value() const (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >inline
value_expression typedef (defined in xt::extension::xreducer_optional< F, CT, X, O >)xt::extension::xreducer_optional< F, CT, X, O >
+
+ + + + diff --git a/classxt_1_1extension_1_1xreducer__optional.html b/classxt_1_1extension_1_1xreducer__optional.html new file mode 100644 index 000000000..abfeba6a5 --- /dev/null +++ b/classxt_1_1extension_1_1xreducer__optional.html @@ -0,0 +1,440 @@ + + + + + + + +xtensor: xt::extension::xreducer_optional< F, CT, X, O > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xreducer_optional< F, CT, X, O > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xreducer_optional< F, CT, X, O >:
+
+
+ + +xt::extension::xoptional_empty_base< xreducer< F, CT, X, O > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using result_type = typename F::init_value_type
 
using rebound_result_type = typename result_type::value_type
 
using rebound_functors_type = typename F::template rebind_t<rebound_result_type>
 
using rebound_reduce_options_values = typename O::template rebind_t<rebound_result_type>
 
using rebound_reduce_options_flag = typename O::template rebind_t<bool>
 
using flag_reducer = xreducer_functors<xt::detail::optional_bitwise<bool>, xt::const_value<bool>>
 
using flag_expression = xreducer<flag_reducer, xt::detail::flag_expression_t<CT>, X, rebound_reduce_options_flag>
 
using value_expression = xreducer<rebound_functors_type, xt::detail::value_expression_t<CT>, X, rebound_reduce_options_values>
 
using const_value_expression = value_expression
 
using const_flag_expression = flag_expression
 
- Public Types inherited from xt::extension::xoptional_empty_base< xreducer< F, CT, X, O > >
using expression_tag
 
+ + + + + +

+Public Member Functions

const_value_expression value () const
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xreducer< F, CT, X, O > >
xreducer< F, CT, X, O > & derived_cast () noexcept
 
const xreducer< F, CT, X, O > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class F, class CT, class X, class O>
+class xt::extension::xreducer_optional< F, CT, X, O >
+

Definition at line 657 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::const_flag_expression = flag_expression
+
+ +

Definition at line 674 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::const_value_expression = value_expression
+
+ +

Definition at line 673 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 661 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::flag_expression = xreducer<flag_reducer, xt::detail::flag_expression_t<CT>, X, rebound_reduce_options_flag>
+
+ +

Definition at line 670 of file xoptional.hpp.

+ +
+
+ +

◆ flag_reducer

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::flag_reducer = xreducer_functors<xt::detail::optional_bitwise<bool>, xt::const_value<bool>>
+
+ +

Definition at line 669 of file xoptional.hpp.

+ +
+
+ +

◆ rebound_functors_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::rebound_functors_type = typename F::template rebind_t<rebound_result_type>
+
+ +

Definition at line 665 of file xoptional.hpp.

+ +
+
+ +

◆ rebound_reduce_options_flag

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::rebound_reduce_options_flag = typename O::template rebind_t<bool>
+
+ +

Definition at line 667 of file xoptional.hpp.

+ +
+
+ +

◆ rebound_reduce_options_values

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::rebound_reduce_options_values = typename O::template rebind_t<rebound_result_type>
+
+ +

Definition at line 666 of file xoptional.hpp.

+ +
+
+ +

◆ rebound_result_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::rebound_result_type = typename result_type::value_type
+
+ +

Definition at line 664 of file xoptional.hpp.

+ +
+
+ +

◆ result_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::result_type = typename F::init_value_type
+
+ +

Definition at line 662 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::extension::xreducer_optional< F, CT, X, O >::value_expression = xreducer<rebound_functors_type, xt::detail::value_expression_t<CT>, X, rebound_reduce_options_values>
+
+ +

Definition at line 671 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::extension::xreducer_optional< F, CT, X, O >::has_value () const
+ 		+inline
+
+ +

Definition at line 1138 of file xoptional.hpp.

+ +
+
+ +

◆ value()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::extension::xreducer_optional< F, CT, X, O >::value () const
+ 		+inline
+
+ +

Definition at line 1122 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xreducer__optional.png b/classxt_1_1extension_1_1xreducer__optional.png new file mode 100644 index 000000000..fed52015b Binary files /dev/null and b/classxt_1_1extension_1_1xreducer__optional.png differ diff --git a/classxt_1_1extension_1_1xrepeat__optional-members.html b/classxt_1_1extension_1_1xrepeat__optional-members.html new file mode 100644 index 000000000..bc893f025 --- /dev/null +++ b/classxt_1_1extension_1_1xrepeat__optional-members.html @@ -0,0 +1,127 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xrepeat_optional< CT, X > Member List
+
+
+ +

This is the complete list of members for xt::extension::xrepeat_optional< CT, X >, including all inherited members.

+ + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xrepeat_optional< CT, X >)xt::extension::xrepeat_optional< CT, X >
const_value_expression typedef (defined in xt::extension::xrepeat_optional< CT, X >)xt::extension::xrepeat_optional< CT, X >
expression_tag typedef (defined in xt::extension::xrepeat_optional< CT, X >)xt::extension::xrepeat_optional< CT, X >
flag_expression typedef (defined in xt::extension::xrepeat_optional< CT, X >)xt::extension::xrepeat_optional< CT, X >
has_value() const (defined in xt::extension::xrepeat_optional< CT, X >)xt::extension::xrepeat_optional< CT, X >
value() const (defined in xt::extension::xrepeat_optional< CT, X >)xt::extension::xrepeat_optional< CT, X >
value_expression typedef (defined in xt::extension::xrepeat_optional< CT, X >)xt::extension::xrepeat_optional< CT, X >
+
+ + + + diff --git a/classxt_1_1extension_1_1xrepeat__optional.html b/classxt_1_1extension_1_1xrepeat__optional.html new file mode 100644 index 000000000..9d36595f8 --- /dev/null +++ b/classxt_1_1extension_1_1xrepeat__optional.html @@ -0,0 +1,263 @@ + + + + + + + +xtensor: xt::extension::xrepeat_optional< CT, X > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xrepeat_optional< CT, X > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xrepeat_optional< CT, X >:
+
+
+ + +xt::extension::xoptional_empty_base< xrepeat< CT, X > > + +
+ + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using value_expression = xbroadcast<xt::detail::value_expression_t<CT>, X>
 
using flag_expression = xbroadcast<xt::detail::flag_expression_t<CT>, X>
 
using const_value_expression = value_expression
 
using const_flag_expression = flag_expression
 
- Public Types inherited from xt::extension::xoptional_empty_base< xrepeat< CT, X > >
using expression_tag
 
+ + + + + +

+Public Member Functions

+const_value_expression value () const
 
+const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xrepeat< CT, X > >
xrepeat< CT, X > & derived_cast () noexcept
 
const xrepeat< CT, X > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class CT, class X>
+class xt::extension::xrepeat_optional< CT, X >
+

Definition at line 694 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xrepeat_optional< CT, X >::const_flag_expression = flag_expression
+
+ +

Definition at line 702 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xrepeat_optional< CT, X >::const_value_expression = value_expression
+
+ +

Definition at line 701 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xrepeat_optional< CT, X >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 698 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xrepeat_optional< CT, X >::flag_expression = xbroadcast<xt::detail::flag_expression_t<CT>, X>
+
+ +

Definition at line 700 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::extension::xrepeat_optional< CT, X >::value_expression = xbroadcast<xt::detail::value_expression_t<CT>, X>
+
+ +

Definition at line 699 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xrepeat__optional.png b/classxt_1_1extension_1_1xrepeat__optional.png new file mode 100644 index 000000000..9685bb0f5 Binary files /dev/null and b/classxt_1_1extension_1_1xrepeat__optional.png differ diff --git a/classxt_1_1extension_1_1xscalar__optional__base-members.html b/classxt_1_1extension_1_1xscalar__optional__base-members.html new file mode 100644 index 000000000..98a329d40 --- /dev/null +++ b/classxt_1_1extension_1_1xscalar__optional__base-members.html @@ -0,0 +1,130 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xscalar_optional_base< CT > Member List
+
+
+ +

This is the complete list of members for xt::extension::xscalar_optional_base< CT >, including all inherited members.

+ + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >
const_value_expression typedef (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >
expression_tag typedef (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >
flag_expression typedef (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >
has_value() (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >inline
has_value() const (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >inline
traits typedef (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >
value() (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >inline
value() const (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >inline
value_expression typedef (defined in xt::extension::xscalar_optional_base< CT >)xt::extension::xscalar_optional_base< CT >
+
+ + + + diff --git a/classxt_1_1extension_1_1xscalar__optional__base.html b/classxt_1_1extension_1_1xscalar__optional__base.html new file mode 100644 index 000000000..ad6279f14 --- /dev/null +++ b/classxt_1_1extension_1_1xscalar__optional__base.html @@ -0,0 +1,402 @@ + + + + + + + +xtensor: xt::extension::xscalar_optional_base< CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xscalar_optional_base< CT > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xscalar_optional_base< CT >:
+
+
+ + +xt::extension::xoptional_empty_base< xscalar< CT > > + +
+ + + + + + + + + + + + + + + + + +

+Public Types

using traits = xscalar_optional_traits<CT>
 
using value_expression = typename traits::value_expression
 
using flag_expression = typename traits::flag_expression
 
using const_value_expression = typename traits::const_value_expression
 
using const_flag_expression = typename traits::const_flag_expression
 
using expression_tag = xoptional_expression_tag
 
- Public Types inherited from xt::extension::xoptional_empty_base< xscalar< CT > >
using expression_tag
 
+ + + + + + + + + +

+Public Member Functions

value_expression value ()
 
const_value_expression value () const
 
flag_expression has_value ()
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xscalar< CT > >
xscalar< CT > & derived_cast () noexcept
 
const xscalar< CT > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class CT>
+class xt::extension::xscalar_optional_base< CT >
+

Definition at line 305 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class CT>
+ + + + +
using xt::extension::xscalar_optional_base< CT >::const_flag_expression = typename traits::const_flag_expression
+
+ +

Definition at line 313 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class CT>
+ + + + +
using xt::extension::xscalar_optional_base< CT >::const_value_expression = typename traits::const_value_expression
+
+ +

Definition at line 312 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT>
+ + + + +
using xt::extension::xscalar_optional_base< CT >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 314 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class CT>
+ + + + +
using xt::extension::xscalar_optional_base< CT >::flag_expression = typename traits::flag_expression
+
+ +

Definition at line 311 of file xoptional.hpp.

+ +
+
+ +

◆ traits

+ +
+
+
+template<class CT>
+ + + + +
using xt::extension::xscalar_optional_base< CT >::traits = xscalar_optional_traits<CT>
+
+ +

Definition at line 309 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CT>
+ + + + +
using xt::extension::xscalar_optional_base< CT >::value_expression = typename traits::value_expression
+
+ +

Definition at line 310 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xscalar_optional_base< CT >::has_value ()
+ 		+inline
+
+ +

Definition at line 917 of file xoptional.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xscalar_optional_base< CT >::has_value () const
+ 		+inline
+
+ +

Definition at line 923 of file xoptional.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xscalar_optional_base< CT >::value ()
+ 		+inline
+
+ +

Definition at line 905 of file xoptional.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::extension::xscalar_optional_base< CT >::value () const
+ 		+inline
+
+ +

Definition at line 911 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xscalar__optional__base.png b/classxt_1_1extension_1_1xscalar__optional__base.png new file mode 100644 index 000000000..dee230b25 Binary files /dev/null and b/classxt_1_1extension_1_1xscalar__optional__base.png differ diff --git a/classxt_1_1extension_1_1xstrided__view__optional-members.html b/classxt_1_1extension_1_1xstrided__view__optional-members.html new file mode 100644 index 000000000..c59d07fbf --- /dev/null +++ b/classxt_1_1extension_1_1xstrided__view__optional-members.html @@ -0,0 +1,133 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xstrided_view_optional< CT, S, L, FST > Member List
+
+
+ +

This is the complete list of members for xt::extension::xstrided_view_optional< CT, S, L, FST >, including all inherited members.

+ + + + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
const_value_expression typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
expression_tag typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
flag_expression typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
has_value() (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >inline
has_value() const (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >inline
ucft typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
ucvt typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
uft typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
uvt typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
value() (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >inline
value() const (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >inline
value_expression typedef (defined in xt::extension::xstrided_view_optional< CT, S, L, FST >)xt::extension::xstrided_view_optional< CT, S, L, FST >
+
+ + + + diff --git a/classxt_1_1extension_1_1xstrided__view__optional.html b/classxt_1_1extension_1_1xstrided__view__optional.html new file mode 100644 index 000000000..4e557bd44 --- /dev/null +++ b/classxt_1_1extension_1_1xstrided__view__optional.html @@ -0,0 +1,462 @@ + + + + + + + +xtensor: xt::extension::xstrided_view_optional< CT, S, L, FST > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xstrided_view_optional< CT, S, L, FST > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xstrided_view_optional< CT, S, L, FST >:
+
+
+ + +xt::extension::xoptional_empty_base< xstrided_view< CT, S, L, FST > > + +
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using uvt = typename std::decay_t<CT>::value_expression
 
using uft = typename std::decay_t<CT>::flag_expression
 
using ucvt = typename std::decay_t<CT>::const_value_expression
 
using ucft = typename std::decay_t<CT>::const_flag_expression
 
using value_expression = xstrided_view<uvt, S, L, typename FST::template rebind_t<uvt>>
 
using flag_expression = xstrided_view<uft, S, L, typename FST::template rebind_t<uft>>
 
using const_value_expression = xstrided_view<ucvt, S, L, typename FST::template rebind_t<ucvt>>
 
using const_flag_expression = xstrided_view<ucft, S, L, typename FST::template rebind_t<ucft>>
 
- Public Types inherited from xt::extension::xoptional_empty_base< xstrided_view< CT, S, L, FST > >
using expression_tag
 
+ + + + + + + + + +

+Public Member Functions

value_expression value ()
 
const_value_expression value () const
 
flag_expression has_value ()
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xstrided_view< CT, S, L, FST > >
xstrided_view< CT, S, L, FST > & derived_cast () noexcept
 
const xstrided_view< CT, S, L, FST > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class CT, class S, layout_type L, class FST>
+class xt::extension::xstrided_view_optional< CT, S, L, FST >
+

Definition at line 722 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::const_flag_expression = xstrided_view<ucft, S, L, typename FST::template rebind_t<ucft>>
+
+ +

Definition at line 734 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::const_value_expression = xstrided_view<ucvt, S, L, typename FST::template rebind_t<ucvt>>
+
+ +

Definition at line 733 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 726 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::flag_expression = xstrided_view<uft, S, L, typename FST::template rebind_t<uft>>
+
+ +

Definition at line 732 of file xoptional.hpp.

+ +
+
+ +

◆ ucft

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::ucft = typename std::decay_t<CT>::const_flag_expression
+
+ +

Definition at line 730 of file xoptional.hpp.

+ +
+
+ +

◆ ucvt

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::ucvt = typename std::decay_t<CT>::const_value_expression
+
+ +

Definition at line 729 of file xoptional.hpp.

+ +
+
+ +

◆ uft

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::uft = typename std::decay_t<CT>::flag_expression
+
+ +

Definition at line 728 of file xoptional.hpp.

+ +
+
+ +

◆ uvt

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::uvt = typename std::decay_t<CT>::value_expression
+
+ +

Definition at line 727 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + +
using xt::extension::xstrided_view_optional< CT, S, L, FST >::value_expression = xstrided_view<uvt, S, L, typename FST::template rebind_t<uvt>>
+
+ +

Definition at line 731 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xstrided_view_optional< CT, S, L, FST >::has_value ()
+ 		+inline
+
+ +

Definition at line 1172 of file xoptional.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xstrided_view_optional< CT, S, L, FST >::has_value () const
+ 		+inline
+
+ +

Definition at line 1178 of file xoptional.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xstrided_view_optional< CT, S, L, FST >::value ()
+ 		+inline
+
+ +

Definition at line 1160 of file xoptional.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::extension::xstrided_view_optional< CT, S, L, FST >::value () const
+ 		+inline
+
+ +

Definition at line 1166 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xstrided__view__optional.png b/classxt_1_1extension_1_1xstrided__view__optional.png new file mode 100644 index 000000000..e911809a9 Binary files /dev/null and b/classxt_1_1extension_1_1xstrided__view__optional.png differ diff --git a/classxt_1_1extension_1_1xview__optional-members.html b/classxt_1_1extension_1_1xview__optional-members.html new file mode 100644 index 000000000..f01d17380 --- /dev/null +++ b/classxt_1_1extension_1_1xview__optional-members.html @@ -0,0 +1,133 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::extension::xview_optional< CT, S > Member List
+
+
+ +

This is the complete list of members for xt::extension::xview_optional< CT, S >, including all inherited members.

+ + + + + + + + + + + + + + +
const_flag_expression typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
const_value_expression typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
expression_tag typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
flag_expression typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
has_value() (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >inline
has_value() const (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >inline
ucft typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
ucvt typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
uft typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
uvt typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
value() (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >inline
value() const (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >inline
value_expression typedef (defined in xt::extension::xview_optional< CT, S >)xt::extension::xview_optional< CT, S >
+
+ + + + diff --git a/classxt_1_1extension_1_1xview__optional.html b/classxt_1_1extension_1_1xview__optional.html new file mode 100644 index 000000000..5c8614c0c --- /dev/null +++ b/classxt_1_1extension_1_1xview__optional.html @@ -0,0 +1,462 @@ + + + + + + + +xtensor: xt::extension::xview_optional< CT, S > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::extension::xview_optional< CT, S > Class Template Reference
+
+
+
+Inheritance diagram for xt::extension::xview_optional< CT, S >:
+
+
+ + +xt::extension::xoptional_empty_base< xview< CT, S... > > + +
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using expression_tag = xoptional_expression_tag
 
using uvt = typename std::decay_t<CT>::value_expression
 
using uft = typename std::decay_t<CT>::flag_expression
 
using ucvt = typename std::decay_t<CT>::const_value_expression
 
using ucft = typename std::decay_t<CT>::const_flag_expression
 
using value_expression = xview<uvt, S...>
 
using flag_expression = xview<uft, S...>
 
using const_value_expression = xview<ucvt, S...>
 
using const_flag_expression = xview<ucft, S...>
 
- Public Types inherited from xt::extension::xoptional_empty_base< xview< CT, S... > >
using expression_tag
 
+ + + + + + + + + +

+Public Member Functions

value_expression value ()
 
const_value_expression value () const
 
flag_expression has_value ()
 
const_flag_expression has_value () const
 
+ + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::extension::xoptional_empty_base< xview< CT, S... > >
xview< CT, S... > & derived_cast () noexcept
 
const xview< CT, S... > & derived_cast () const noexcept
 
+

Detailed Description

+
template<class CT, class... S>
+class xt::extension::xview_optional< CT, S >
+

Definition at line 757 of file xoptional.hpp.

+

Member Typedef Documentation

+ +

◆ const_flag_expression

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::const_flag_expression = xview<ucft, S...>
+
+ +

Definition at line 769 of file xoptional.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::const_value_expression = xview<ucvt, S...>
+
+ +

Definition at line 768 of file xoptional.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 761 of file xoptional.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::flag_expression = xview<uft, S...>
+
+ +

Definition at line 767 of file xoptional.hpp.

+ +
+
+ +

◆ ucft

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::ucft = typename std::decay_t<CT>::const_flag_expression
+
+ +

Definition at line 765 of file xoptional.hpp.

+ +
+
+ +

◆ ucvt

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::ucvt = typename std::decay_t<CT>::const_value_expression
+
+ +

Definition at line 764 of file xoptional.hpp.

+ +
+
+ +

◆ uft

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::uft = typename std::decay_t<CT>::flag_expression
+
+ +

Definition at line 763 of file xoptional.hpp.

+ +
+
+ +

◆ uvt

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::uvt = typename std::decay_t<CT>::value_expression
+
+ +

Definition at line 762 of file xoptional.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::extension::xview_optional< CT, S >::value_expression = xview<uvt, S...>
+
+ +

Definition at line 766 of file xoptional.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ has_value() [1/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::extension::xview_optional< CT, S >::has_value ()
+ 		+inline
+
+ +

Definition at line 1203 of file xoptional.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::extension::xview_optional< CT, S >::has_value () const
+ 		+inline
+
+ +

Definition at line 1209 of file xoptional.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::extension::xview_optional< CT, S >::value ()
+ 		+inline
+
+ +

Definition at line 1191 of file xoptional.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::extension::xview_optional< CT, S >::value () const
+ 		+inline
+
+ +

Definition at line 1197 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1extension_1_1xview__optional.png b/classxt_1_1extension_1_1xview__optional.png new file mode 100644 index 000000000..a88987c39 Binary files /dev/null and b/classxt_1_1extension_1_1xview__optional.png differ diff --git a/classxt_1_1fixed__shape-members.html b/classxt_1_1fixed__shape-members.html new file mode 100644 index 000000000..aa5aea218 --- /dev/null +++ b/classxt_1_1fixed__shape-members.html @@ -0,0 +1,135 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::fixed_shape< X > Member List
+
+
+ +

This is the complete list of members for xt::fixed_shape< X >, including all inherited members.

+ + + + + + + + + + + + + + + + +
begin() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
cast_type typedef (defined in xt::fixed_shape< X >)xt::fixed_shape< X >
cbegin() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
cend() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
const_iterator typedef (defined in xt::fixed_shape< X >)xt::fixed_shape< X >
empty() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
end() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
get() (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inlinestatic
operator cast_type() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
operator[](std::size_t idx) const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
rbegin() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
rend() const (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inline
size() (defined in xt::fixed_shape< X >)xt::fixed_shape< X >inlinestatic
size_type typedef (defined in xt::fixed_shape< X >)xt::fixed_shape< X >
value_type typedef (defined in xt::fixed_shape< X >)xt::fixed_shape< X >
+
+ + + + diff --git a/classxt_1_1fixed__shape.html b/classxt_1_1fixed__shape.html new file mode 100644 index 000000000..6c0ab2d4c --- /dev/null +++ b/classxt_1_1fixed__shape.html @@ -0,0 +1,573 @@ + + + + + + + +xtensor: xt::fixed_shape< X > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +List of all members
+
xt::fixed_shape< X > Class Template Reference
+
+
+ +

Fixed shape implementation for compile time defined arrays. + More...

+ +

#include <xstorage.hpp>

+ + + + + + + + + + +

+Public Types

using cast_type = const_array<std::size_t, sizeof...(X)>
 
using value_type = std::size_t
 
using size_type = std::size_t
 
using const_iterator = typename cast_type::const_iterator
 
+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

constexpr operator cast_type () const
 
constexpr auto begin () const
 
constexpr auto end () const
 
auto rbegin () const
 
auto rend () const
 
constexpr auto cbegin () const
 
constexpr auto cend () const
 
constexpr std::size_t operator[] (std::size_t idx) const
 
constexpr bool empty () const
 
+ + + + + + +

+Static Public Member Functions

static constexpr std::size_t size ()
 
template<std::size_t idx>
static constexpr auto get ()
 
+

Detailed Description

+
template<std::size_t... X>
+class xt::fixed_shape< X >

Fixed shape implementation for compile time defined arrays.

+
See also
xshape
+ +

Definition at line 1657 of file xstorage.hpp.

+

Member Typedef Documentation

+ +

◆ cast_type

+ +
+
+
+template<std::size_t... X>
+ + + + +
using xt::fixed_shape< X >::cast_type = const_array<std::size_t, sizeof...(X)>
+
+ +

Definition at line 1665 of file xstorage.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<std::size_t... X>
+ + + + +
using xt::fixed_shape< X >::const_iterator = typename cast_type::const_iterator
+
+ +

Definition at line 1670 of file xstorage.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<std::size_t... X>
+ + + + +
using xt::fixed_shape< X >::size_type = std::size_t
+
+ +

Definition at line 1669 of file xstorage.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<std::size_t... X>
+ + + + +
using xt::fixed_shape< X >::value_type = std::size_t
+
+ +

Definition at line 1668 of file xstorage.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
auto xt::fixed_shape< X >::begin () const
+ 		+inlineconstexpr
+
+ +

Definition at line 1689 of file xstorage.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
auto xt::fixed_shape< X >::cbegin () const
+ 		+inlineconstexpr
+
+ +

Definition at line 1709 of file xstorage.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
auto xt::fixed_shape< X >::cend () const
+ 		+inlineconstexpr
+
+ +

Definition at line 1714 of file xstorage.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
bool xt::fixed_shape< X >::empty () const
+ 		+inlineconstexpr
+
+ +

Definition at line 1724 of file xstorage.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
auto xt::fixed_shape< X >::end () const
+ 		+inlineconstexpr
+
+ +

Definition at line 1694 of file xstorage.hpp.

+ +
+
+ +

◆ get()

+ +
+
+
+template<std::size_t... X>
+
+template<std::size_t idx>
+ + + + + +
+ + + + + + + +
static constexpr auto xt::fixed_shape< X >::get ()
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 1678 of file xstorage.hpp.

+ +
+
+ +

◆ operator cast_type()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
xt::fixed_shape< X >::operator cast_type () const
+ 		+inlineconstexpr
+
+ +

Definition at line 1684 of file xstorage.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
std::size_t xt::fixed_shape< X >::operator[] (std::size_t idx) const
+ 		+inlineconstexpr
+
+ +

Definition at line 1719 of file xstorage.hpp.

+ +
+
+ +

◆ rbegin()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
auto xt::fixed_shape< X >::rbegin () const
+ 		+inline
+
+ +

Definition at line 1699 of file xstorage.hpp.

+ +
+
+ +

◆ rend()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
auto xt::fixed_shape< X >::rend () const
+ 		+inline
+
+ +

Definition at line 1704 of file xstorage.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<std::size_t... X>
+ + + + + +
+ + + + + + + +
static constexpr std::size_t xt::fixed_shape< X >::size ()
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 1672 of file xstorage.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4-members.html b/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4-members.html new file mode 100644 index 000000000..d82ad0104 --- /dev/null +++ b/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4-members.html @@ -0,0 +1,141 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > > Member List
+
+
+ +

This is the complete list of members for xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + +
cmap(const UnderlyingContainer &container, const view_type &view, const Indices... indices) constxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
cmap(const UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> const_reference (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
cmap_at(const UnderlyingContainer &container, const view_type &view, const Indices... indices) constxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
cmap_at(const UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> const_reference (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
const_reference typedefxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
dimension(const UnderlyingContainer &container) constxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
get_indices_full(const Indices... indices) const -> std::array< size_t, n_indices_full_v< Indices... > > (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map(UnderlyingContainer &container, const view_type &view, const Indices... indices) constxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map(UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> reference (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map_all_indices(std::bool_constant< IS_CONST >, std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container, std::integral_constant< access_t, ACCESS >, const view_type &view, std::index_sequence< Is... >, const std::array< size_t, n_indices > &indices) const -> conditional_reference< IS_CONST > (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map_at(UnderlyingContainer &container, const view_type &view, const Indices... indices) constxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map_at(UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> reference (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map_ith_index(const view_type &view, const Index i) const -> size_t (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map_main(std::bool_constant< IS_CONST > is_const, std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container, std::integral_constant< access_t, ACCESS > access, const view_type &view, const FirstIndice firstIndice, const OtherIndices... otherIndices) const -> conditional_reference< IS_CONST > (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
map_main(std::bool_constant< IS_CONST > is_const, std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container, std::integral_constant< access_t, ACCESS > access, const view_type &view) const -> conditional_reference< IS_CONST > (defined in xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >)xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
n_indices_full_vxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >static
n_slicesxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >static
nb_integral_slicesxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >static
nb_new_axis_slicesxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >static
reference typedefxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
view_type typedefxt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
+
+ + + + diff --git a/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html b/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html new file mode 100644 index 000000000..f11174925 --- /dev/null +++ b/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html @@ -0,0 +1,890 @@ + + + + + + + +xtensor: xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > > Class Template Reference
+
+
+ + + + + + + + + + + +

+Public Types

using view_type = xt::xview<UnderlyingContainer, Slices...>
 The view type this mapper works with.
 
using reference = typename xt::xview<UnderlyingContainer, Slices...>::reference
 Reference type of the underlying view.
 
using const_reference = typename xt::xview<UnderlyingContainer, Slices...>::const_reference
 Const reference type of the underlying view.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<std::integral... Indices>
reference map (UnderlyingContainer &container, const view_type &view, const Indices... indices) const
 Map view indices to container reference using UNSAFE access.
 
template<std::integral... Indices>
const_reference cmap (const UnderlyingContainer &container, const view_type &view, const Indices... indices) const
 Map view indices to container const_reference using UNSAFE access.
 
template<std::integral... Indices>
reference map_at (UnderlyingContainer &container, const view_type &view, const Indices... indices) const
 Map view indices to container reference using SAFE access.
 
template<std::integral... Indices>
const_reference cmap_at (const UnderlyingContainer &container, const view_type &view, const Indices... indices) const
 Map view indices to container const_reference using SAFE access.
 
size_t dimension (const UnderlyingContainer &container) const
 Return the dimensionality of the view.
 
template<std::integral... Indices>
auto get_indices_full (const Indices... indices) const -> std::array< size_t, n_indices_full_v< Indices... > >
 
template<std::integral... Indices>
auto map (UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> reference
 
template<std::integral... Indices>
auto cmap (const UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> const_reference
 
template<std::integral... Indices>
auto map_at (UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> reference
 
template<std::integral... Indices>
auto cmap_at (const UnderlyingContainer &container, const view_type &view, const Indices... indices) const -> const_reference
 
template<bool IS_CONST, access_t ACCESS, std::integral FirstIndice, std::integral... OtherIndices>
auto map_main (std::bool_constant< IS_CONST > is_const, std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container, std::integral_constant< access_t, ACCESS > access, const view_type &view, const FirstIndice firstIndice, const OtherIndices... otherIndices) const -> conditional_reference< IS_CONST >
 
template<bool IS_CONST, access_t ACCESS>
auto map_main (std::bool_constant< IS_CONST > is_const, std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container, std::integral_constant< access_t, ACCESS > access, const view_type &view) const -> conditional_reference< IS_CONST >
 
template<bool IS_CONST, access_t ACCESS, size_t n_indices, size_t... Is>
auto map_all_indices (std::bool_constant< IS_CONST >, std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container, std::integral_constant< access_t, ACCESS >, const view_type &view, std::index_sequence< Is... >, const std::array< size_t, n_indices > &indices) const -> conditional_reference< IS_CONST >
 
template<size_t I, std::integral Index>
auto map_ith_index (const view_type &view, const Index i) const -> size_t
 
+ + + + + + + + + + + + + + +

+Static Public Attributes

static constexpr size_t n_slices = sizeof...(Slices)
 Total number of explicitly passed slices in the view.
 
static constexpr size_t nb_integral_slices = (std::is_integral_v<Slices> + ...)
 Number of slices that are integral constants (fixed indices)
 
static constexpr size_t nb_new_axis_slices = (xt::detail::is_newaxis_v<Slices> + ...)
 Number of slices that are xt::newaxis (insert a dimension)
 
template<std::integral... Indices>
static constexpr size_t n_indices_full_v = size_t(sizeof...(Indices) + nb_integral_slices)
 Compute how many indices are needed to address the underlying container when given N indices in the view.
 
+

Detailed Description

+
template<class UnderlyingContainer, class... Slices>
+class xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >
+

Definition at line 58 of file index_mapper.hpp.

+

Member Typedef Documentation

+ +

◆ const_reference

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+ + + + +
using xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::const_reference = typename xt::xview<UnderlyingContainer, Slices...>::const_reference
+
+ +

Const reference type of the underlying view.

+ +

Definition at line 69 of file index_mapper.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+ + + + +
using xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::reference = typename xt::xview<UnderlyingContainer, Slices...>::reference
+
+ +

Reference type of the underlying view.

+ +

Definition at line 66 of file index_mapper.hpp.

+ +
+
+ +

◆ view_type

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+ + + + +
using xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::view_type = xt::xview<UnderlyingContainer, Slices...>
+
+ +

The view type this mapper works with.

+ +

Definition at line 63 of file index_mapper.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ cmap() [1/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
const_reference xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::cmap (const UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const
+
+ +

Map view indices to container const_reference using UNSAFE access.

+
Parameters
+ + + + +
containerThe source container.
viewThe view defining the mapping.
indicesThe indices in view-space.
+
+
+
Returns
Reference to the element in the container.
+ +
+
+ +

◆ cmap() [2/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::cmap (const UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const -> const_reference +
+
+ +

Definition at line 343 of file index_mapper.hpp.

+ +
+
+ +

◆ cmap_at() [1/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
const_reference xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::cmap_at (const UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const
+
+ +

Map view indices to container const_reference using SAFE access.

+
Parameters
+ + + + +
containerThe source container.
viewThe view defining the mapping.
indicesThe indices in view-space.
+
+
+
Returns
Reference to the element in the container.
+ +
+
+ +

◆ cmap_at() [2/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::cmap_at (const UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const -> const_reference +
+
+ +

Definition at line 377 of file index_mapper.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+ + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::dimension (const UnderlyingContainer & container) const
+
+ +

Return the dimensionality of the view.

+ +

Definition at line 532 of file index_mapper.hpp.

+ +
+
+ +

◆ get_indices_full()

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::get_indices_full (const Indices... indices) const -> std::array<size_t, n_indices_full_v<Indices...>> +
+
+ +

Definition at line 304 of file index_mapper.hpp.

+ +
+
+ +

◆ map() [1/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
reference xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map (UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const
+
+ +

Map view indices to container reference using UNSAFE access.

+
Parameters
+ + + + +
containerThe source container.
viewThe view defining the mapping.
indicesThe indices in view-space.
+
+
+
Returns
Reference to the element in the container.
+ +
+
+ +

◆ map() [2/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map (UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const -> reference +
+
+ +

Definition at line 326 of file index_mapper.hpp.

+ +
+
+ +

◆ map_all_indices()

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<bool IS_CONST, access_t ACCESS, size_t n_indices, size_t... Is>
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map_all_indices (std::bool_constant< IS_CONST > ,
std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container,
std::integral_constant< access_t, ACCESS > ,
const view_type & view,
std::index_sequence< Is... > ,
const std::array< size_t, n_indices > & indices ) const -> conditional_reference<IS_CONST> +
+
+ +

Definition at line 479 of file index_mapper.hpp.

+ +
+
+ +

◆ map_at() [1/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
reference xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map_at (UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const
+
+ +

Map view indices to container reference using SAFE access.

+
Parameters
+ + + + +
containerThe source container.
viewThe view defining the mapping.
indicesThe indices in view-space.
+
+
+
Returns
Reference to the element in the container.
+ +
+
+ +

◆ map_at() [2/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + + + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map_at (UnderlyingContainer & container,
const view_type & view,
const Indices... indices ) const -> reference +
+
+ +

Definition at line 360 of file index_mapper.hpp.

+ +
+
+ +

◆ map_ith_index()

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<size_t I, std::integral Index>
+ + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map_ith_index (const view_type & view,
const Index i ) const -> size_t +
+
+ +

Definition at line 501 of file index_mapper.hpp.

+ +
+
+ +

◆ map_main() [1/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<bool IS_CONST, access_t ACCESS>
+ + + + + + + + + + + + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map_main (std::bool_constant< IS_CONST > is_const,
std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container,
std::integral_constant< access_t, ACCESS > access,
const view_type & view ) const -> conditional_reference<IS_CONST> +
+
+ +

Definition at line 458 of file index_mapper.hpp.

+ +
+
+ +

◆ map_main() [2/2]

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<bool IS_CONST, access_t ACCESS, std::integral FirstIndice, std::integral... OtherIndices>
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
auto xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::map_main (std::bool_constant< IS_CONST > is_const,
std::conditional_t< IS_CONST, const UnderlyingContainer &, UnderlyingContainer & > container,
std::integral_constant< access_t, ACCESS > access,
const view_type & view,
const FirstIndice firstIndice,
const OtherIndices... otherIndices ) const -> conditional_reference<IS_CONST> +
+
+ +

Definition at line 394 of file index_mapper.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ n_indices_full_v

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+
+template<std::integral... Indices>
+ + + + + +
+ + + + +
size_t xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::n_indices_full_v = size_t(sizeof...(Indices) + nb_integral_slices)
+ 		+staticconstexpr
+
+ +

Compute how many indices are needed to address the underlying container when given N indices in the view.

+ +

Definition at line 85 of file index_mapper.hpp.

+ +
+
+ +

◆ n_slices

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+ + + + + +
+ + + + +
size_t xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::n_slices = sizeof...(Slices)
+ 		+staticconstexpr
+
+ +

Total number of explicitly passed slices in the view.

+ +

Definition at line 72 of file index_mapper.hpp.

+ +
+
+ +

◆ nb_integral_slices

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+ + + + + +
+ + + + +
size_t xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::nb_integral_slices = (std::is_integral_v<Slices> + ...)
+ 		+staticconstexpr
+
+ +

Number of slices that are integral constants (fixed indices)

+ +

Definition at line 75 of file index_mapper.hpp.

+ +
+
+ +

◆ nb_new_axis_slices

+ +
+
+
+template<class UnderlyingContainer, class... Slices>
+ + + + + +
+ + + + +
size_t xt::index_mapper< xt::xview< UnderlyingContainer, Slices... > >::nb_new_axis_slices = (xt::detail::is_newaxis_v<Slices> + ...)
+ 		+staticconstexpr
+
+ +

Number of slices that are xt::newaxis (insert a dimension)

+ +

Definition at line 78 of file index_mapper.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.js b/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.js new file mode 100644 index 000000000..22ebdc0b3 --- /dev/null +++ b/classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.js @@ -0,0 +1,11 @@ +var classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4 = +[ + [ "const_reference", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#a340678e79e66a00c366597f2adf2b978", null ], + [ "reference", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#a6ee11ca3c87c65a8f33511019a8fddaf", null ], + [ "view_type", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#a121d95388e4bc47eb6bfad7312601dbf", null ], + [ "cmap", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#a8a05211f1dec8baa4732be2407dfceed", null ], + [ "cmap_at", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#a48ce7c87ea115701f789fa086de0190d", null ], + [ "dimension", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#a8565c9e35a1e5c2c6462bcc248368b11", null ], + [ "map", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#aed240e2021f2f3e9f8cba86234d24f2e", null ], + [ "map_at", "classxt_1_1index__mapper_3_01xt_1_1xview_3_01_underlying_container_00_01_slices_8_8_8_01_4_01_4.html#ac6608a673491a49d7ff37d23aaa8ebeb", null ] +]; \ No newline at end of file diff --git a/classxt_1_1linear__assigner-members.html b/classxt_1_1linear__assigner-members.html new file mode 100644 index 000000000..6c95b4c17 --- /dev/null +++ b/classxt_1_1linear__assigner-members.html @@ -0,0 +1,121 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::linear_assigner< simd_assign > Member List
+
+
+ +

This is the complete list of members for xt::linear_assigner< simd_assign >, including all inherited members.

+ + +
run(E1 &e1, const E2 &e2) (defined in xt::linear_assigner< simd_assign >)xt::linear_assigner< simd_assign >inlinestatic
+
+ + + + diff --git a/classxt_1_1linear__assigner.html b/classxt_1_1linear__assigner.html new file mode 100644 index 000000000..897f8dc78 --- /dev/null +++ b/classxt_1_1linear__assigner.html @@ -0,0 +1,171 @@ + + + + + + + +xtensor: xt::linear_assigner< simd_assign > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Static Public Member Functions | +List of all members
+
xt::linear_assigner< simd_assign > Class Template Reference
+
+
+ + + + + +

+Static Public Member Functions

template<class E1, class E2>
static void run (E1 &e1, const E2 &e2)
 
+

Detailed Description

+
template<bool simd_assign>
+class xt::linear_assigner< simd_assign >
+

Definition at line 146 of file xassign.hpp.

+

Member Function Documentation

+ +

◆ run()

+ +
+
+
+template<bool simd_assign>
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + +
void xt::linear_assigner< simd_assign >::run (E1 & e1,
const E2 & e2 )
+ 		+inlinestatic
+
+ +

Definition at line 703 of file xassign.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1linear__assigner_3_01false_01_4-members.html b/classxt_1_1linear__assigner_3_01false_01_4-members.html new file mode 100644 index 000000000..d80e60472 --- /dev/null +++ b/classxt_1_1linear__assigner_3_01false_01_4-members.html @@ -0,0 +1,122 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::linear_assigner< false > Member List
+
+
+ +

This is the complete list of members for xt::linear_assigner< false >, including all inherited members.

+ + + +
run(E1 &e1, const E2 &e2) (defined in xt::linear_assigner< false >)xt::linear_assigner< false >inlinestatic
run(E1 &e1, const E2 &e2) (defined in xt::linear_assigner< false >)xt::linear_assigner< false >inlinestatic
+
+ + + + diff --git a/classxt_1_1linear__assigner_3_01false_01_4.html b/classxt_1_1linear__assigner_3_01false_01_4.html new file mode 100644 index 000000000..73baedb24 --- /dev/null +++ b/classxt_1_1linear__assigner_3_01false_01_4.html @@ -0,0 +1,201 @@ + + + + + + + +xtensor: xt::linear_assigner< false > Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Static Public Member Functions | +List of all members
+
xt::linear_assigner< false > Class Reference
+
+
+ + + + + + + +

+Static Public Member Functions

template<class E1, class E2>
static void run (E1 &e1, const E2 &e2)
 
static void run (E1 &e1, const E2 &e2)
 
+

Detailed Description

+
+

Definition at line 155 of file xassign.hpp.

+

Member Function Documentation

+ +

◆ run() [1/2]

+ +
+
+ + + + + +
+ + + + + + + + + + + +
void xt::linear_assigner< simd_assign >::run (E1 & e1,
const E2 & e2 )
+ 		+inlinestatic
+
+ +

Definition at line 151 of file xassign.hpp.

+ +
+
+ +

◆ run() [2/2]

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + +
void xt::linear_assigner< false >::run (E1 & e1,
const E2 & e2 )
+ 		+inlinestatic
+
+ +

Definition at line 788 of file xassign.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1noalias__proxy-members.html b/classxt_1_1noalias__proxy-members.html new file mode 100644 index 000000000..7c3020c9e --- /dev/null +++ b/classxt_1_1noalias__proxy-members.html @@ -0,0 +1,148 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::noalias_proxy< A > Member List
+
+
+ +

This is the complete list of members for xt::noalias_proxy< A >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
noalias_proxy(A a) noexcept (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator%=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator%=(const xexpression< E > &e) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator%=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator&=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator&=(const xexpression< E > &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator&=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator*=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator*=(const xexpression< E > &e) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator*=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator+=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator+=(const xexpression< E > &e) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator+=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator-=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator-=(const xexpression< E > &e) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator-=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator/=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator/=(const xexpression< E > &e) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator/=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator=(const xexpression< E > &e) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator^=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator^=(const xexpression< E > &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator^=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator|=(const E &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >
operator|=(const xexpression< E > &) (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
operator|=(const E &e) -> disable_xexpression< E, A > (defined in xt::noalias_proxy< A >)xt::noalias_proxy< A >inline
+
+ + + + diff --git a/classxt_1_1noalias__proxy.html b/classxt_1_1noalias__proxy.html new file mode 100644 index 000000000..bcb4e8778 --- /dev/null +++ b/classxt_1_1noalias__proxy.html @@ -0,0 +1,822 @@ + + + + + + + +xtensor: xt::noalias_proxy< A > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +List of all members
+
xt::noalias_proxy< A > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 noalias_proxy (A a) noexcept
 
+template<class E>
disable_xexpression< E, A > operator= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, A > operator^= (const E &)
 
template<class E>
A operator= (const xexpression< E > &e)
 
template<class E>
A operator+= (const xexpression< E > &e)
 
template<class E>
A operator-= (const xexpression< E > &e)
 
template<class E>
A operator*= (const xexpression< E > &e)
 
template<class E>
A operator/= (const xexpression< E > &e)
 
template<class E>
A operator%= (const xexpression< E > &e)
 
template<class E>
A operator&= (const xexpression< E > &)
 
template<class E>
A operator|= (const xexpression< E > &)
 
template<class E>
A operator^= (const xexpression< E > &)
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, A >
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, A >
 
+

Detailed Description

+
template<class A>
+class xt::noalias_proxy< A >
+

Definition at line 19 of file xnoalias.hpp.

+

Constructor & Destructor Documentation

+ +

◆ noalias_proxy()

+ +
+
+
+template<class A>
+ + + + + +
+ + + + + + + +
xt::noalias_proxy< A >::noalias_proxy (A a)
+ 		+inlinenoexcept
+
+ +

Definition at line 92 of file xnoalias.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator%=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator%= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 134 of file xnoalias.hpp.

+ +
+
+ +

◆ operator%=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator%= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 197 of file xnoalias.hpp.

+ +
+
+ +

◆ operator&=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator&= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 141 of file xnoalias.hpp.

+ +
+
+ +

◆ operator&=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator&= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 204 of file xnoalias.hpp.

+ +
+
+ +

◆ operator*=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator*= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 120 of file xnoalias.hpp.

+ +
+
+ +

◆ operator*=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator*= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 183 of file xnoalias.hpp.

+ +
+
+ +

◆ operator+=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator+= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 106 of file xnoalias.hpp.

+ +
+
+ +

◆ operator+=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator+= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 169 of file xnoalias.hpp.

+ +
+
+ +

◆ operator-=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator-= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 113 of file xnoalias.hpp.

+ +
+
+ +

◆ operator-=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator-= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 176 of file xnoalias.hpp.

+ +
+
+ +

◆ operator/=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator/= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 127 of file xnoalias.hpp.

+ +
+
+ +

◆ operator/=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator/= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 190 of file xnoalias.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 99 of file xnoalias.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 162 of file xnoalias.hpp.

+ +
+
+ +

◆ operator^=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator^= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 155 of file xnoalias.hpp.

+ +
+
+ +

◆ operator^=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator^= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 218 of file xnoalias.hpp.

+ +
+
+ +

◆ operator|=() [1/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::noalias_proxy< A >::operator|= (const E & e) -> disable_xexpression<E, A> +
+ 		+inline
+
+ +

Definition at line 148 of file xnoalias.hpp.

+ +
+
+ +

◆ operator|=() [2/2]

+ +
+
+
+template<class A>
+
+template<class E>
+ + + + + +
+ + + + + + + +
A xt::noalias_proxy< A >::operator|= (const xexpression< E > & e)
+ 		+inline
+
+ +

Definition at line 211 of file xnoalias.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xnoalias.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1print__options_1_1edge__items-members.html b/classxt_1_1print__options_1_1edge__items-members.html new file mode 100644 index 000000000..431409173 --- /dev/null +++ b/classxt_1_1print__options_1_1edge__items-members.html @@ -0,0 +1,123 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::print_options::edge_items Member List
+
+
+ +

This is the complete list of members for xt::print_options::edge_items, including all inherited members.

+ + + + +
edge_items(int value) (defined in xt::print_options::edge_items)xt::print_options::edge_itemsinline
id() (defined in xt::print_options::edge_items)xt::print_options::edge_itemsinlinestatic
value() const (defined in xt::print_options::edge_items)xt::print_options::edge_itemsinline
+
+ + + + diff --git a/classxt_1_1print__options_1_1edge__items.html b/classxt_1_1print__options_1_1edge__items.html new file mode 100644 index 000000000..312a4825c --- /dev/null +++ b/classxt_1_1print__options_1_1edge__items.html @@ -0,0 +1,234 @@ + + + + + + + +xtensor: xt::print_options::edge_items Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +Static Public Member Functions | +List of all members
+
xt::print_options::edge_items Class Reference
+
+
+ +

io manipulator used to set the number of egde items if the summarization is triggered. + More...

+ +

#include <xio.hpp>

+ + + + + + +

+Public Member Functions

 edge_items (int value)
 
int value () const
 
+ + + +

+Static Public Member Functions

static int id ()
 
+

Detailed Description

+

io manipulator used to set the number of egde items if the summarization is triggered.

+
using po = xt::print_options;
+
xt::xarray<double> a = xt::rand::randn<double>({2000, 500});
+
std::cout << po::edge_items(5) << a << std::endl;
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+

Definition at line 165 of file xio.hpp.

+

Constructor & Destructor Documentation

+ +

◆ edge_items()

+ +
+
+ + + + + +
+ + + + + + + +
xt::print_options::edge_items::edge_items (int value)
+ 		+inline
+
+ +

Definition at line 165 of file xio.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ id()

+ +
+
+ + + + + +
+ + + + + + + +
static int xt::print_options::edge_items::id ()
+ 		+inlinestatic
+
+ +

Definition at line 165 of file xio.hpp.

+ +
+
+ +

◆ value()

+ +
+
+ + + + + +
+ + + + + + + +
int xt::print_options::edge_items::value () const
+ 		+inline
+
+ +

Definition at line 165 of file xio.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xio.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1print__options_1_1line__width-members.html b/classxt_1_1print__options_1_1line__width-members.html new file mode 100644 index 000000000..0528a7065 --- /dev/null +++ b/classxt_1_1print__options_1_1line__width-members.html @@ -0,0 +1,123 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::print_options::line_width Member List
+
+
+ +

This is the complete list of members for xt::print_options::line_width, including all inherited members.

+ + + + +
id() (defined in xt::print_options::line_width)xt::print_options::line_widthinlinestatic
line_width(int value) (defined in xt::print_options::line_width)xt::print_options::line_widthinline
value() const (defined in xt::print_options::line_width)xt::print_options::line_widthinline
+
+ + + + diff --git a/classxt_1_1print__options_1_1line__width.html b/classxt_1_1print__options_1_1line__width.html new file mode 100644 index 000000000..a40f39cdc --- /dev/null +++ b/classxt_1_1print__options_1_1line__width.html @@ -0,0 +1,234 @@ + + + + + + + +xtensor: xt::print_options::line_width Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +Static Public Member Functions | +List of all members
+
xt::print_options::line_width Class Reference
+
+
+ +

io manipulator used to set the width of the lines when printing an expression. + More...

+ +

#include <xio.hpp>

+ + + + + + +

+Public Member Functions

 line_width (int value)
 
int value () const
 
+ + + +

+Static Public Member Functions

static int id ()
 
+

Detailed Description

+

io manipulator used to set the width of the lines when printing an expression.

+
using po = xt::print_options;
+
xt::xarray<double> a = {{1, 2, 3}, {4, 5, 6}};
+
std::cout << po::line_width(100) << a << std::endl;
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+

Definition at line 137 of file xio.hpp.

+

Constructor & Destructor Documentation

+ +

◆ line_width()

+ +
+
+ + + + + +
+ + + + + + + +
xt::print_options::line_width::line_width (int value)
+ 		+inline
+
+ +

Definition at line 137 of file xio.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ id()

+ +
+
+ + + + + +
+ + + + + + + +
static int xt::print_options::line_width::id ()
+ 		+inlinestatic
+
+ +

Definition at line 137 of file xio.hpp.

+ +
+
+ +

◆ value()

+ +
+
+ + + + + +
+ + + + + + + +
int xt::print_options::line_width::value () const
+ 		+inline
+
+ +

Definition at line 137 of file xio.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xio.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1print__options_1_1precision-members.html b/classxt_1_1print__options_1_1precision-members.html new file mode 100644 index 000000000..e5cdea648 --- /dev/null +++ b/classxt_1_1print__options_1_1precision-members.html @@ -0,0 +1,123 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::print_options::precision Member List
+
+
+ +

This is the complete list of members for xt::print_options::precision, including all inherited members.

+ + + + +
id() (defined in xt::print_options::precision)xt::print_options::precisioninlinestatic
precision(int value) (defined in xt::print_options::precision)xt::print_options::precisioninline
value() const (defined in xt::print_options::precision)xt::print_options::precisioninline
+
+ + + + diff --git a/classxt_1_1print__options_1_1precision.html b/classxt_1_1print__options_1_1precision.html new file mode 100644 index 000000000..1dfbd744e --- /dev/null +++ b/classxt_1_1print__options_1_1precision.html @@ -0,0 +1,234 @@ + + + + + + + +xtensor: xt::print_options::precision Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +Static Public Member Functions | +List of all members
+
xt::print_options::precision Class Reference
+
+
+ +

io manipulator used to set the precision of the floating point values when printing an expression. + More...

+ +

#include <xio.hpp>

+ + + + + + +

+Public Member Functions

 precision (int value)
 
int value () const
 
+ + + +

+Static Public Member Functions

static int id ()
 
+

Detailed Description

+

io manipulator used to set the precision of the floating point values when printing an expression.

+
using po = xt::print_options;
+
xt::xarray<double> a = xt::rand::randn<double>({2000, 500});
+
std::cout << po::precision(5) << a << std::endl;
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+

Definition at line 179 of file xio.hpp.

+

Constructor & Destructor Documentation

+ +

◆ precision()

+ +
+
+ + + + + +
+ + + + + + + +
xt::print_options::precision::precision (int value)
+ 		+inline
+
+ +

Definition at line 179 of file xio.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ id()

+ +
+
+ + + + + +
+ + + + + + + +
static int xt::print_options::precision::id ()
+ 		+inlinestatic
+
+ +

Definition at line 179 of file xio.hpp.

+ +
+
+ +

◆ value()

+ +
+
+ + + + + +
+ + + + + + + +
int xt::print_options::precision::value () const
+ 		+inline
+
+ +

Definition at line 179 of file xio.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xio.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1print__options_1_1threshold-members.html b/classxt_1_1print__options_1_1threshold-members.html new file mode 100644 index 000000000..7f9214f32 --- /dev/null +++ b/classxt_1_1print__options_1_1threshold-members.html @@ -0,0 +1,123 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::print_options::threshold Member List
+
+
+ +

This is the complete list of members for xt::print_options::threshold, including all inherited members.

+ + + + +
id() (defined in xt::print_options::threshold)xt::print_options::thresholdinlinestatic
threshold(int value) (defined in xt::print_options::threshold)xt::print_options::thresholdinline
value() const (defined in xt::print_options::threshold)xt::print_options::thresholdinline
+
+ + + + diff --git a/classxt_1_1print__options_1_1threshold.html b/classxt_1_1print__options_1_1threshold.html new file mode 100644 index 000000000..2eac56720 --- /dev/null +++ b/classxt_1_1print__options_1_1threshold.html @@ -0,0 +1,234 @@ + + + + + + + +xtensor: xt::print_options::threshold Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +Static Public Member Functions | +List of all members
+
xt::print_options::threshold Class Reference
+
+
+ +

io manipulator used to set the threshold after which summarization is triggered. + More...

+ +

#include <xio.hpp>

+ + + + + + +

+Public Member Functions

 threshold (int value)
 
int value () const
 
+ + + +

+Static Public Member Functions

static int id ()
 
+

Detailed Description

+

io manipulator used to set the threshold after which summarization is triggered.

+
using po = xt::print_options;
+
xt::xarray<double> a = xt::rand::randn<double>({2000, 500});
+
std::cout << po::threshold(50) << a << std::endl;
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+

Definition at line 151 of file xio.hpp.

+

Constructor & Destructor Documentation

+ +

◆ threshold()

+ +
+
+ + + + + +
+ + + + + + + +
xt::print_options::threshold::threshold (int value)
+ 		+inline
+
+ +

Definition at line 151 of file xio.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ id()

+ +
+
+ + + + + +
+ + + + + + + +
static int xt::print_options::threshold::id ()
+ 		+inlinestatic
+
+ +

Definition at line 151 of file xio.hpp.

+ +
+
+ +

◆ value()

+ +
+
+ + + + + +
+ + + + + + + +
int xt::print_options::threshold::value () const
+ 		+inline
+
+ +

Definition at line 151 of file xio.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xio.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1sequence__view-members.html b/classxt_1_1sequence__view-members.html new file mode 100644 index 000000000..2a5264e12 --- /dev/null +++ b/classxt_1_1sequence__view-members.html @@ -0,0 +1,148 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::sequence_view< E, Start, End > Member List
+
+
+ +

This is the complete list of members for xt::sequence_view< E, Start, End >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
back() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
begin() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
cbegin() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
cend() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
const_iterator typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
const_pointer typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
const_reference typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
const_reverse_iterator typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
crbegin() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
crend() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
difference_type typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
empty() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
end() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
front() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
iterator typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
operator T() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
operator[](std::size_t idx) const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
pointer typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
rbegin() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
reference typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
rend() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
reverse_iterator typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
sequence_view(const E &container) (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >explicit
sequence_view(const sequence_view< E, OS, OE > &other) (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >explicit
size() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
size_type typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
storage() const (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
value_type typedef (defined in xt::sequence_view< E, Start, End >)xt::sequence_view< E, Start, End >
+
+ + + + diff --git a/classxt_1_1sequence__view.html b/classxt_1_1sequence__view.html new file mode 100644 index 000000000..ddf08e68d --- /dev/null +++ b/classxt_1_1sequence__view.html @@ -0,0 +1,772 @@ + + + + + + + +xtensor: xt::sequence_view< E, Start, End > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::sequence_view< E, Start, End > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using value_type = typename E::value_type
 
using reference = typename E::reference
 
using const_reference = typename E::const_reference
 
using pointer = typename E::pointer
 
using const_pointer = typename E::const_pointer
 
using size_type = typename E::size_type
 
using difference_type = typename E::difference_type
 
using iterator = typename E::iterator
 
using const_iterator = typename E::const_iterator
 
using reverse_iterator = typename E::reverse_iterator
 
using const_reverse_iterator = typename E::const_reverse_iterator
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 sequence_view (const E &container)
 
template<std::ptrdiff_t OS, std::ptrdiff_t OE>
 sequence_view (const sequence_view< E, OS, OE > &other)
 
template<class T, class R = decltype(std::declval<T>().begin())>
 operator T () const
 
bool empty () const
 
size_type size () const
 
const_reference operator[] (std::size_t idx) const
 
const_iterator end () const
 
const_iterator begin () const
 
const_iterator cend () const
 
const_iterator cbegin () const
 
const_reverse_iterator rend () const
 
const_reverse_iterator rbegin () const
 
const_reverse_iterator crend () const
 
const_reverse_iterator crbegin () const
 
const_reference front () const
 
const_reference back () const
 
const E & storage () const
 
+

Detailed Description

+
template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+class xt::sequence_view< E, Start, End >
+

Definition at line 1737 of file xstorage.hpp.

+

Member Typedef Documentation

+ +

◆ const_iterator

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::const_iterator = typename E::const_iterator
+
+ +

Definition at line 1751 of file xstorage.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::const_pointer = typename E::const_pointer
+
+ +

Definition at line 1745 of file xstorage.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::const_reference = typename E::const_reference
+
+ +

Definition at line 1743 of file xstorage.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::const_reverse_iterator = typename E::const_reverse_iterator
+
+ +

Definition at line 1753 of file xstorage.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::difference_type = typename E::difference_type
+
+ +

Definition at line 1748 of file xstorage.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::iterator = typename E::iterator
+
+ +

Definition at line 1750 of file xstorage.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::pointer = typename E::pointer
+
+ +

Definition at line 1744 of file xstorage.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::reference = typename E::reference
+
+ +

Definition at line 1742 of file xstorage.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::reverse_iterator = typename E::reverse_iterator
+
+ +

Definition at line 1752 of file xstorage.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::size_type = typename E::size_type
+
+ +

Definition at line 1747 of file xstorage.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
+ + + + +
using xt::sequence_view< E, Start, End >::value_type = typename E::value_type
+
+ +

Definition at line 1741 of file xstorage.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ sequence_view() [1/2]

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + +
+ + + + + + + +
xt::sequence_view< E, Start, End >::sequence_view (const E & container)
+ 		+explicit
+
+ +

Definition at line 1788 of file xstorage.hpp.

+ +
+
+ +

◆ sequence_view() [2/2]

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+
+template<std::ptrdiff_t OS, std::ptrdiff_t OE>
+ + + + + +
+ + + + + + + +
xt::sequence_view< E, Start, End >::sequence_view (const sequence_view< E, OS, OE > & other)
+ 		+explicit
+
+ +

Definition at line 1795 of file xstorage.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ back()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::back () const
+
+ +

Definition at line 1896 of file xstorage.hpp.

+ +
+
+ +

◆ begin()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::begin () const
+
+ +

Definition at line 1848 of file xstorage.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::cbegin () const
+
+ +

Definition at line 1860 of file xstorage.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::cend () const
+
+ +

Definition at line 1854 of file xstorage.hpp.

+ +
+
+ +

◆ crbegin()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::crbegin () const
+
+ +

Definition at line 1884 of file xstorage.hpp.

+ +
+
+ +

◆ crend()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::crend () const
+
+ +

Definition at line 1878 of file xstorage.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
bool xt::sequence_view< E, Start, End >::empty () const
+
+ +

Definition at line 1810 of file xstorage.hpp.

+ +
+
+ +

◆ end()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::end () const
+
+ +

Definition at line 1835 of file xstorage.hpp.

+ +
+
+ +

◆ front()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::front () const
+
+ +

Definition at line 1890 of file xstorage.hpp.

+ +
+
+ +

◆ operator T()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+
+template<class T, class R>
+ + + + + + + +
xt::sequence_view< E, Start, End >::operator T () const
+
+ +

Definition at line 1802 of file xstorage.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::operator[] (std::size_t idx) const
+
+ +

Definition at line 1829 of file xstorage.hpp.

+ +
+
+ +

◆ rbegin()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::rbegin () const
+
+ +

Definition at line 1872 of file xstorage.hpp.

+ +
+
+ +

◆ rend()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::rend () const
+
+ +

Definition at line 1866 of file xstorage.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
auto xt::sequence_view< E, Start, End >::size () const
+
+ +

Definition at line 1816 of file xstorage.hpp.

+ +
+
+ +

◆ storage()

+ +
+
+
+template<class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+ + + + + + + +
const E & xt::sequence_view< E, Start, End >::storage () const
+
+ +

Definition at line 1909 of file xstorage.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1stepper__assigner-members.html b/classxt_1_1stepper__assigner-members.html new file mode 100644 index 000000000..35566b92d --- /dev/null +++ b/classxt_1_1stepper__assigner-members.html @@ -0,0 +1,132 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::stepper_assigner< E1, E2, L > Member List
+
+
+ +

This is the complete list of members for xt::stepper_assigner< E1, E2, L >, including all inherited members.

+ + + + + + + + + + + + + +
difference_type typedef (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >
index_type typedef (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >
lhs_iterator typedef (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >
reset(size_type i) (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >inline
rhs_iterator typedef (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >
run() (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >inline
shape_type typedef (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >
size_type typedef (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >
step(size_type i) (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >inline
step(size_type i, size_type n) (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >inline
stepper_assigner(E1 &e1, const E2 &e2) (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >inline
to_end(layout_type) (defined in xt::stepper_assigner< E1, E2, L >)xt::stepper_assigner< E1, E2, L >inline
+
+ + + + diff --git a/classxt_1_1stepper__assigner.html b/classxt_1_1stepper__assigner.html new file mode 100644 index 000000000..dd1693c99 --- /dev/null +++ b/classxt_1_1stepper__assigner.html @@ -0,0 +1,453 @@ + + + + + + + +xtensor: xt::stepper_assigner< E1, E2, L > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::stepper_assigner< E1, E2, L > Class Template Reference
+
+
+ + + + + + + + + + + + + + +

+Public Types

using lhs_iterator = typename E1::stepper
 
using rhs_iterator = typename E2::const_stepper
 
using shape_type = typename E1::shape_type
 
using index_type = xindex_type_t<shape_type>
 
using size_type = typename lhs_iterator::size_type
 
using difference_type = typename lhs_iterator::difference_type
 
+ + + + + + + + + + + + + +

+Public Member Functions

 stepper_assigner (E1 &e1, const E2 &e2)
 
void run ()
 
void step (size_type i)
 
void step (size_type i, size_type n)
 
void reset (size_type i)
 
void to_end (layout_type)
 
+

Detailed Description

+
template<class E1, class E2, layout_type L>
+class xt::stepper_assigner< E1, E2, L >
+

Definition at line 110 of file xassign.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + +
using xt::stepper_assigner< E1, E2, L >::difference_type = typename lhs_iterator::difference_type
+
+ +

Definition at line 119 of file xassign.hpp.

+ +
+
+ +

◆ index_type

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + +
using xt::stepper_assigner< E1, E2, L >::index_type = xindex_type_t<shape_type>
+
+ +

Definition at line 117 of file xassign.hpp.

+ +
+
+ +

◆ lhs_iterator

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + +
using xt::stepper_assigner< E1, E2, L >::lhs_iterator = typename E1::stepper
+
+ +

Definition at line 114 of file xassign.hpp.

+ +
+
+ +

◆ rhs_iterator

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + +
using xt::stepper_assigner< E1, E2, L >::rhs_iterator = typename E2::const_stepper
+
+ +

Definition at line 115 of file xassign.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + +
using xt::stepper_assigner< E1, E2, L >::shape_type = typename E1::shape_type
+
+ +

Definition at line 116 of file xassign.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + +
using xt::stepper_assigner< E1, E2, L >::size_type = typename lhs_iterator::size_type
+
+ +

Definition at line 118 of file xassign.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ stepper_assigner()

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + + +
+ + + + + + + + + + + +
xt::stepper_assigner< E1, E2, L >::stepper_assigner (E1 & e1,
const E2 & e2 )
+ 		+inline
+
+ +

Definition at line 645 of file xassign.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ reset()

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + + +
+ + + + + + + +
void xt::stepper_assigner< E1, E2, L >::reset (size_type i)
+ 		+inline
+
+ +

Definition at line 684 of file xassign.hpp.

+ +
+
+ +

◆ run()

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + + +
+ + + + + + + +
void xt::stepper_assigner< E1, E2, L >::run ()
+ 		+inline
+
+ +

Definition at line 654 of file xassign.hpp.

+ +
+
+ +

◆ step() [1/2]

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + + +
+ + + + + + + +
void xt::stepper_assigner< E1, E2, L >::step (size_type i)
+ 		+inline
+
+ +

Definition at line 670 of file xassign.hpp.

+ +
+
+ +

◆ step() [2/2]

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + + +
+ + + + + + + + + + + +
void xt::stepper_assigner< E1, E2, L >::step (size_type i,
size_type n )
+ 		+inline
+
+ +

Definition at line 677 of file xassign.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class E1, class E2, layout_type L>
+ + + + + +
+ + + + + + + +
void xt::stepper_assigner< E1, E2, L >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 691 of file xassign.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1strided__loop__assigner-members.html b/classxt_1_1strided__loop__assigner-members.html new file mode 100644 index 000000000..8ddd7282b --- /dev/null +++ b/classxt_1_1strided__loop__assigner-members.html @@ -0,0 +1,128 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::strided_loop_assigner< simd > Member List
+
+
+ +

This is the complete list of members for xt::strided_loop_assigner< simd >, including all inherited members.

+ + + + + + + + + +
get_loop_sizes(E1 &e1, const E2 &e2) (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >static
get_loop_sizes(E1 &e1, const E2 &e2) (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >inline
loop_sizes_t typedef (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >
run(E1 &e1, const E2 &e2, const loop_sizes_t &loop_sizes) (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >inlinestatic
run(E1 &e1, const E2 &e2) (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >static
run(E1 &e1, const E2 &e2) (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >inline
run(E1 &, const E2 &, const loop_sizes_t &) (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >inline
run(E1 &e1, const E2 &e2) (defined in xt::strided_loop_assigner< simd >)xt::strided_loop_assigner< simd >inline
+
+ + + + diff --git a/classxt_1_1strided__loop__assigner.html b/classxt_1_1strided__loop__assigner.html new file mode 100644 index 000000000..e44182528 --- /dev/null +++ b/classxt_1_1strided__loop__assigner.html @@ -0,0 +1,355 @@ + + + + + + + +xtensor: xt::strided_loop_assigner< simd > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +List of all members
+
xt::strided_loop_assigner< simd > Class Template Reference
+
+
+ + + + +

+Public Types

using loop_sizes_t = strided_assign_detail::loop_sizes_t
 
+ + + + + + + + + + +

+Public Member Functions

template<class E1, class E2>
strided_assign_detail::loop_sizes_t get_loop_sizes (E1 &e1, const E2 &e2)
 
void run (E1 &e1, const E2 &e2)
 
void run (E1 &, const E2 &, const loop_sizes_t &)
 
void run (E1 &e1, const E2 &e2)
 
+ + + + + + + + + + +

+Static Public Member Functions

template<class E1, class E2>
static void run (E1 &e1, const E2 &e2, const loop_sizes_t &loop_sizes)
 
+template<class E1, class E2>
static loop_sizes_t get_loop_sizes (E1 &e1, const E2 &e2)
 
+template<class E1, class E2>
static void run (E1 &e1, const E2 &e2)
 
+

Detailed Description

+
template<bool simd>
+class xt::strided_loop_assigner< simd >
+

Definition at line 189 of file xassign.hpp.

+

Member Typedef Documentation

+ +

◆ loop_sizes_t

+ +
+
+
+template<bool simd>
+ + + + +
using xt::strided_loop_assigner< simd >::loop_sizes_t = strided_assign_detail::loop_sizes_t
+
+ +

Definition at line 193 of file xassign.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ get_loop_sizes()

+ +
+
+
+template<bool simd>
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + +
strided_assign_detail::loop_sizes_t xt::strided_loop_assigner< simd >::get_loop_sizes (E1 & e1,
const E2 & e2 )
+ 		+inline
+
+ +

Definition at line 1093 of file xassign.hpp.

+ +
+
+ +

◆ run() [1/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + + + + + + +
void xt::strided_loop_assigner< false >::run (E1 & ,
const E2 & ,
const loop_sizes_t &  )
+ 		+inline
+
+ +

Definition at line 1348 of file xassign.hpp.

+ +
+
+ +

◆ run() [2/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + +
void xt::strided_loop_assigner< true >::run (E1 & e1,
const E2 & e2 )
+ 		+inline
+
+ +

Definition at line 1332 of file xassign.hpp.

+ +
+
+ +

◆ run() [3/4]

+ +
+
+ + + + + +
+ + + + + + + + + + + +
void xt::strided_loop_assigner< false >::run (E1 & e1,
const E2 & e2 )
+ 		+inline
+
+ +

Definition at line 1354 of file xassign.hpp.

+ +
+
+ +

◆ run() [4/4]

+ +
+
+
+template<bool simd>
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + + + + + + +
void xt::strided_loop_assigner< simd >::run (E1 & e1,
const E2 & e2,
const loop_sizes_t & loop_sizes )
+ 		+inlinestatic
+
+ +

Definition at line 1102 of file xassign.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1svector-members.html b/classxt_1_1svector-members.html new file mode 100644 index 000000000..d0ed1e417 --- /dev/null +++ b/classxt_1_1svector-members.html @@ -0,0 +1,196 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::svector< T, N, A, Init > Member List
+
+
+ +

This is the complete list of members for xt::svector< T, N, A, Init >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
alignment (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >static
allocator_type typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
assign(size_type n, const value_type &v) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
assign(std::initializer_list< V > il) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
assign(IT other_begin, IT other_end) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
at(size_type idx) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
at(size_type idx) const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
back() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
back() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
begin() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
begin() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
capacity() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
cbegin() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
cend() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
clear() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
const_iterator typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
const_pointer typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
const_reference typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
const_reverse_iterator typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
crbegin() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
crend() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
data() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
data() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
difference_type typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
empty() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
end() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
end() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
erase(const_iterator cit) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
erase(const_iterator cfirst, const_iterator clast) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
front() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
front() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
get_allocator() const noexcept (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
insert(const_iterator it, const T &elt) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
insert(const_iterator pos, It first, It last) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
insert(const_iterator pos, std::initializer_list< T > l) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
insert(const_iterator pos, It first, It last) -> iterator (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
iterator typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
max_size() const noexcept (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
on_stack() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
operator=(const svector &rhs) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
operator=(svector &&rhs) noexcept(std::is_nothrow_move_assignable< value_type >::value) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
operator=(const std::vector< T > &rhs) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
operator=(std::initializer_list< T > il) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
operator=(const svector< T, N2, A, I2 > &rhs) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
operator=(const svector< T, N2, A, I2 > &rhs) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
operator[](size_type idx) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
operator[](size_type idx) const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
pointer typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
pop_back() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
push_back(const T &elt) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
push_back(T &&elt) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
rbegin() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
rbegin() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
reference typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
rend() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
rend() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
reserve(size_type n) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
resize(size_type n) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
reverse_iterator typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
self_type typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
shrink_to_fit() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
size() const (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
size_type typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
svector() noexcept (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
svector(const allocator_type &alloc) noexcept (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inlineexplicit
svector(size_type n, const allocator_type &alloc=allocator_type()) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inlineexplicit
svector(size_type n, const value_type &v, const allocator_type &alloc=allocator_type()) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
svector(std::initializer_list< T > il, const allocator_type &alloc=allocator_type()) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
svector(const std::vector< T > &vec) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
svector(IT begin, IT end, const allocator_type &alloc=allocator_type()) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
svector(const svector< T, N2, A, I2 > &rhs) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inlineexplicit
svector(const svector &other) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
svector(svector &&other) noexcept(std::is_nothrow_move_constructible< value_type >::value) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
swap(svector< T, ON, OA, InitA > &rhs) (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
value_type typedef (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >
~svector() (defined in xt::svector< T, N, A, Init >)xt::svector< T, N, A, Init >inline
+
+ + + + diff --git a/classxt_1_1svector.html b/classxt_1_1svector.html new file mode 100644 index 000000000..4f618e920 --- /dev/null +++ b/classxt_1_1svector.html @@ -0,0 +1,2350 @@ + + + + + + + +xtensor: xt::svector< T, N, A, Init > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::svector< T, N, A, Init > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = svector<T, N, A, Init>
 
using allocator_type = A
 
using size_type = typename std::allocator_traits<A>::size_type
 
using value_type = typename std::allocator_traits<A>::value_type
 
using pointer = typename std::allocator_traits<A>::pointer
 
using const_pointer = typename std::allocator_traits<A>::const_pointer
 
using reference = value_type&
 
using const_reference = const value_type&
 
using difference_type = typename std::allocator_traits<A>::difference_type
 
using iterator = pointer
 
using const_iterator = const_pointer
 
using reverse_iterator = std::reverse_iterator<iterator>
 
using const_reverse_iterator = std::reverse_iterator<const_iterator>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 svector (const allocator_type &alloc) noexcept
 
 svector (size_type n, const allocator_type &alloc=allocator_type())
 
 svector (size_type n, const value_type &v, const allocator_type &alloc=allocator_type())
 
 svector (std::initializer_list< T > il, const allocator_type &alloc=allocator_type())
 
 svector (const std::vector< T > &vec)
 
template<std::input_iterator IT>
 svector (IT begin, IT end, const allocator_type &alloc=allocator_type())
 
template<std::size_t N2, bool I2>
+requires (N != N2)
 svector (const svector< T, N2, A, I2 > &rhs)
 
svector & operator= (const svector &rhs)
 
svector & operator= (svector &&rhs) noexcept(std::is_nothrow_move_assignable< value_type >::value)
 
svector & operator= (const std::vector< T > &rhs)
 
svector & operator= (std::initializer_list< T > il)
 
+template<std::size_t N2, bool I2>
+requires (N != N2)
svector & operator= (const svector< T, N2, A, I2 > &rhs)
 
 svector (const svector &other)
 
 svector (svector &&other) noexcept(std::is_nothrow_move_constructible< value_type >::value)
 
void assign (size_type n, const value_type &v)
 
template<class V>
void assign (std::initializer_list< V > il)
 
template<class IT>
void assign (IT other_begin, IT other_end)
 
reference operator[] (size_type idx)
 
const_reference operator[] (size_type idx) const
 
reference at (size_type idx)
 
const_reference at (size_type idx) const
 
pointer data ()
 
const_pointer data () const
 
void push_back (const T &elt)
 
void push_back (T &&elt)
 
void pop_back ()
 
iterator begin ()
 
const_iterator begin () const
 
const_iterator cbegin () const
 
iterator end ()
 
const_iterator end () const
 
const_iterator cend () const
 
reverse_iterator rbegin ()
 
const_reverse_iterator rbegin () const
 
const_reverse_iterator crbegin () const
 
reverse_iterator rend ()
 
const_reverse_iterator rend () const
 
const_reverse_iterator crend () const
 
bool empty () const
 
size_type size () const
 
void resize (size_type n)
 
size_type max_size () const noexcept
 
size_type capacity () const
 
void reserve (size_type n)
 
void shrink_to_fit ()
 
void clear ()
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
bool on_stack ()
 
iterator erase (const_iterator cit)
 
iterator erase (const_iterator cfirst, const_iterator clast)
 
iterator insert (const_iterator it, const T &elt)
 
+template<class It>
iterator insert (const_iterator pos, It first, It last)
 
iterator insert (const_iterator pos, std::initializer_list< T > l)
 
template<std::size_t ON, class OA, bool InitA>
void swap (svector< T, ON, OA, InitA > &rhs)
 
allocator_type get_allocator () const noexcept
 
template<std::size_t N2, bool I2>
+requires (N != N2)
svector< T, N, A, Init > & operator= (const svector< T, N2, A, I2 > &rhs)
 
template<class It>
auto insert (const_iterator pos, It first, It last) -> iterator
 
+ + + +

+Static Public Attributes

static constexpr std::size_t alignment
 
+

Detailed Description

+
template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+class xt::svector< T, N, A, Init >
+

Definition at line 633 of file xstorage.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::allocator_type = A
+
+ +

Definition at line 638 of file xstorage.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::const_iterator = const_pointer
+
+ +

Definition at line 648 of file xstorage.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::const_pointer = typename std::allocator_traits<A>::const_pointer
+
+ +

Definition at line 642 of file xstorage.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::const_reference = const value_type&
+
+ +

Definition at line 644 of file xstorage.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::const_reverse_iterator = std::reverse_iterator<const_iterator>
+
+ +

Definition at line 650 of file xstorage.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::difference_type = typename std::allocator_traits<A>::difference_type
+
+ +

Definition at line 645 of file xstorage.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::iterator = pointer
+
+ +

Definition at line 647 of file xstorage.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::pointer = typename std::allocator_traits<A>::pointer
+
+ +

Definition at line 641 of file xstorage.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::reference = value_type&
+
+ +

Definition at line 643 of file xstorage.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::reverse_iterator = std::reverse_iterator<iterator>
+
+ +

Definition at line 649 of file xstorage.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::self_type = svector<T, N, A, Init>
+
+ +

Definition at line 637 of file xstorage.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::size_type = typename std::allocator_traits<A>::size_type
+
+ +

Definition at line 639 of file xstorage.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + +
using xt::svector< T, N, A, Init >::value_type = typename std::allocator_traits<A>::value_type
+
+ +

Definition at line 640 of file xstorage.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ svector() [1/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
xt::svector< T, N, A, Init >::svector ()
+ 		+inlinenoexcept
+
+ +

Definition at line 780 of file xstorage.hpp.

+ +
+
+ +

◆ ~svector()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
xt::svector< T, N, A, Init >::~svector ()
+ 		+inline
+
+ +

Definition at line 771 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [2/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
xt::svector< T, N, A, Init >::svector (const allocator_type & alloc)
+ 		+inlineexplicitnoexcept
+
+ +

Definition at line 786 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [3/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + + + + + +
xt::svector< T, N, A, Init >::svector (size_type n,
const allocator_type & alloc = allocator_type() )
+ 		+inlineexplicit
+
+ +

Definition at line 792 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [4/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::svector< T, N, A, Init >::svector (size_type n,
const value_type & v,
const allocator_type & alloc = allocator_type() )
+ 		+inline
+
+ +

Definition at line 829 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [5/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + + + + + +
xt::svector< T, N, A, Init >::svector (std::initializer_list< T > il,
const allocator_type & alloc = allocator_type() )
+ 		+inline
+
+ +

Definition at line 836 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [6/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
xt::svector< T, N, A, Init >::svector (const std::vector< T > & vec)
+ 		+inline
+
+ +

Definition at line 823 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [7/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+
+template<std::input_iterator IT>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::svector< T, N, A, Init >::svector (IT begin,
IT end,
const allocator_type & alloc = allocator_type() )
+ 		+inline
+
+ +

Definition at line 807 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [8/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+requires (N != N2)
+
+template<std::size_t N2, bool I2>
+requires (N != N2)
+ + + + + +
+ + + + + + + +
xt::svector< T, N, A, Init >::svector (const svector< T, N2, A, I2 > & rhs)
+ 		+inlineexplicit
+
+ +

Definition at line 815 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [9/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
xt::svector< T, N, A, Init >::svector (const svector< T, N, A, Init > & other)
+ 		+inline
+
+ +

Definition at line 886 of file xstorage.hpp.

+ +
+
+ +

◆ svector() [10/10]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
xt::svector< T, N, A, Init >::svector (svector< T, N, A, Init > && other)
+ 		+inlinenoexcept
+
+ +

Definition at line 895 of file xstorage.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign() [1/3]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+
+template<class IT>
+ + + + + +
+ + + + + + + + + + + +
void xt::svector< T, N, A, Init >::assign (IT other_begin,
IT other_end )
+ 		+inline
+
+ +

Definition at line 921 of file xstorage.hpp.

+ +
+
+ +

◆ assign() [2/3]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + + + + + +
void xt::svector< T, N, A, Init >::assign (size_type n,
const value_type & v )
+ 		+inline
+
+ +

Definition at line 902 of file xstorage.hpp.

+ +
+
+ +

◆ assign() [3/3]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+
+template<class V>
+ + + + + +
+ + + + + + + +
void xt::svector< T, N, A, Init >::assign (std::initializer_list< V > il)
+ 		+inline
+
+ +

Definition at line 914 of file xstorage.hpp.

+ +
+
+ +

◆ at() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::at (size_type idx)
+ 		+inline
+
+ +

Definition at line 945 of file xstorage.hpp.

+ +
+
+ +

◆ at() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::at (size_type idx) const
+ 		+inline
+
+ +

Definition at line 955 of file xstorage.hpp.

+ +
+
+ +

◆ back() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::back ()
+ 		+inline
+
+ +

Definition at line 1149 of file xstorage.hpp.

+ +
+
+ +

◆ back() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::back () const
+ 		+inline
+
+ +

Definition at line 1156 of file xstorage.hpp.

+ +
+
+ +

◆ begin() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::begin ()
+ 		+inline
+
+ +

Definition at line 1051 of file xstorage.hpp.

+ +
+
+ +

◆ begin() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::begin () const
+ 		+inline
+
+ +

Definition at line 1057 of file xstorage.hpp.

+ +
+
+ +

◆ capacity()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::capacity () const
+ 		+inline
+
+ +

Definition at line 998 of file xstorage.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::cbegin () const
+ 		+inline
+
+ +

Definition at line 1063 of file xstorage.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::cend () const
+ 		+inline
+
+ +

Definition at line 1081 of file xstorage.hpp.

+ +
+
+ +

◆ clear()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
void xt::svector< T, N, A, Init >::clear ()
+ 		+inline
+
+ +

Definition at line 1019 of file xstorage.hpp.

+ +
+
+ +

◆ crbegin()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::crbegin () const
+ 		+inline
+
+ +

Definition at line 1099 of file xstorage.hpp.

+ +
+
+ +

◆ crend()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::crend () const
+ 		+inline
+
+ +

Definition at line 1117 of file xstorage.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::data ()
+ 		+inline
+
+ +

Definition at line 965 of file xstorage.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::data () const
+ 		+inline
+
+ +

Definition at line 971 of file xstorage.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::empty () const
+ 		+inline
+
+ +

Definition at line 1129 of file xstorage.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::end ()
+ 		+inline
+
+ +

Definition at line 1069 of file xstorage.hpp.

+ +
+
+ +

◆ end() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::end () const
+ 		+inline
+
+ +

Definition at line 1075 of file xstorage.hpp.

+ +
+
+ +

◆ erase() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + + + + + +
auto xt::svector< T, N, A, Init >::erase (const_iterator cfirst,
const_iterator clast )
+ 		+inline
+
+ +

Definition at line 1185 of file xstorage.hpp.

+ +
+
+ +

◆ erase() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::erase (const_iterator cit)
+ 		+inline
+
+ +

Definition at line 1175 of file xstorage.hpp.

+ +
+
+ +

◆ front() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::front ()
+ 		+inline
+
+ +

Definition at line 1135 of file xstorage.hpp.

+ +
+
+ +

◆ front() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::front () const
+ 		+inline
+
+ +

Definition at line 1142 of file xstorage.hpp.

+ +
+
+ +

◆ get_allocator()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::get_allocator () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1169 of file xstorage.hpp.

+ +
+
+ +

◆ insert() [1/3]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + + + + + +
auto xt::svector< T, N, A, Init >::insert (const_iterator it,
const T & elt )
+ 		+inline
+
+ +

Definition at line 1201 of file xstorage.hpp.

+ +
+
+ +

◆ insert() [2/3]

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::svector< T, N, A, Init >::insert (const_iterator pos,
It first,
It last ) -> iterator +
+ 		+inline
+
+ +

Definition at line 1233 of file xstorage.hpp.

+ +
+
+ +

◆ insert() [3/3]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + + + + + +
auto xt::svector< T, N, A, Init >::insert (const_iterator pos,
std::initializer_list< T > l )
+ 		+inline
+
+ +

Definition at line 1254 of file xstorage.hpp.

+ +
+
+ +

◆ max_size()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::max_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 992 of file xstorage.hpp.

+ +
+
+ +

◆ on_stack()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::on_stack ()
+ 		+inline
+
+ +

Definition at line 1163 of file xstorage.hpp.

+ +
+
+ +

◆ operator=() [1/5]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
svector< T, N, A, Init > & xt::svector< T, N, A, Init >::operator= (const std::vector< T > & rhs)
+ 		+inline
+
+ +

Definition at line 858 of file xstorage.hpp.

+ +
+
+ +

◆ operator=() [2/5]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
svector< T, N, A, Init > & xt::svector< T, N, A, Init >::operator= (const svector< T, N, A, Init > & rhs)
+ 		+inline
+
+ +

Definition at line 843 of file xstorage.hpp.

+ +
+
+ +

◆ operator=() [3/5]

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+
+template<std::size_t N2, bool I2>
+requires (N != N2)
+ + + + + +
+ + + + + + + +
svector< T, N, A, Init > & xt::svector< T, N, A, Init >::operator= (const svector< T, N2, A, I2 > & rhs)
+ 		+inline
+
+ +

Definition at line 875 of file xstorage.hpp.

+ +
+
+ +

◆ operator=() [4/5]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
svector< T, N, A, Init > & xt::svector< T, N, A, Init >::operator= (std::initializer_list< T > il)
+ 		+inline
+
+ +

Definition at line 868 of file xstorage.hpp.

+ +
+
+ +

◆ operator=() [5/5]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
svector< T, N, A, Init > & xt::svector< T, N, A, Init >::operator= (svector< T, N, A, Init > && rhs)
+ 		+inlinenoexcept
+
+ +

Definition at line 850 of file xstorage.hpp.

+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::operator[] (size_type idx)
+ 		+inline
+
+ +

Definition at line 933 of file xstorage.hpp.

+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::operator[] (size_type idx) const
+ 		+inline
+
+ +

Definition at line 939 of file xstorage.hpp.

+ +
+
+ +

◆ pop_back()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + + + +
void xt::svector< T, N, A, Init >::pop_back ()
+
+ +

Definition at line 1045 of file xstorage.hpp.

+ +
+
+ +

◆ push_back() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + + + +
void xt::svector< T, N, A, Init >::push_back (const T & elt)
+
+ +

Definition at line 1025 of file xstorage.hpp.

+ +
+
+ +

◆ push_back() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + + + +
void xt::svector< T, N, A, Init >::push_back (T && elt)
+
+ +

Definition at line 1035 of file xstorage.hpp.

+ +
+
+ +

◆ rbegin() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::rbegin ()
+ 		+inline
+
+ +

Definition at line 1087 of file xstorage.hpp.

+ +
+
+ +

◆ rbegin() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::rbegin () const
+ 		+inline
+
+ +

Definition at line 1093 of file xstorage.hpp.

+ +
+
+ +

◆ rend() [1/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::rend ()
+ 		+inline
+
+ +

Definition at line 1105 of file xstorage.hpp.

+ +
+
+ +

◆ rend() [2/2]

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::rend () const
+ 		+inline
+
+ +

Definition at line 1111 of file xstorage.hpp.

+ +
+
+ +

◆ reserve()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
void xt::svector< T, N, A, Init >::reserve (size_type n)
+ 		+inline
+
+ +

Definition at line 1004 of file xstorage.hpp.

+ +
+
+ +

◆ resize()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + + + +
void xt::svector< T, N, A, Init >::resize (size_type n)
+
+ +

Definition at line 977 of file xstorage.hpp.

+ +
+
+ +

◆ shrink_to_fit()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
void xt::svector< T, N, A, Init >::shrink_to_fit ()
+ 		+inline
+
+ +

Definition at line 1013 of file xstorage.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+ + + + + +
+ + + + + + + +
auto xt::svector< T, N, A, Init >::size () const
+ 		+inline
+
+ +

Definition at line 1123 of file xstorage.hpp.

+ +
+
+ +

◆ swap()

+ +
+
+
+template<class T, std::size_t N, class A, bool Init>
+
+template<std::size_t ON, class OA, bool InitA>
+ + + + + +
+ + + + + + + +
void xt::svector< T, N, A, Init >::swap (svector< T, ON, OA, InitA > & rhs)
+ 		+inline
+
+ +

Definition at line 1274 of file xstorage.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ alignment

+ +
+
+
+template<class T, std::size_t N = 4, class A = std::allocator<T>, bool Init = true>
+ + + + + +
+ + + + +
std::size_t xt::svector< T, N, A, Init >::alignment
+ 		+staticconstexpr
+
+Initial value:
= detail::allocator_alignment<A>::value != 0
+
? detail::allocator_alignment<A>::value
+
: alignof(T)
+
+

Definition at line 655 of file xstorage.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1transpose__error-members.html b/classxt_1_1transpose__error-members.html new file mode 100644 index 000000000..46dc74f8e --- /dev/null +++ b/classxt_1_1transpose__error-members.html @@ -0,0 +1,121 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::transpose_error Member List
+
+
+ +

This is the complete list of members for xt::transpose_error, including all inherited members.

+ + +
transpose_error(const char *msg) (defined in xt::transpose_error)xt::transpose_errorinlineexplicit
+
+ + + + diff --git a/classxt_1_1transpose__error.html b/classxt_1_1transpose__error.html new file mode 100644 index 000000000..a8cc93761 --- /dev/null +++ b/classxt_1_1transpose__error.html @@ -0,0 +1,167 @@ + + + + + + + +xtensor: xt::transpose_error Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Member Functions | +List of all members
+
xt::transpose_error Class Reference
+
+
+
+Inheritance diagram for xt::transpose_error:
+
+
+ +
+ + + + +

+Public Member Functions

 transpose_error (const char *msg)
 
+

Detailed Description

+
+

Definition at line 159 of file xexception.hpp.

+

Constructor & Destructor Documentation

+ +

◆ transpose_error()

+ +
+
+ + + + + +
+ + + + + + + +
xt::transpose_error::transpose_error (const char * msg)
+ 		+inlineexplicit
+
+ +

Definition at line 163 of file xexception.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/utils/xexception.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1transpose__error.png b/classxt_1_1transpose__error.png new file mode 100644 index 000000000..3ad30253f Binary files /dev/null and b/classxt_1_1transpose__error.png differ diff --git a/classxt_1_1uvector-members.html b/classxt_1_1uvector-members.html new file mode 100644 index 000000000..abb8b4105 --- /dev/null +++ b/classxt_1_1uvector-members.html @@ -0,0 +1,177 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::uvector< T, A > Member List
+
+
+ +

This is the complete list of members for xt::uvector< T, A >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
at(size_type i) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
at(size_type i) const (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
back() (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
back() const (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
begin() noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
begin() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
capacity() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
cbegin() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
cend() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
clear() (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
const_iterator typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
const_pointer typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
const_reference typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
const_reverse_iterator typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
crbegin() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
crend() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
data() noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
data() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
difference_type typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
empty() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
end() noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
end() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
front() (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
front() const (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
get_allocator() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
iterator typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
max_size() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
operator=(const uvector &) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
operator=(uvector &&rhs) noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
operator[](size_type i) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
operator[](size_type i) const (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
pointer typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
rbegin() noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
rbegin() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
reference typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
rend() noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
rend() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
reserve(size_type new_cap) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
resize(size_type size) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
reverse_iterator typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
shrink_to_fit() (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
size() const noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
size_type typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
swap(uvector &rhs) noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector() noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector(const allocator_type &alloc) noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inlineexplicit
uvector(size_type count, const allocator_type &alloc=allocator_type()) (defined in xt::uvector< T, A >)xt::uvector< T, A >inlineexplicit
uvector(size_type count, const_reference value, const allocator_type &alloc=allocator_type()) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector(InputIt first, InputIt last, const allocator_type &alloc=allocator_type()) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector(std::initializer_list< T > init, const allocator_type &alloc=allocator_type()) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector(const uvector &rhs) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector(const uvector &rhs, const allocator_type &alloc) (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector(uvector &&rhs) noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
uvector(uvector &&rhs, const allocator_type &alloc) noexcept (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
value_type typedef (defined in xt::uvector< T, A >)xt::uvector< T, A >
~uvector() (defined in xt::uvector< T, A >)xt::uvector< T, A >inline
+
+ + + + diff --git a/classxt_1_1uvector.html b/classxt_1_1uvector.html new file mode 100644 index 000000000..5a91c452e --- /dev/null +++ b/classxt_1_1uvector.html @@ -0,0 +1,1807 @@ + + + + + + + +xtensor: xt::uvector< T, A > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::uvector< T, A > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using allocator_type = A
 
using value_type = typename std::allocator_traits<A>::value_type
 
using reference = value_type&
 
using const_reference = const value_type&
 
using pointer = typename std::allocator_traits<A>::pointer
 
using const_pointer = typename std::allocator_traits<A>::const_pointer
 
using size_type = typename std::allocator_traits<A>::size_type
 
using difference_type = typename std::allocator_traits<A>::difference_type
 
using iterator = pointer
 
using const_iterator = const_pointer
 
using reverse_iterator = std::reverse_iterator<iterator>
 
using const_reverse_iterator = std::reverse_iterator<const_iterator>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 uvector (const allocator_type &alloc) noexcept
 
 uvector (size_type count, const allocator_type &alloc=allocator_type())
 
 uvector (size_type count, const_reference value, const allocator_type &alloc=allocator_type())
 
template<std::input_iterator InputIt>
 uvector (InputIt first, InputIt last, const allocator_type &alloc=allocator_type())
 
 uvector (std::initializer_list< T > init, const allocator_type &alloc=allocator_type())
 
 uvector (const uvector &rhs)
 
 uvector (const uvector &rhs, const allocator_type &alloc)
 
uvector & operator= (const uvector &)
 
 uvector (uvector &&rhs) noexcept
 
 uvector (uvector &&rhs, const allocator_type &alloc) noexcept
 
uvector & operator= (uvector &&rhs) noexcept
 
allocator_type get_allocator () const noexcept
 
bool empty () const noexcept
 
size_type size () const noexcept
 
void resize (size_type size)
 
size_type max_size () const noexcept
 
void reserve (size_type new_cap)
 
size_type capacity () const noexcept
 
void shrink_to_fit ()
 
void clear ()
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference at (size_type i)
 
const_reference at (size_type i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
pointer data () noexcept
 
const_pointer data () const noexcept
 
iterator begin () noexcept
 
iterator end () noexcept
 
const_iterator begin () const noexcept
 
const_iterator end () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
reverse_iterator rbegin () noexcept
 
reverse_iterator rend () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
const_reverse_iterator rend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
void swap (uvector &rhs) noexcept
 
+

Detailed Description

+
template<class T, class A = std::allocator<T>>
+class xt::uvector< T, A >
+

Definition at line 34 of file xstorage.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::allocator_type = A
+
+ +

Definition at line 38 of file xstorage.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::const_iterator = const_pointer
+
+ +

Definition at line 50 of file xstorage.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::const_pointer = typename std::allocator_traits<A>::const_pointer
+
+ +

Definition at line 44 of file xstorage.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::const_reference = const value_type&
+
+ +

Definition at line 42 of file xstorage.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::const_reverse_iterator = std::reverse_iterator<const_iterator>
+
+ +

Definition at line 52 of file xstorage.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::difference_type = typename std::allocator_traits<A>::difference_type
+
+ +

Definition at line 47 of file xstorage.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::iterator = pointer
+
+ +

Definition at line 49 of file xstorage.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::pointer = typename std::allocator_traits<A>::pointer
+
+ +

Definition at line 43 of file xstorage.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::reference = value_type&
+
+ +

Definition at line 41 of file xstorage.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::reverse_iterator = std::reverse_iterator<iterator>
+
+ +

Definition at line 51 of file xstorage.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::size_type = typename std::allocator_traits<A>::size_type
+
+ +

Definition at line 46 of file xstorage.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class T, class A = std::allocator<T>>
+ + + + +
using xt::uvector< T, A >::value_type = typename std::allocator_traits<A>::value_type
+
+ +

Definition at line 40 of file xstorage.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ uvector() [1/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
xt::uvector< T, A >::uvector ()
+ 		+inlinenoexcept
+
+ +

Definition at line 231 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [2/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
xt::uvector< T, A >::uvector (const allocator_type & alloc)
+ 		+inlineexplicitnoexcept
+
+ +

Definition at line 237 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [3/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + + + + + +
xt::uvector< T, A >::uvector (size_type count,
const allocator_type & alloc = allocator_type() )
+ 		+inlineexplicit
+
+ +

Definition at line 245 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [4/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::uvector< T, A >::uvector (size_type count,
const_reference value,
const allocator_type & alloc = allocator_type() )
+ 		+inline
+
+ +

Definition at line 258 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [5/10]

+ +
+
+
+template<class T, class A>
+
+template<std::input_iterator InputIt>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::uvector< T, A >::uvector (InputIt first,
InputIt last,
const allocator_type & alloc = allocator_type() )
+ 		+inline
+
+ +

Definition at line 273 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [6/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + + + + + +
xt::uvector< T, A >::uvector (std::initializer_list< T > init,
const allocator_type & alloc = allocator_type() )
+ 		+inline
+
+ +

Definition at line 282 of file xstorage.hpp.

+ +
+
+ +

◆ ~uvector()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
xt::uvector< T, A >::~uvector ()
+ 		+inline
+
+ +

Definition at line 291 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [7/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
xt::uvector< T, A >::uvector (const uvector< T, A > & rhs)
+ 		+inline
+
+ +

Definition at line 299 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [8/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + + + + + +
xt::uvector< T, A >::uvector (const uvector< T, A > & rhs,
const allocator_type & alloc )
+ 		+inline
+
+ +

Definition at line 310 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [9/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
xt::uvector< T, A >::uvector (uvector< T, A > && rhs)
+ 		+inlinenoexcept
+
+ +

Definition at line 341 of file xstorage.hpp.

+ +
+
+ +

◆ uvector() [10/10]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + + + + + +
xt::uvector< T, A >::uvector (uvector< T, A > && rhs,
const allocator_type & alloc )
+ 		+inlinenoexcept
+
+ +

Definition at line 351 of file xstorage.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ at() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::at (size_type i)
+ 		+inline
+
+ +

Definition at line 435 of file xstorage.hpp.

+ +
+
+ +

◆ at() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::at (size_type i) const
+ 		+inline
+
+ +

Definition at line 445 of file xstorage.hpp.

+ +
+
+ +

◆ back() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::back ()
+ 		+inline
+
+ +

Definition at line 467 of file xstorage.hpp.

+ +
+
+ +

◆ back() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::back () const
+ 		+inline
+
+ +

Definition at line 473 of file xstorage.hpp.

+ +
+
+ +

◆ begin() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 503 of file xstorage.hpp.

+ +
+
+ +

◆ begin() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 491 of file xstorage.hpp.

+ +
+
+ +

◆ capacity()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::capacity () const
+ 		+inlinenoexcept
+
+ +

Definition at line 406 of file xstorage.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 515 of file xstorage.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 521 of file xstorage.hpp.

+ +
+
+ +

◆ clear()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
void xt::uvector< T, A >::clear ()
+ 		+inline
+
+ +

Definition at line 417 of file xstorage.hpp.

+ +
+
+ +

◆ crbegin()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 551 of file xstorage.hpp.

+ +
+
+ +

◆ crend()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 557 of file xstorage.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::data () const
+ 		+inlinenoexcept
+
+ +

Definition at line 485 of file xstorage.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::data ()
+ 		+inlinenoexcept
+
+ +

Definition at line 479 of file xstorage.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
bool xt::uvector< T, A >::empty () const
+ 		+inlinenoexcept
+
+ +

Definition at line 377 of file xstorage.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 509 of file xstorage.hpp.

+ +
+
+ +

◆ end() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 497 of file xstorage.hpp.

+ +
+
+ +

◆ front() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::front ()
+ 		+inline
+
+ +

Definition at line 455 of file xstorage.hpp.

+ +
+
+ +

◆ front() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::front () const
+ 		+inline
+
+ +

Definition at line 461 of file xstorage.hpp.

+ +
+
+ +

◆ get_allocator()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::get_allocator () const
+ 		+inlinenoexcept
+
+ +

Definition at line 371 of file xstorage.hpp.

+ +
+
+ +

◆ max_size()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::max_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 395 of file xstorage.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
uvector< T, A > & xt::uvector< T, A >::operator= (const uvector< T, A > & rhs)
+ 		+inline
+
+ +

Definition at line 319 of file xstorage.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
uvector< T, A > & xt::uvector< T, A >::operator= (uvector< T, A > && rhs)
+ 		+inlinenoexcept
+
+ +

Definition at line 361 of file xstorage.hpp.

+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 423 of file xstorage.hpp.

+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 429 of file xstorage.hpp.

+ +
+
+ +

◆ rbegin() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 539 of file xstorage.hpp.

+ +
+
+ +

◆ rbegin() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::rbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 527 of file xstorage.hpp.

+ +
+
+ +

◆ rend() [1/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 545 of file xstorage.hpp.

+ +
+
+ +

◆ rend() [2/2]

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::rend ()
+ 		+inlinenoexcept
+
+ +

Definition at line 533 of file xstorage.hpp.

+ +
+
+ +

◆ reserve()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
void xt::uvector< T, A >::reserve (size_type new_cap)
+ 		+inline
+
+ +

Definition at line 401 of file xstorage.hpp.

+ +
+
+ +

◆ resize()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
void xt::uvector< T, A >::resize (size_type size)
+ 		+inline
+
+ +

Definition at line 389 of file xstorage.hpp.

+ +
+
+ +

◆ shrink_to_fit()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
void xt::uvector< T, A >::shrink_to_fit ()
+ 		+inline
+
+ +

Definition at line 412 of file xstorage.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
auto xt::uvector< T, A >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 383 of file xstorage.hpp.

+ +
+
+ +

◆ swap()

+ +
+
+
+template<class T, class A>
+ + + + + +
+ + + + + + + +
void xt::uvector< T, A >::swap (uvector< T, A > & rhs)
+ 		+inlinenoexcept
+
+ +

Definition at line 563 of file xstorage.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xstorage.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xaccessible-members.html b/classxt_1_1xaccessible-members.html new file mode 100644 index 000000000..115551b57 --- /dev/null +++ b/classxt_1_1xaccessible-members.html @@ -0,0 +1,160 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xaccessible< D > Member List
+
+
+ +

This is the complete list of members for xt::xaccessible< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
at(Args... args) (defined in xt::xaccessible< D >)xt::xaccessible< D >
at(Args... args) -> referencext::xaccessible< D >inline
at(Args... args) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
back()xt::xaccessible< D >inline
back() constxt::xaccessible< D >inline
base_type typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >
const_reference typedef (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
derived_type typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >
dimension() const noexceptxt::xconst_accessible< D >inline
front()xt::xaccessible< D >inline
front() constxt::xaccessible< D >inline
in_bounds(Args... args) constxt::xconst_accessible< D >inline
inner_types typedef (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
operator=(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
operator=(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
operator=(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator=(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator[](const S &index) (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](std::initializer_list< I > index) (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](size_type i) (defined in xt::xaccessible< D >)xt::xaccessible< D >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< D >inline
operator[](std::initializer_list< I > index) -> reference (defined in xt::xaccessible< D >)xt::xaccessible< D >inline
operator[](const S &index) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](std::initializer_list< I > index) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](size_type i) const (defined in xt::xaccessible< D >)xt::xaccessible< D >inline
periodic(Args... args) (defined in xt::xaccessible< D >)xt::xaccessible< D >
periodic(Args... args) -> referencext::xaccessible< D >inline
periodic(Args... args) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
reference typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >
shape(size_type index) constxt::xconst_accessible< D >inline
size() const noexcept(noexcept(derived_cast().shape()))xt::xconst_accessible< D >inline
size_type typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >
xaccessible()=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
xaccessible(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
xaccessible(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
xconst_accessible()=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
xconst_accessible(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
xconst_accessible(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
~xaccessible()=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
~xconst_accessible()=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
+
+ + + + diff --git a/classxt_1_1xaccessible.html b/classxt_1_1xaccessible.html new file mode 100644 index 000000000..834f26b89 --- /dev/null +++ b/classxt_1_1xaccessible.html @@ -0,0 +1,754 @@ + + + + + + + +xtensor: xt::xaccessible< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xaccessible< D > Class Template Reference
+
+
+ +

Base class for implementation of common expression access methods. + More...

+ +

#include <xaccessible.hpp>

+
+Inheritance diagram for xt::xaccessible< D >:
+
+
+ + +xt::xconst_accessible< D > +xt::xreducer< Func, E, X, Opts > +xt::xscalar< xtl::closure_type_t< E > > +xt::xscalar< xtl::const_closure_type_t< E > > +xt::xscalar< T > +xt::xscalar< bool > +xt::xscalar< std::conditional_t< is_const, const_value_closure, value_closure > > +xt::xscalar< std::conditional_t< is_const, const_flag_closure, flag_closure > > +xt::xscalar< const_value_closure > +xt::xscalar< const_flag_closure > +xt::xview< uvt, S... > +xt::xview< uft, S... > +xt::xview< ucvt, S... > +xt::xview< ucft, S... > +xt::xview< UnderlyingContainer, Slices... > +xt::xview< E, S... > +xt::xcontainer< D > +xt::xfunctor_applier_base< D > +xt::xstrided_view_base< D > + +
+ + + + + + + + + + + + + + + + + + + + + +

+Public Types

using base_type = xconst_accessible<D>
 
using derived_type = typename base_type::derived_type
 
using reference = typename base_type::reference
 
using size_type = typename base_type::size_type
 
- Public Types inherited from xt::xconst_accessible< D >
using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using size_type = typename inner_types::size_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
reference at (Args... args)
 
+template<class S>
disable_integral_t< S, reference > operator[] (const S &index)
 
+template<class I>
reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
+template<class... Args>
reference periodic (Args... args)
 
reference front ()
 Returns a reference to the first element of the expression.
 
reference back ()
 Returns a reference to the last element of the expression.
 
template<class... Args>
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
template<class S>
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
template<class I>
auto operator[] (std::initializer_list< I > index) -> reference
 
template<class... Args>
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+template<class... Args>
const_reference at (Args... args) const
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class I>
const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+template<class... Args>
const_reference periodic (Args... args) const
 
- Public Member Functions inherited from xt::xconst_accessible< D >
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+template<class... Args>
const_reference at (Args... args) const
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class I>
const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
+template<class... Args>
const_reference periodic (Args... args) const
 
template<class... Args>
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
template<class... Args>
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
template<class S>
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
template<class I>
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
template<class... Args>
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+ + + + + + + + + + + + + + + + + + +

+Protected Member Functions

+ xaccessible (const xaccessible &)=default
 
+xaccessible & operator= (const xaccessible &)=default
 
+ xaccessible (xaccessible &&)=default
 
+xaccessible & operator= (xaccessible &&)=default
 
- Protected Member Functions inherited from xt::xconst_accessible< D >
+ xconst_accessible (const xconst_accessible &)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
+

Detailed Description

+
template<class D>
+class xt::xaccessible< D >

Base class for implementation of common expression access methods.

+

The xaccessible class implements access methods common to all expressions.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xaccessible provides the interface.
+
+
+ +

Definition at line 87 of file xaccessible.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xaccessible< D >::base_type = xconst_accessible<D>
+
+ +

Definition at line 91 of file xaccessible.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xaccessible< D >::derived_type = typename base_type::derived_type
+
+ +

Definition at line 92 of file xaccessible.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xaccessible< D >::reference = typename base_type::reference
+
+ +

Definition at line 93 of file xaccessible.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xaccessible< D >::size_type = typename base_type::size_type
+
+ +

Definition at line 94 of file xaccessible.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ at()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::at (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices should be equal to the number of dimensions of the expression.
+
+
+
Exceptions
+ + +
std::out_of_rangeif the number of argument is greater than the number of dimensions or if indices are out of bounds.
+
+
+ +

Definition at line 274 of file xaccessible.hpp.

+ +
+
+ +

◆ back() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::back ()
+ 		+inline
+
+ +

Returns a reference to the last element of the expression.

+ +

Definition at line 334 of file xaccessible.hpp.

+ +
+
+ +

◆ back() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::back () const
+ 		+inline
+
+ +

Returns a constant reference to last the element of the expression.

+ +

Definition at line 59 of file xaccessible.hpp.

+ +
+
+ +

◆ front() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::front ()
+ 		+inline
+
+ +

Returns a reference to the first element of the expression.

+ +

Definition at line 325 of file xaccessible.hpp.

+ +
+
+ +

◆ front() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::front () const
+ 		+inline
+
+ +

Returns a constant reference to first the element of the expression.

+ +

Definition at line 58 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [1/4]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::operator[] (const S & index) -> disable_integral_t<S, reference> +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the expression.

+
Parameters
+ + +
indexa sequence of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices in the list should be equal or greater than the number of dimensions of the expression.
+
+
+ +

Definition at line 288 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [2/4]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 301 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [3/4]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 50 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [4/4]

+ +
+
+
+template<class D>
+
+template<class I>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::operator[] (std::initializer_list< I > index) -> reference +
+ 		+inline
+
+ +

Definition at line 295 of file xaccessible.hpp.

+ +
+
+ +

◆ periodic()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::periodic (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be integers, the number of indices should be equal to the number of dimensions of the expression.
+
+
+ +

Definition at line 315 of file xaccessible.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xaccessible.js b/classxt_1_1xaccessible.js new file mode 100644 index 000000000..c4a636133 --- /dev/null +++ b/classxt_1_1xaccessible.js @@ -0,0 +1,10 @@ +var classxt_1_1xaccessible = +[ + [ "at", "classxt_1_1xaccessible.html#abd1a88f04c122d8d066a5b2abc7f2c8f", null ], + [ "back", "classxt_1_1xaccessible.html#a905660a4d87f4d3e7b651bcf6bb690d0", null ], + [ "back", "classxt_1_1xaccessible.html#ae8c11bf107fb871f054e2194163778fd", null ], + [ "front", "classxt_1_1xaccessible.html#ad36ac2c194e7e6f470548dad89e88ca2", null ], + [ "front", "classxt_1_1xaccessible.html#a06f3bb2ce9e0c3081ef0ce0ae40d1fe8", null ], + [ "operator[]", "classxt_1_1xaccessible.html#a45649ae70e8ea6cbda28caa423347c96", null ], + [ "periodic", "classxt_1_1xaccessible.html#a038772dfb1936fa221a220c5ded4ac05", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xaccessible.png b/classxt_1_1xaccessible.png new file mode 100644 index 000000000..0840d3786 Binary files /dev/null and b/classxt_1_1xaccessible.png differ diff --git a/classxt_1_1xall-members.html b/classxt_1_1xall-members.html new file mode 100644 index 000000000..2a67a2716 --- /dev/null +++ b/classxt_1_1xall-members.html @@ -0,0 +1,134 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xall< T > Member List
+
+
+ +

This is the complete list of members for xt::xall< T >, including all inherited members.

+ + + + + + + + + + + + + + + +
contains(size_type i) const noexcept (defined in xt::xall< T >)xt::xall< T >inline
convert() const noexcept (defined in xt::xall< T >)xt::xall< T >inline
operator xall< S >() const noexcept (defined in xt::xall< T >)xt::xall< T >inline
operator!=(const self_type &rhs) const noexcept (defined in xt::xall< T >)xt::xall< T >inline
operator()(size_type i) const noexcept (defined in xt::xall< T >)xt::xall< T >inline
operator==(const self_type &rhs) const noexcept (defined in xt::xall< T >)xt::xall< T >inline
revert_index(std::size_t i) const noexcept (defined in xt::xall< T >)xt::xall< T >inline
self_type typedef (defined in xt::xall< T >)xt::xall< T >
size() const noexcept (defined in xt::xall< T >)xt::xall< T >inline
size_type typedef (defined in xt::xall< T >)xt::xall< T >
step_size() const noexcept (defined in xt::xall< T >)xt::xall< T >inline
step_size(std::size_t i, std::size_t n=1) const noexcept (defined in xt::xall< T >)xt::xall< T >inline
xall()=default (defined in xt::xall< T >)xt::xall< T >
xall(size_type size) noexcept (defined in xt::xall< T >)xt::xall< T >inlineexplicit
+
+ + + + diff --git a/classxt_1_1xall.html b/classxt_1_1xall.html new file mode 100644 index 000000000..dfd1d28cd --- /dev/null +++ b/classxt_1_1xall.html @@ -0,0 +1,563 @@ + + + + + + + +xtensor: xt::xall< T > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xall< T > Class Template Reference
+
+
+
+Inheritance diagram for xt::xall< T >:
+
+
+ + +xt::xslice< xall< T > > + +
+ + + + + + + + + +

+Public Types

using size_type = T
 
using self_type = xall<T>
 
- Public Types inherited from xt::xslice< xall< T > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xall (size_type size) noexcept
 
template<std::convertible_to< T > S>
 operator xall< S > () const noexcept
 
template<std::convertible_to< T > S>
xall< S > convert () const noexcept
 
size_type operator() (size_type i) const noexcept
 
size_type size () const noexcept
 
size_type step_size () const noexcept
 
size_type step_size (std::size_t i, std::size_t n=1) const noexcept
 
size_type revert_index (std::size_t i) const noexcept
 
bool contains (size_type i) const noexcept
 
bool operator== (const self_type &rhs) const noexcept
 
bool operator!= (const self_type &rhs) const noexcept
 
- Public Member Functions inherited from xt::xslice< xall< T > >
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xslice< xall< T > >
+ xslice (const xslice &)=default
 
+ xslice (xslice &&)=default
 
+xslice & operator= (const xslice &)=default
 
+xslice & operator= (xslice &&)=default
 
+

Detailed Description

+
template<class T>
+class xt::xall< T >
+

Definition at line 191 of file xslice.hpp.

+

Member Typedef Documentation

+ +

◆ self_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xall< T >::self_type = xall<T>
+
+ +

Definition at line 196 of file xslice.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xall< T >::size_type = T
+
+ +

Definition at line 195 of file xslice.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xall()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
xt::xall< T >::xall (size_type size)
+ 		+inlineexplicitnoexcept
+
+ +

Definition at line 1146 of file xslice.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ contains()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xall< T >::contains (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1196 of file xslice.hpp.

+ +
+
+ +

◆ convert()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xall< S > xt::xall< T >::convert () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1160 of file xslice.hpp.

+ +
+
+ +

◆ operator xall< S >()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xt::xall< T >::operator xall< S > () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1153 of file xslice.hpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xall< T >::operator!= (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1208 of file xslice.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xall< T >::operator() (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1166 of file xslice.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xall< T >::operator== (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1202 of file xslice.hpp.

+ +
+
+ +

◆ revert_index()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xall< T >::revert_index (std::size_t i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1190 of file xslice.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xall< T >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1172 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [1/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xall< T >::step_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1178 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [2/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xall< T >::step_size (std::size_t i,
std::size_t n = 1 ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1184 of file xslice.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xslice.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xall.png b/classxt_1_1xall.png new file mode 100644 index 000000000..ad5350193 Binary files /dev/null and b/classxt_1_1xall.png differ diff --git a/classxt_1_1xarray__adaptor-members.html b/classxt_1_1xarray__adaptor-members.html new file mode 100644 index 000000000..7a40c7e38 --- /dev/null +++ b/classxt_1_1xarray__adaptor-members.html @@ -0,0 +1,282 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xarray_adaptor< EC, L, SC, Tag > Member List
+
+
+ +

This is the complete list of members for xt::xarray_adaptor< EC, L, SC, Tag >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xarray_adaptor< EC, L, SC, Tag > >inline
back()xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
back()xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
backstrides() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
backstrides_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
base_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
container_closure_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
data() noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
data() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
data_offset() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
dimension() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
expression_tag typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
extension_base typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
fill(const T &value)xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
flat(size_type i)xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
flat(size_type i) constxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
front()xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
front()xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
layout() const noexceptxt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator=(const xarray_adaptor &) (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >inline
operator=(xarray_adaptor &&) (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >inline
operator=(temporary_type &&) (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >inline
operator=(const xexpression< E > &e) (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
operator=(const xexpression< E > &e) -> self_type &xt::xarray_adaptor< EC, L, SC, Tag >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >inline
rank (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >static
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >inline
reset_buffer(P &&pointer, S &&size) (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >inline
reshape(S &&shape, layout_type layout=base_type::static_layout) &xt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > >inline
resize(S &&shape, bool force=false)xt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > >inline
resize(S &&shape, layout_type l)xt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > >inline
resize(S &&shape, const strides_type &strides)xt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > >inline
self_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
semantic_base typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
shape() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
shape_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
size() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
storage() noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
storage() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
storage_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
strides() const noexceptxt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
strides_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
temporary_type typedef (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
unchecked(Args... args) -> referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
unchecked(Args... args) -> referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xarray_adaptor< EC, L, SC, Tag > >inline
xarray_adaptor(storage_type &&storage)xt::xarray_adaptor< EC, L, SC, Tag >inline
xarray_adaptor(const storage_type &storage)xt::xarray_adaptor< EC, L, SC, Tag >inline
xarray_adaptor(D &&storage, const shape_type &shape, layout_type l=L)xt::xarray_adaptor< EC, L, SC, Tag >inline
xarray_adaptor(D &&storage, const shape_type &shape, const strides_type &strides)xt::xarray_adaptor< EC, L, SC, Tag >inline
xarray_adaptor(const xarray_adaptor &)=default (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
xarray_adaptor(xarray_adaptor &&)=default (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
xcontainer< xarray_adaptor< EC, L, SC, Tag > > (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >friend
~xarray_adaptor()=default (defined in xt::xarray_adaptor< EC, L, SC, Tag >)xt::xarray_adaptor< EC, L, SC, Tag >
+
+ + + + diff --git a/classxt_1_1xarray__adaptor.html b/classxt_1_1xarray__adaptor.html new file mode 100644 index 000000000..730e089fa --- /dev/null +++ b/classxt_1_1xarray__adaptor.html @@ -0,0 +1,1816 @@ + + + + + + + +xtensor: xt::xarray_adaptor< EC, L, SC, Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xarray_adaptor< EC, L, SC, Tag > Class Template Reference
+
+
+ +

Dense multidimensional container adaptor with tensor semantic. + More...

+ +

#include <xarray.hpp>

+
+Inheritance diagram for xt::xarray_adaptor< EC, L, SC, Tag >:
+
+
+ + +xt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > > +xt::xcontainer_semantic< xarray_adaptor< EC, L, SC, Tag > > +xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > > +xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > > +xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > > +xt::xaccessible< xarray_adaptor< EC, L, SC, Tag > > +xt::xiterable< xarray_adaptor< EC, L, SC, Tag > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using container_closure_type = EC
 
using self_type = xarray_adaptor<EC, L, SC, Tag>
 
using base_type = xstrided_container<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using extension_base = extension::xarray_adaptor_base_t<EC, L, SC, Tag>
 
using storage_type = typename base_type::storage_type
 
using allocator_type = typename base_type::allocator_type
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using expression_tag = Tag
 
- Public Types inherited from xt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > >
using base_type
 
using storage_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using shape_type
 
using strides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
- Public Types inherited from xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
using derived_type
 
using inner_types
 
using storage_type
 
using allocator_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using accessible_base
 
using data_alignment
 
using simd_type
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using simd_return_type
 
using container_iterator
 
using const_container_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >
using derived_type
 
using inner_types
 
using iterable_base
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_traits
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using select_iterator_impl
 
using select_iterator
 
using select_const_iterator
 
using select_reverse_iterator
 
using select_const_reverse_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xarray_adaptor< EC, L, SC, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xarray_adaptor (const xarray_adaptor &)=default
 
+ xarray_adaptor (xarray_adaptor &&)=default
 
+template<class E>
xarray_adaptor & operator= (const xexpression< E > &e)
 
Constructors
 xarray_adaptor (storage_type &&storage)
 Constructs an xarray_adaptor of the given stl-like container.
 
 xarray_adaptor (const storage_type &storage)
 Constructs an xarray_adaptor of the given stl-like container.
 
template<class D>
 xarray_adaptor (D &&storage, const shape_type &shape, layout_type l=L)
 Constructs an xarray_adaptor of the given stl-like container, with the specified shape and layout_type.
 
template<class D>
 xarray_adaptor (D &&storage, const shape_type &shape, const strides_type &strides)
 Constructs an xarray_adaptor of the given stl-like container, with the specified shape and strides.
 
xarray_adaptor & operator= (const xarray_adaptor &)
 
xarray_adaptor & operator= (xarray_adaptor &&)
 
xarray_adaptor & operator= (temporary_type &&)
 
void resize (S &&shape, bool force=false)
 Resizes the container.
 
void resize (S &&shape, layout_type l)
 Resizes the container.
 
void resize (S &&shape, const strides_type &strides)
 Resizes the container.
 
auto & reshape (S &&shape, layout_type layout=base_type::static_layout) &
 Reshapes the container and keeps old elements.
 
auto & reshape (std::initializer_list< T > shape, layout_type layout=base_type::static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
- Public Member Functions inherited from xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
void fill (const T &value)
 Fills the container with the given value.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
void store_simd (size_type i, const simd &e)
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
- Public Member Functions inherited from xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >
+select_iterator< L > begin () noexcept
 
+select_const_iterator< L > begin () const noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+select_iterator< L > end () noexcept
 
+select_const_iterator< L > end () const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+select_const_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+select_const_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+select_reverse_iterator< L > rbegin () noexcept
 
+select_const_reverse_iterator< L > rbegin () const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+select_reverse_iterator< L > rend () noexcept
 
+select_const_reverse_iterator< L > rend () const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xarray_adaptor< EC, L, SC, Tag > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + + + +

+Static Public Attributes

static constexpr std::size_t rank = SIZE_MAX
 
- Static Public Attributes inherited from xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< xarray_adaptor< EC, L, SC, Tag > >
static constexpr layout_type static_layout
 
+ + + +

+Friends

class xcontainer< xarray_adaptor< EC, L, SC, Tag > >
 
+ + + + + + + + +

Extended copy semantic

template<class P, class S>
void reset_buffer (P &&pointer, S &&size)
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xstrided_container< xarray_adaptor< EC, L, SC, Tag > >
+ xstrided_container (const xstrided_container &)=default
 
+ xstrided_container (xstrided_container &&)=default
 
+xstrided_container & operator= (const xstrided_container &)=default
 
+xstrided_container & operator= (xstrided_container &&)=default
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&) noexcept
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept
 
inner_shape_type & shape_impl () noexcept
 
const inner_shape_type & shape_impl () const noexcept
 
inner_strides_type & strides_impl () noexcept
 
const inner_strides_type & strides_impl () const noexcept
 
inner_backstrides_type & backstrides_impl () noexcept
 
const inner_backstrides_type & backstrides_impl () const noexcept
 
void reshape_impl (S &&shape, std::true_type, layout_type layout=base_type::static_layout)
 
void reshape_impl (S &&shape, std::false_type, layout_type layout=base_type::static_layout)
 
layout_type & mutable_layout () noexcept
 
- Protected Member Functions inherited from xt::xcontainer< xarray_adaptor< EC, L, SC, Tag > >
+ xcontainer (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xarray_adaptor< EC, L, SC, Tag > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xarray_adaptor< EC, L, SC, Tag > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class EC, layout_type L, class SC, class Tag>
+class xt::xarray_adaptor< EC, L, SC, Tag >

Dense multidimensional container adaptor with tensor semantic.

+

The xarray_adaptor class implements a dense multidimensional container adaptor with tensor semantic. It is used to provide a multidimensional container semantic and a tensor semantic to stl-like containers.

+
Template Parameters
+ + + + + +
ECThe closure for the container type to adapt.
LThe layout_type of the adaptor.
SCThe type of the containers holding the shape and the strides.
TagThe expression tag.
+
+
+
See also
xstrided_container, xcontainer
+ +

Definition at line 213 of file xarray.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::allocator_type = typename base_type::allocator_type
+
+ +

Definition at line 226 of file xarray.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 229 of file xarray.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::base_type = xstrided_container<self_type>
+
+ +

Definition at line 222 of file xarray.hpp.

+ +
+
+ +

◆ container_closure_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::container_closure_type = EC
+
+ +

Definition at line 219 of file xarray.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::expression_tag = Tag
+
+ +

Definition at line 231 of file xarray.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::extension_base = extension::xarray_adaptor_base_t<EC, L, SC, Tag>
+
+ +

Definition at line 224 of file xarray.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::self_type = xarray_adaptor<EC, L, SC, Tag>
+
+ +

Definition at line 221 of file xarray.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 223 of file xarray.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 227 of file xarray.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 225 of file xarray.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 228 of file xarray.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_adaptor< EC, L, SC, Tag >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 230 of file xarray.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xarray_adaptor() [1/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_adaptor< EC, L, SC, Tag >::xarray_adaptor (storage_type && storage)
+ 		+inline
+
+ +

Constructs an xarray_adaptor of the given stl-like container.

+
Parameters
+ + +
storagethe container to adapt
+
+
+ +

Definition at line 549 of file xarray.hpp.

+ +
+
+ +

◆ xarray_adaptor() [2/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_adaptor< EC, L, SC, Tag >::xarray_adaptor (const storage_type & storage)
+ 		+inline
+
+ +

Constructs an xarray_adaptor of the given stl-like container.

+
Parameters
+ + +
storagethe container to adapt
+
+
+ +

Definition at line 560 of file xarray.hpp.

+ +
+
+ +

◆ xarray_adaptor() [3/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xarray_adaptor< EC, L, SC, Tag >::xarray_adaptor (D && storage,
const shape_type & shape,
layout_type l = L )
+ 		+inline
+
+ +

Constructs an xarray_adaptor of the given stl-like container, with the specified shape and layout_type.

+
Parameters
+ + + + +
storagethe container to adapt
shapethe shape of the xarray_adaptor
lthe layout_type of the xarray_adaptor
+
+
+ +

Definition at line 575 of file xarray.hpp.

+ +
+
+ +

◆ xarray_adaptor() [4/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xarray_adaptor< EC, L, SC, Tag >::xarray_adaptor (D && storage,
const shape_type & shape,
const strides_type & strides )
+ 		+inline
+
+ +

Constructs an xarray_adaptor of the given stl-like container, with the specified shape and strides.

+
Parameters
+ + + + +
storagethe container to adapt
shapethe shape of the xarray_adaptor
stridesthe strides of the xarray_adaptor
+
+
+ +

Definition at line 591 of file xarray.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator=() [1/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xarray_adaptor< EC, L, SC, Tag >::operator= (const xarray_adaptor< EC, L, SC, Tag > & rhs)
+ 		+inline
+
+ +

Definition at line 605 of file xarray.hpp.

+ +
+
+ +

◆ operator=() [2/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xarray_adaptor< EC, L, SC, Tag >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 639 of file xarray.hpp.

+ +
+
+ +

◆ operator=() [3/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xarray_adaptor< EC, L, SC, Tag >::operator= (temporary_type && rhs)
+ 		+inline
+
+ +

Definition at line 621 of file xarray.hpp.

+ +
+
+ +

◆ operator=() [4/4]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xarray_adaptor< EC, L, SC, Tag >::operator= (xarray_adaptor< EC, L, SC, Tag > && rhs)
+ 		+inline
+
+ +

Definition at line 613 of file xarray.hpp.

+ +
+
+ +

◆ reset_buffer()

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<class P, class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xarray_adaptor< EC, L, SC, Tag >::reset_buffer (P && pointer,
S && size )
+ 		+inline
+
+ +

Definition at line 660 of file xarray.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xcontainer< xarray_adaptor< EC, L, SC, Tag > >

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + +
friend class xcontainer< xarray_adaptor< EC, L, SC, Tag > >
+ 		+friend
+
+ +

Definition at line 263 of file xarray.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ rank

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + +
std::size_t xt::xarray_adaptor< EC, L, SC, Tag >::rank = SIZE_MAX
+ 		+staticconstexpr
+
+ +

Definition at line 232 of file xarray.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xarray.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xarray__adaptor.js b/classxt_1_1xarray__adaptor.js new file mode 100644 index 000000000..54c057600 --- /dev/null +++ b/classxt_1_1xarray__adaptor.js @@ -0,0 +1,8 @@ +var classxt_1_1xarray__adaptor = +[ + [ "xarray_adaptor", "classxt_1_1xarray__adaptor.html#acc36cdfcb52803d3996a97569929eb72", null ], + [ "xarray_adaptor", "classxt_1_1xarray__adaptor.html#a7f70baf14dbcdfeffa82a4dc56d995e4", null ], + [ "xarray_adaptor", "classxt_1_1xarray__adaptor.html#a04e029bca1b4fbf0bb361898b93182fc", null ], + [ "xarray_adaptor", "classxt_1_1xarray__adaptor.html#a32fe6b670e042fff5d9a1f7c4d99c125", null ], + [ "operator=", "classxt_1_1xarray__adaptor.html#aece6f91aa92298df35846b524613828b", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xarray__adaptor.png b/classxt_1_1xarray__adaptor.png new file mode 100644 index 000000000..bf5749607 Binary files /dev/null and b/classxt_1_1xarray__adaptor.png differ diff --git a/classxt_1_1xarray__container-members.html b/classxt_1_1xarray__container-members.html new file mode 100644 index 000000000..fd92c4194 --- /dev/null +++ b/classxt_1_1xarray__container-members.html @@ -0,0 +1,301 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xarray_container< EC, L, SC, Tag > Member List
+
+
+ +

This is the complete list of members for xt::xarray_container< EC, L, SC, Tag >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > >inline
back()xt::xcontainer< xarray_container< EC, L, SC, Tag > >
back()xt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
backstrides() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >
backstrides_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
base_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
const_pointer typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
const_reference typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
data() noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
data() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
data_offset() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
dimension() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
expression_tag typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
extension_base typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
fill(const T &value)xt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
flat(size_type i)xt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
flat(size_type i) constxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
from_shape(S &&s) (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >static
from_shape(S &&s)xt::xarray_container< EC, L, SC, Tag >inline
front()xt::xcontainer< xarray_container< EC, L, SC, Tag > >
front()xt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
inner_backstrides_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
inner_shape_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
inner_strides_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
layout() const noexceptxt::xstrided_container< xarray_container< EC, L, SC, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator=(const xarray_container &)=default (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
operator=(xarray_container &&)=default (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
operator=(xtensor_container< EC, N, L, Tag > &&rhs) (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
operator=(const xexpression< E > &e) (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
operator=(xtensor_container< EC, N, L, Tag > &&rhs) (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >inline
operator=(const xexpression< E > &e) -> self_type &xt::xarray_container< EC, L, SC, Tag >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >inline
pointer typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
rank (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >static
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
reference typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >inline
reshape(S &&shape, layout_type layout=base_type::static_layout) &xt::xstrided_container< xarray_container< EC, L, SC, Tag > >inline
resize(S &&shape, bool force=false)xt::xstrided_container< xarray_container< EC, L, SC, Tag > >inline
resize(S &&shape, layout_type l)xt::xstrided_container< xarray_container< EC, L, SC, Tag > >inline
resize(S &&shape, const strides_type &strides)xt::xstrided_container< xarray_container< EC, L, SC, Tag > >inline
self_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
semantic_base typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
shape() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >
shape_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
size() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
storage() noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
storage() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >inline
storage_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
strides() const noexceptxt::xcontainer< xarray_container< EC, L, SC, Tag > >
strides_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
temporary_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
unchecked(Args... args) -> referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
unchecked(Args... args) -> referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xarray_container< EC, L, SC, Tag > >inline
value_type typedef (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
xarray_container()xt::xarray_container< EC, L, SC, Tag >inline
xarray_container(const shape_type &shape, layout_type l=L)xt::xarray_container< EC, L, SC, Tag >inlineexplicit
xarray_container(const shape_type &shape, const_reference value, layout_type l=L)xt::xarray_container< EC, L, SC, Tag >inlineexplicit
xarray_container(const shape_type &shape, const strides_type &strides)xt::xarray_container< EC, L, SC, Tag >inlineexplicit
xarray_container(const shape_type &shape, const strides_type &strides, const_reference value)xt::xarray_container< EC, L, SC, Tag >inlineexplicit
xarray_container(storage_type &&storage, inner_shape_type &&shape, inner_strides_type &&strides)xt::xarray_container< EC, L, SC, Tag >inlineexplicit
xarray_container(const value_type &t)xt::xarray_container< EC, L, SC, Tag >inline
xarray_container(nested_initializer_list_t< value_type, 1 > t)xt::xarray_container< EC, L, SC, Tag >inline
xarray_container(nested_initializer_list_t< value_type, 2 > t)xt::xarray_container< EC, L, SC, Tag >inline
xarray_container(nested_initializer_list_t< value_type, 3 > t)xt::xarray_container< EC, L, SC, Tag >inline
xarray_container(nested_initializer_list_t< value_type, 4 > t)xt::xarray_container< EC, L, SC, Tag >inline
xarray_container(nested_initializer_list_t< value_type, 5 > t)xt::xarray_container< EC, L, SC, Tag >inline
xarray_container(const xarray_container &)=default (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
xarray_container(xarray_container &&)=default (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
xarray_container(xtensor_container< EC, N, L, Tag > &&rhs) (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >inlineexplicit
xarray_container(const xexpression< E > &e)xt::xarray_container< EC, L, SC, Tag >inline
xcontainer< xarray_container< EC, L, SC, Tag > > (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >friend
~xarray_container()=default (defined in xt::xarray_container< EC, L, SC, Tag >)xt::xarray_container< EC, L, SC, Tag >
+
+ + + + diff --git a/classxt_1_1xarray__container.html b/classxt_1_1xarray__container.html new file mode 100644 index 000000000..4a5f6a58b --- /dev/null +++ b/classxt_1_1xarray__container.html @@ -0,0 +1,2321 @@ + + + + + + + +xtensor: xt::xarray_container< EC, L, SC, Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xarray_container< EC, L, SC, Tag > Class Template Reference
+
+
+ +

Dense multidimensional container with tensor semantic. + More...

+ +

#include <xarray.hpp>

+
+Inheritance diagram for xt::xarray_container< EC, L, SC, Tag >:
+
+
+ + +xt::xstrided_container< xarray_container< EC, L, SC, Tag > > +xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > > +xt::xcontainer< xarray_container< EC, L, SC, Tag > > +xt::xsemantic_base< xarray_container< EC, L, SC, Tag > > +xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > > +xt::xaccessible< xarray_container< EC, L, SC, Tag > > +xt::xiterable< xarray_container< EC, L, SC, Tag > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xarray_container<EC, L, SC, Tag>
 
using base_type = xstrided_container<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using extension_base = extension::xarray_container_base_t<EC, L, SC, Tag>
 
using storage_type = typename base_type::storage_type
 
using allocator_type = typename base_type::allocator_type
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using shape_type = typename base_type::shape_type
 
using inner_shape_type = typename base_type::inner_shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using inner_strides_type = typename base_type::inner_strides_type
 
using inner_backstrides_type = typename base_type::inner_backstrides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using expression_tag = Tag
 
- Public Types inherited from xt::xstrided_container< xarray_container< EC, L, SC, Tag > >
using base_type
 
using storage_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using shape_type
 
using strides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
- Public Types inherited from xt::xcontainer< xarray_container< EC, L, SC, Tag > >
using derived_type
 
using inner_types
 
using storage_type
 
using allocator_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using accessible_base
 
using data_alignment
 
using simd_type
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using simd_return_type
 
using container_iterator
 
using const_container_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >
using derived_type
 
using inner_types
 
using iterable_base
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_traits
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using select_iterator_impl
 
using select_iterator
 
using select_const_iterator
 
using select_reverse_iterator
 
using select_const_reverse_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xarray_container (const xarray_container &)=default
 
+xarray_container & operator= (const xarray_container &)=default
 
+ xarray_container (xarray_container &&)=default
 
+xarray_container & operator= (xarray_container &&)=default
 
+template<std::size_t N>
xarray_container & operator= (xtensor_container< EC, N, L, Tag > &&rhs)
 
+template<class E>
xarray_container & operator= (const xexpression< E > &e)
 
Constructors
 xarray_container ()
 Allocates an uninitialized xarray_container that holds 0 element.
 
 xarray_container (const shape_type &shape, layout_type l=L)
 Allocates an uninitialized xarray_container with the specified shape and layout_type.
 
 xarray_container (const shape_type &shape, const_reference value, layout_type l=L)
 Allocates an xarray_container with the specified shape and layout_type.
 
 xarray_container (const shape_type &shape, const strides_type &strides)
 Allocates an uninitialized xarray_container with the specified shape and strides.
 
 xarray_container (const shape_type &shape, const strides_type &strides, const_reference value)
 Allocates an uninitialized xarray_container with the specified shape and strides.
 
 xarray_container (storage_type &&storage, inner_shape_type &&shape, inner_strides_type &&strides)
 Allocates an xarray_container by moving specified data, shape and strides.
 
 xarray_container (const value_type &t)
 Allocates an xarray_container that holds a single element initialized to the specified value.
 
Constructors from initializer list
 xarray_container (nested_initializer_list_t< value_type, 1 > t)
 Allocates a one-dimensional xarray_container.
 
 xarray_container (nested_initializer_list_t< value_type, 2 > t)
 Allocates a two-dimensional xarray_container.
 
 xarray_container (nested_initializer_list_t< value_type, 3 > t)
 Allocates a three-dimensional xarray_container.
 
 xarray_container (nested_initializer_list_t< value_type, 4 > t)
 Allocates a four-dimensional xarray_container.
 
 xarray_container (nested_initializer_list_t< value_type, 5 > t)
 Allocates a five-dimensional xarray_container.
 
template<std::size_t N>
 xarray_container (xtensor_container< EC, N, L, Tag > &&rhs)
 
template<class S>
xarray_container< EC, L, SC, Tag > from_shape (S &&s)
 Allocates and returns an xarray_container with the specified shape.
 
template<std::size_t N>
xarray_container< EC, L, SC, Tag > & operator= (xtensor_container< EC, N, L, Tag > &&rhs)
 
void resize (S &&shape, bool force=false)
 Resizes the container.
 
void resize (S &&shape, layout_type l)
 Resizes the container.
 
void resize (S &&shape, const strides_type &strides)
 Resizes the container.
 
auto & reshape (S &&shape, layout_type layout=base_type::static_layout) &
 Reshapes the container and keeps old elements.
 
auto & reshape (std::initializer_list< T > shape, layout_type layout=base_type::static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
- Public Member Functions inherited from xt::xcontainer< xarray_container< EC, L, SC, Tag > >
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
void fill (const T &value)
 Fills the container with the given value.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
void store_simd (size_type i, const simd &e)
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
- Public Member Functions inherited from xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >
+select_iterator< L > begin () noexcept
 
+select_const_iterator< L > begin () const noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+select_iterator< L > end () noexcept
 
+select_const_iterator< L > end () const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+select_const_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+select_const_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+select_reverse_iterator< L > rbegin () noexcept
 
+select_const_reverse_iterator< L > rbegin () const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+select_reverse_iterator< L > rend () noexcept
 
+select_const_reverse_iterator< L > rend () const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + +

+Static Public Member Functions

+template<class S = shape_type>
static xarray_container from_shape (S &&s)
 
+ + + + + + + + + + + +

+Static Public Attributes

static constexpr std::size_t rank = SIZE_MAX
 
- Static Public Attributes inherited from xt::xcontainer< xarray_container< EC, L, SC, Tag > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< xarray_container< EC, L, SC, Tag > >
static constexpr layout_type static_layout
 
+ + + +

+Friends

class xcontainer< xarray_container< EC, L, SC, Tag > >
 
+ + + + + + + + + +

Extended copy semantic

template<class E>
 xarray_container (const xexpression< E > &e)
 The extended copy constructor.
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xstrided_container< xarray_container< EC, L, SC, Tag > >
+ xstrided_container (const xstrided_container &)=default
 
+ xstrided_container (xstrided_container &&)=default
 
+xstrided_container & operator= (const xstrided_container &)=default
 
+xstrided_container & operator= (xstrided_container &&)=default
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&) noexcept
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept
 
inner_shape_type & shape_impl () noexcept
 
const inner_shape_type & shape_impl () const noexcept
 
inner_strides_type & strides_impl () noexcept
 
const inner_strides_type & strides_impl () const noexcept
 
inner_backstrides_type & backstrides_impl () noexcept
 
const inner_backstrides_type & backstrides_impl () const noexcept
 
void reshape_impl (S &&shape, std::true_type, layout_type layout=base_type::static_layout)
 
void reshape_impl (S &&shape, std::false_type, layout_type layout=base_type::static_layout)
 
layout_type & mutable_layout () noexcept
 
- Protected Member Functions inherited from xt::xcontainer< xarray_container< EC, L, SC, Tag > >
+ xcontainer (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xarray_container< EC, L, SC, Tag > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xarray_container< EC, L, SC, Tag > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class EC, layout_type L, class SC, class Tag>
+class xt::xarray_container< EC, L, SC, Tag >

Dense multidimensional container with tensor semantic.

+

The xarray_container class implements a dense multidimensional container with tensor semantic.

+
Template Parameters
+ + + + + +
ECThe type of the container holding the elements.
LThe layout_type of the container.
SCThe type of the containers holding the shape and the strides.
TagThe expression tag.
+
+
+
See also
xarray, xstrided_container, xcontainer
+ +

Definition at line 81 of file xarray.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::allocator_type = typename base_type::allocator_type
+
+ +

Definition at line 92 of file xarray.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 101 of file xarray.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::base_type = xstrided_container<self_type>
+
+ +

Definition at line 88 of file xarray.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 97 of file xarray.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 95 of file xarray.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::expression_tag = Tag
+
+ +

Definition at line 105 of file xarray.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::extension_base = extension::xarray_container_base_t<EC, L, SC, Tag>
+
+ +

Definition at line 90 of file xarray.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::inner_backstrides_type = typename base_type::inner_backstrides_type
+
+ +

Definition at line 103 of file xarray.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::inner_shape_type = typename base_type::inner_shape_type
+
+ +

Definition at line 99 of file xarray.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::inner_strides_type = typename base_type::inner_strides_type
+
+ +

Definition at line 102 of file xarray.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::pointer = typename base_type::pointer
+
+ +

Definition at line 96 of file xarray.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::reference = typename base_type::reference
+
+ +

Definition at line 94 of file xarray.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::self_type = xarray_container<EC, L, SC, Tag>
+
+ +

Definition at line 87 of file xarray.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 89 of file xarray.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 98 of file xarray.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 91 of file xarray.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 100 of file xarray.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 104 of file xarray.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + +
using xt::xarray_container< EC, L, SC, Tag >::value_type = typename base_type::value_type
+
+ +

Definition at line 93 of file xarray.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xarray_container() [1/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container ()
+ 		+inline
+
+ +

Allocates an uninitialized xarray_container that holds 0 element.

+ +

Definition at line 280 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [2/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (const shape_type & shape,
layout_type l = L )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xarray_container with the specified shape and layout_type.

+
Parameters
+ + + +
shapethe shape of the xarray_container
lthe layout_type of the xarray_container
+
+
+ +

Definition at line 293 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [3/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (const shape_type & shape,
const_reference value,
layout_type l = L )
+ 		+inlineexplicit
+
+ +

Allocates an xarray_container with the specified shape and layout_type.

+

Elements are initialized to the specified value.

Parameters
+ + + + +
shapethe shape of the xarray_container
valuethe value of the elements
lthe layout_type of the xarray_container
+
+
+ +

Definition at line 307 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [4/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (const shape_type & shape,
const strides_type & strides )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xarray_container with the specified shape and strides.

+
Parameters
+ + + +
shapethe shape of the xarray_container
stridesthe strides of the xarray_container
+
+
+ +

Definition at line 324 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [5/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (const shape_type & shape,
const strides_type & strides,
const_reference value )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xarray_container with the specified shape and strides.

+

Elements are initialized to the specified value.

Parameters
+ + + + +
shapethe shape of the xarray_container
stridesthe strides of the xarray_container
valuethe value of the elements
+
+
+ +

Definition at line 338 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [6/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (storage_type && storage,
inner_shape_type && shape,
inner_strides_type && strides )
+ 		+inlineexplicit
+
+ +

Allocates an xarray_container by moving specified data, shape and strides.

+
Parameters
+ + + + +
storagethe data for the xarray_container
shapethe shape of the xarray_container
stridesthe strides of the xarray_container
+
+
+ +

Definition at line 370 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [7/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (const value_type & t)
+ 		+inline
+
+ +

Allocates an xarray_container that holds a single element initialized to the specified value.

+
Parameters
+ + +
tthe value of the element
+
+
+ +

Definition at line 355 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [8/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (nested_initializer_list_t< value_type, 1 > t)
+ 		+inline
+
+ +

Allocates a one-dimensional xarray_container.

+
Parameters
+ + +
tthe elements of the xarray_container
+
+
+ +

Definition at line 391 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [9/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (nested_initializer_list_t< value_type, 2 > t)
+ 		+inline
+
+ +

Allocates a two-dimensional xarray_container.

+
Parameters
+ + +
tthe elements of the xarray_container
+
+
+ +

Definition at line 404 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [10/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (nested_initializer_list_t< value_type, 3 > t)
+ 		+inline
+
+ +

Allocates a three-dimensional xarray_container.

+
Parameters
+ + +
tthe elements of the xarray_container
+
+
+ +

Definition at line 417 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [11/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (nested_initializer_list_t< value_type, 4 > t)
+ 		+inline
+
+ +

Allocates a four-dimensional xarray_container.

+
Parameters
+ + +
tthe elements of the xarray_container
+
+
+ +

Definition at line 430 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [12/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (nested_initializer_list_t< value_type, 5 > t)
+ 		+inline
+
+ +

Allocates a five-dimensional xarray_container.

+
Parameters
+ + +
tthe elements of the xarray_container
+
+
+ +

Definition at line 443 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [13/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<std::size_t N>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (xtensor_container< EC, N, L, Tag > && rhs)
+ 		+inlineexplicit
+
+ +

Definition at line 467 of file xarray.hpp.

+ +
+
+ +

◆ xarray_container() [14/14]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
xt::xarray_container< EC, L, SC, Tag >::xarray_container (const xexpression< E > & e)
+ 		+inline
+
+ +

The extended copy constructor.

+ +

Definition at line 500 of file xarray.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ from_shape()

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<class S>
+ + + + + +
+ + + + + + + +
xarray_container< EC, L, SC, Tag > xt::xarray_container< EC, L, SC, Tag >::from_shape (S && s)
+ 		+inline
+
+ +

Allocates and returns an xarray_container with the specified shape.

+
Parameters
+ + +
sthe shape of the xarray_container
+
+
+ +

Definition at line 459 of file xarray.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xarray_container< EC, L, SC, Tag >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 517 of file xarray.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+
+template<std::size_t N>
+ + + + + +
+ + + + + + + +
xarray_container< EC, L, SC, Tag > & xt::xarray_container< EC, L, SC, Tag >::operator= (xtensor_container< EC, N, L, Tag > && rhs)
+ 		+inline
+
+ +

Definition at line 481 of file xarray.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xcontainer< xarray_container< EC, L, SC, Tag > >

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + +
friend class xcontainer< xarray_container< EC, L, SC, Tag > >
+ 		+friend
+
+ +

Definition at line 149 of file xarray.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ rank

+ +
+
+
+template<class EC, layout_type L, class SC, class Tag>
+ + + + + +
+ + + + +
std::size_t xt::xarray_container< EC, L, SC, Tag >::rank = SIZE_MAX
+ 		+staticconstexpr
+
+ +

Definition at line 106 of file xarray.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xarray.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xarray__container.js b/classxt_1_1xarray__container.js new file mode 100644 index 000000000..5725aa586 --- /dev/null +++ b/classxt_1_1xarray__container.js @@ -0,0 +1,18 @@ +var classxt_1_1xarray__container = +[ + [ "xarray_container", "classxt_1_1xarray__container.html#ae5c1e535231ddffdb7783d1445ffd66d", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a6b738f9e83ff453355414de037099d8c", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a72aad798502aefff1285aa6f46941e9c", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a0ca205f5f86d10d73b87b1d3ea7e6297", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a020df69d60ce91531bc3cf31af0b97ce", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a9e8b9a74e75fd76352d23346fa69a5c6", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a77e6553e8d27386c45f4fe7e80017e5c", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a9cd19d110d8063589c6f6c08a44af6ad", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a23f21da84072d9319fc8c826d98fb1de", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#aa7107f45d9ee3d9bb7a4a65f7c240edb", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#aaac4e823fd41ff9e9801a3cd8b1b5f6c", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#a44069c72b35f79263d7e24b6de2c4262", null ], + [ "xarray_container", "classxt_1_1xarray__container.html#aad2ebb4b2fa3a2a3a33a8a57b6bfe60a", null ], + [ "from_shape", "classxt_1_1xarray__container.html#ab23fb8ed1e93061e427ef9da391336a0", null ], + [ "operator=", "classxt_1_1xarray__container.html#ac47c631a33e292371fab8acff451f269", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xarray__container.png b/classxt_1_1xarray__container.png new file mode 100644 index 000000000..850ecd262 Binary files /dev/null and b/classxt_1_1xarray__container.png differ diff --git a/classxt_1_1xassign__traits-members.html b/classxt_1_1xassign__traits-members.html new file mode 100644 index 000000000..cae56c841 --- /dev/null +++ b/classxt_1_1xassign__traits-members.html @@ -0,0 +1,128 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xassign_traits< E1, E2 > Member List
+
+
+ +

This is the complete list of members for xt::xassign_traits< E1, E2 >, including all inherited members.

+ + + + + + + + + +
e2_requested_value_type typedef (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >
linear_assign(const E1 &e1, const E2 &e2, bool trivial) (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >inlinestatic
requested_value_type typedef (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >
simd_assign() (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >inlinestatic
simd_linear_assign() (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >inlinestatic
simd_linear_assign(const E1 &e1, const E2 &e2) (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >inlinestatic
simd_strided_assign() (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >inlinestatic
strided_assign() (defined in xt::xassign_traits< E1, E2 >)xt::xassign_traits< E1, E2 >inlinestatic
+
+ + + + diff --git a/classxt_1_1xassign__traits.html b/classxt_1_1xassign__traits.html new file mode 100644 index 000000000..8075de0bf --- /dev/null +++ b/classxt_1_1xassign__traits.html @@ -0,0 +1,379 @@ + + + + + + + +xtensor: xt::xassign_traits< E1, E2 > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Static Public Member Functions | +List of all members
+
xt::xassign_traits< E1, E2 > Class Template Reference
+
+
+ + + + + + +

+Public Types

using e2_requested_value_type
 
using requested_value_type = detail::conditional_promote_to_complex_t<e1_value_type, e2_requested_value_type>
 
+ + + + + + + + + + + + + +

+Static Public Member Functions

static constexpr bool simd_assign ()
 
static constexpr bool linear_assign (const E1 &e1, const E2 &e2, bool trivial)
 
static constexpr bool strided_assign ()
 
static constexpr bool simd_linear_assign ()
 
static constexpr bool simd_strided_assign ()
 
static constexpr bool simd_linear_assign (const E1 &e1, const E2 &e2)
 
+

Detailed Description

+
template<class E1, class E2>
+class xt::xassign_traits< E1, E2 >
+

Definition at line 352 of file xassign.hpp.

+

Member Typedef Documentation

+ +

◆ e2_requested_value_type

+ +
+
+
+template<class E1, class E2>
+ + + + +
using xt::xassign_traits< E1, E2 >::e2_requested_value_type
+
+Initial value:
std::
+
conditional_t<is_bool<e2_value_type>::value, typename E2::bool_load_type, e2_value_type>
+
+

Definition at line 434 of file xassign.hpp.

+ +
+
+ +

◆ requested_value_type

+ +
+
+
+template<class E1, class E2>
+ + + + +
using xt::xassign_traits< E1, E2 >::requested_value_type = detail::conditional_promote_to_complex_t<e1_value_type, e2_requested_value_type>
+
+ +

Definition at line 436 of file xassign.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ linear_assign()

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + + + + + + +
static constexpr bool xt::xassign_traits< E1, E2 >::linear_assign (const E1 & e1,
const E2 & e2,
bool trivial )
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 409 of file xassign.hpp.

+ +
+
+ +

◆ simd_assign()

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + +
static constexpr bool xt::xassign_traits< E1, E2 >::simd_assign ()
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 404 of file xassign.hpp.

+ +
+
+ +

◆ simd_linear_assign() [1/2]

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + +
static constexpr bool xt::xassign_traits< E1, E2 >::simd_linear_assign ()
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 419 of file xassign.hpp.

+ +
+
+ +

◆ simd_linear_assign() [2/2]

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + +
static constexpr bool xt::xassign_traits< E1, E2 >::simd_linear_assign (const E1 & e1,
const E2 & e2 )
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 429 of file xassign.hpp.

+ +
+
+ +

◆ simd_strided_assign()

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + +
static constexpr bool xt::xassign_traits< E1, E2 >::simd_strided_assign ()
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 424 of file xassign.hpp.

+ +
+
+ +

◆ strided_assign()

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + +
static constexpr bool xt::xassign_traits< E1, E2 >::strided_assign ()
+ 		+inlinestaticconstexpr
+
+ +

Definition at line 414 of file xassign.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xaxis__iterator-members.html b/classxt_1_1xaxis__iterator-members.html new file mode 100644 index 000000000..f6cb42e7c --- /dev/null +++ b/classxt_1_1xaxis__iterator-members.html @@ -0,0 +1,136 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xaxis_iterator< CT > Member List
+
+
+ +

This is the complete list of members for xt::xaxis_iterator< CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
equal(const self_type &rhs) constxt::xaxis_iterator< CT >inline
iterator_category typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
operator*() constxt::xaxis_iterator< CT >inline
operator++()xt::xaxis_iterator< CT >inline
operator++(int)xt::xaxis_iterator< CT >inline
operator->() constxt::xaxis_iterator< CT >inline
pointer typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
reference typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
self_type typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
shape_type typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
size_type typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
value_type typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
xaxis_iterator(CTA &&e, size_type axis)xt::xaxis_iterator< CT >inline
xaxis_iterator(CTA &&e, size_type axis, size_type index, size_type offset)xt::xaxis_iterator< CT >inline
xexpression_type typedef (defined in xt::xaxis_iterator< CT >)xt::xaxis_iterator< CT >
+
+ + + + diff --git a/classxt_1_1xaxis__iterator.html b/classxt_1_1xaxis__iterator.html new file mode 100644 index 000000000..ff3a3728c --- /dev/null +++ b/classxt_1_1xaxis__iterator.html @@ -0,0 +1,621 @@ + + + + + + + +xtensor: xt::xaxis_iterator< CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xaxis_iterator< CT > Class Template Reference
+
+
+ +

Class for iteration over (N-1)-dimensional slices, where N is the dimension of the underlying expression. + More...

+ +

#include <xaxis_iterator.hpp>

+ + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xaxis_iterator<CT>
 
using xexpression_type = std::decay_t<CT>
 
using size_type = typename xexpression_type::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using shape_type = typename xexpression_type::shape_type
 
using value_type = xstrided_view<CT, shape_type>
 
using reference = std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>
 
using pointer = xtl::xclosure_pointer<std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>>
 
using iterator_category = std::forward_iterator_tag
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors
template<class CTA>
 xaxis_iterator (CTA &&e, size_type axis)
 Constructs an xaxis_iterator.
 
template<class CTA>
 xaxis_iterator (CTA &&e, size_type axis, size_type index, size_type offset)
 Constructs an xaxis_iterator starting at specified index and offset.
 
Increment
self_type & operator++ ()
 Increments the iterator to the next position and returns it.
 
self_type operator++ (int)
 Makes a copy of the iterator, increments it to the next position, and returns the copy.
 
Reference
reference operator* () const
 Returns the strided view at the current iteration position.
 
pointer operator-> () const
 Returns a pointer to the strided view at the current iteration position.
 
bool equal (const self_type &rhs) const
 Checks equality of the xaxis_slice_iterator and rhs.
 
+

Detailed Description

+
template<class CT>
+class xt::xaxis_iterator< CT >

Class for iteration over (N-1)-dimensional slices, where N is the dimension of the underlying expression.

+

If N is the number of dimensions of an expression, the xaxis_iterator iterates over (N-1)-dimensional slices oriented along the specified axis.

+
Template Parameters
+ + +
CTthe closure type of the xexpression
+
+
+ +

Definition at line 33 of file xaxis_iterator.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 41 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::iterator_category = std::forward_iterator_tag
+
+ +

Definition at line 47 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::pointer = xtl::xclosure_pointer<std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>>
+
+ +

Definition at line 45 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::reference = std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>
+
+ +

Definition at line 44 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::self_type = xaxis_iterator<CT>
+
+ +

Definition at line 37 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::shape_type = typename xexpression_type::shape_type
+
+ +

Definition at line 42 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::size_type = typename xexpression_type::size_type
+
+ +

Definition at line 40 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::value_type = xstrided_view<CT, shape_type>
+
+ +

Definition at line 43 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_iterator< CT >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 39 of file xaxis_iterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xaxis_iterator() [1/2]

+ +
+
+
+template<class CT>
+
+template<class CTA>
+ + + + + +
+ + + + + + + + + + + +
xt::xaxis_iterator< CT >::xaxis_iterator (CTA && e,
size_type axis )
+ 		+inline
+
+ +

Constructs an xaxis_iterator.

+
Parameters
+ + + +
ethe expression to iterate over
axisthe axis to iterate over taking N-1 dimensional slices
+
+
+ +

Definition at line 149 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ xaxis_iterator() [2/2]

+ +
+
+
+template<class CT>
+
+template<class CTA>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xaxis_iterator< CT >::xaxis_iterator (CTA && e,
size_type axis,
size_type index,
size_type offset )
+ 		+inline
+
+ +

Constructs an xaxis_iterator starting at specified index and offset.

+
Parameters
+ + + + + +
ethe expression to iterate over
axisthe axis to iterate over taking N-1 dimensional slices
indexthe starting index for the iterator
offsetthe starting offset for the iterator
+
+
+ +

Definition at line 164 of file xaxis_iterator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ equal()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
bool xt::xaxis_iterator< CT >::equal (const self_type & rhs) const
+ 		+inline
+
+ +

Checks equality of the xaxis_slice_iterator and rhs.

+
Parameters
+ + +
rhsiterator to compare with
+
+
+
Returns
true if the iterators are equivalent, false otherwise
+ +

Definition at line 242 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_iterator< CT >::operator* () const
+ 		+inline
+
+ +

Returns the strided view at the current iteration position.

+
Returns
a strided_view
+ +

Definition at line 213 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ operator++() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_iterator< CT >::operator++ ()
+ 		+inline
+
+ +

Increments the iterator to the next position and returns it.

+ +

Definition at line 182 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ operator++() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_iterator< CT >::operator++ (int )
+ 		+inline
+
+ +

Makes a copy of the iterator, increments it to the next position, and returns the copy.

+ +

Definition at line 194 of file xaxis_iterator.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_iterator< CT >::operator-> () const
+ 		+inline
+
+ +

Returns a pointer to the strided view at the current iteration position.

+
Returns
a pointer to a strided_view
+ +

Definition at line 224 of file xaxis_iterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xaxis__iterator.js b/classxt_1_1xaxis__iterator.js new file mode 100644 index 000000000..2965d7d03 --- /dev/null +++ b/classxt_1_1xaxis__iterator.js @@ -0,0 +1,10 @@ +var classxt_1_1xaxis__iterator = +[ + [ "xaxis_iterator", "classxt_1_1xaxis__iterator.html#a27574105e56e37a1986b8cb5a141a9ea", null ], + [ "xaxis_iterator", "classxt_1_1xaxis__iterator.html#aacf91594c4a97e2811691d5678a95e4e", null ], + [ "equal", "classxt_1_1xaxis__iterator.html#ab4e285d56b758b9c9f95d4c63f39093c", null ], + [ "operator*", "classxt_1_1xaxis__iterator.html#a150d158b5c15befbed66477acf3ea890", null ], + [ "operator++", "classxt_1_1xaxis__iterator.html#aa6a381b3f4e53a2b7b2a0385e2675b65", null ], + [ "operator++", "classxt_1_1xaxis__iterator.html#af118e8a489b3ee60287f8848a42c3ec8", null ], + [ "operator->", "classxt_1_1xaxis__iterator.html#a265baea7c543cabd5f9b074d39371310", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xaxis__slice__iterator-members.html b/classxt_1_1xaxis__slice__iterator-members.html new file mode 100644 index 000000000..e2dcbdd73 --- /dev/null +++ b/classxt_1_1xaxis__slice__iterator-members.html @@ -0,0 +1,137 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xaxis_slice_iterator< CT > Member List
+
+
+ +

This is the complete list of members for xt::xaxis_slice_iterator< CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
equal(const self_type &rhs) constxt::xaxis_slice_iterator< CT >inline
iterator_category typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
operator*() constxt::xaxis_slice_iterator< CT >inline
operator++()xt::xaxis_slice_iterator< CT >inline
operator++(int)xt::xaxis_slice_iterator< CT >inline
operator->() constxt::xaxis_slice_iterator< CT >inline
pointer typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
reference typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
self_type typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
shape_type typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
size_type typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
strides_type typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
value_type typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
xaxis_slice_iterator(CTA &&e, size_type axis)xt::xaxis_slice_iterator< CT >inline
xaxis_slice_iterator(CTA &&e, size_type axis, size_type index, size_type offset)xt::xaxis_slice_iterator< CT >inline
xexpression_type typedef (defined in xt::xaxis_slice_iterator< CT >)xt::xaxis_slice_iterator< CT >
+
+ + + + diff --git a/classxt_1_1xaxis__slice__iterator.html b/classxt_1_1xaxis__slice__iterator.html new file mode 100644 index 000000000..a4792014f --- /dev/null +++ b/classxt_1_1xaxis__slice__iterator.html @@ -0,0 +1,635 @@ + + + + + + + +xtensor: xt::xaxis_slice_iterator< CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xaxis_slice_iterator< CT > Class Template Reference
+
+
+ +

Class for iteration over one-dimensional slices. + More...

+ +

#include <xaxis_slice_iterator.hpp>

+ + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xaxis_slice_iterator<CT>
 
using xexpression_type = std::decay_t<CT>
 
using size_type = typename xexpression_type::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using shape_type = typename xexpression_type::shape_type
 
using strides_type = typename xexpression_type::strides_type
 
using value_type = xstrided_view<CT, shape_type>
 
using reference = std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>
 
using pointer = xtl::xclosure_pointer<std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>>
 
using iterator_category = std::forward_iterator_tag
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Constructors
template<class CTA>
 xaxis_slice_iterator (CTA &&e, size_type axis)
 Constructs an xaxis_slice_iterator.
 
template<class CTA>
 xaxis_slice_iterator (CTA &&e, size_type axis, size_type index, size_type offset)
 Constructs an xaxis_slice_iterator starting at specified index and offset.
 
Increment
self_type & operator++ ()
 Increments the iterator to the next position and returns it.
 
self_type operator++ (int)
 Makes a copy of the iterator, increments it to the next position, and returns the copy.
 
Reference
reference operator* () const
 Returns the strided view at the current iteration position.
 
pointer operator-> () const
 Returns a pointer to the strided view at the current iteration position.
 
bool equal (const self_type &rhs) const
 Checks equality of the xaxis_slice_iterator and rhs.
 
+

Detailed Description

+
template<class CT>
+class xt::xaxis_slice_iterator< CT >

Class for iteration over one-dimensional slices.

+

The xaxis_slice_iterator iterates over one-dimensional slices oriented along the specified axis

+
Template Parameters
+ + +
CTthe closure type of the xexpression
+
+
+ +

Definition at line 28 of file xaxis_slice_iterator.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 36 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::iterator_category = std::forward_iterator_tag
+
+ +

Definition at line 43 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::pointer = xtl::xclosure_pointer<std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>>
+
+ +

Definition at line 41 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::reference = std::remove_reference_t<xtl::apply_cv_t<CT, value_type>>
+
+ +

Definition at line 40 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::self_type = xaxis_slice_iterator<CT>
+
+ +

Definition at line 32 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::shape_type = typename xexpression_type::shape_type
+
+ +

Definition at line 37 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::size_type = typename xexpression_type::size_type
+
+ +

Definition at line 35 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::strides_type = typename xexpression_type::strides_type
+
+ +

Definition at line 38 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::value_type = xstrided_view<CT, shape_type>
+
+ +

Definition at line 39 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xaxis_slice_iterator< CT >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 34 of file xaxis_slice_iterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xaxis_slice_iterator() [1/2]

+ +
+
+
+template<class CT>
+
+template<class CTA>
+ + + + + +
+ + + + + + + + + + + +
xt::xaxis_slice_iterator< CT >::xaxis_slice_iterator (CTA && e,
size_type axis )
+ 		+inline
+
+ +

Constructs an xaxis_slice_iterator.

+
Parameters
+ + + +
ethe expression to iterate over
axisthe axis to iterate over taking one dimensional slices
+
+
+ +

Definition at line 123 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ xaxis_slice_iterator() [2/2]

+ +
+
+
+template<class CT>
+
+template<class CTA>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xaxis_slice_iterator< CT >::xaxis_slice_iterator (CTA && e,
size_type axis,
size_type index,
size_type offset )
+ 		+inline
+
+ +

Constructs an xaxis_slice_iterator starting at specified index and offset.

+
Parameters
+ + + + + +
ethe expression to iterate over
axisthe axis to iterate over taking one dimensional slices
indexthe starting index for the iterator
offsetthe starting offset for the iterator
+
+
+ +

Definition at line 138 of file xaxis_slice_iterator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ equal()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
bool xt::xaxis_slice_iterator< CT >::equal (const self_type & rhs) const
+ 		+inline
+
+ +

Checks equality of the xaxis_slice_iterator and rhs.

+
Returns
true if the iterators are equivalent, false otherwise
+ +

Definition at line 255 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_slice_iterator< CT >::operator* () const
+ 		+inline
+
+ +

Returns the strided view at the current iteration position.

+
Returns
a strided_view
+ +

Definition at line 227 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ operator++() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_slice_iterator< CT >::operator++ ()
+ 		+inline
+
+ +

Increments the iterator to the next position and returns it.

+ +

Definition at line 190 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ operator++() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_slice_iterator< CT >::operator++ (int )
+ 		+inline
+
+ +

Makes a copy of the iterator, increments it to the next position, and returns the copy.

+ +

Definition at line 208 of file xaxis_slice_iterator.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xaxis_slice_iterator< CT >::operator-> () const
+ 		+inline
+
+ +

Returns a pointer to the strided view at the current iteration position.

+
Returns
a pointer to a strided_view
+ +

Definition at line 238 of file xaxis_slice_iterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xaxis__slice__iterator.js b/classxt_1_1xaxis__slice__iterator.js new file mode 100644 index 000000000..698a1c581 --- /dev/null +++ b/classxt_1_1xaxis__slice__iterator.js @@ -0,0 +1,10 @@ +var classxt_1_1xaxis__slice__iterator = +[ + [ "xaxis_slice_iterator", "classxt_1_1xaxis__slice__iterator.html#af741f5bf73967431bc0aba068da8fada", null ], + [ "xaxis_slice_iterator", "classxt_1_1xaxis__slice__iterator.html#a0817357b924fd7c356a2a2f252fcb323", null ], + [ "equal", "classxt_1_1xaxis__slice__iterator.html#abb5ffe172da06056aa31e3f18b821b88", null ], + [ "operator*", "classxt_1_1xaxis__slice__iterator.html#a8250c9f5f36a93e0e3ff856f9bd6ab2b", null ], + [ "operator++", "classxt_1_1xaxis__slice__iterator.html#a6712f741da8a93fa4c0785888d008608", null ], + [ "operator++", "classxt_1_1xaxis__slice__iterator.html#a58c7c5d0bec327a8fb5d1f63b6122822", null ], + [ "operator->", "classxt_1_1xaxis__slice__iterator.html#a98d80126e4d0c78658fabe73303913bb", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xblockwise__reducer-members.html b/classxt_1_1xblockwise__reducer-members.html new file mode 100644 index 000000000..515431a95 --- /dev/null +++ b/classxt_1_1xblockwise__reducer-members.html @@ -0,0 +1,140 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xblockwise_reducer< CT, F, X, O > Member List
+
+
+ +

This is the complete list of members for xt::xblockwise_reducer< CT, F, X, O >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + +
assign_to(R &result) const (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >inline
axes() const (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >inline
axes_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
chunk_shape() const (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >inline
chunk_shape_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
compute_input_chunk_range(CI &result_chunk_iter) const -> input_chunk_range_type (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
dimension() const (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >inline
functor_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
input_chunk_index_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
input_grid_strides typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
input_shape() const (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >inline
input_shape_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
keep_dims typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
raw_options_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
self_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
shape() const (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >inline
shape_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
value_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
xblockwise_reducer(E &&e, BS &&block_shape, XX &&axes, OO &&options, FF &&functor) (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
xexpression_type typedef (defined in xt::xblockwise_reducer< CT, F, X, O >)xt::xblockwise_reducer< CT, F, X, O >
+
+ + + + diff --git a/classxt_1_1xblockwise__reducer.html b/classxt_1_1xblockwise__reducer.html new file mode 100644 index 000000000..6c9d8e6f3 --- /dev/null +++ b/classxt_1_1xblockwise__reducer.html @@ -0,0 +1,640 @@ + + + + + + + +xtensor: xt::xblockwise_reducer< CT, F, X, O > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xblockwise_reducer< CT, F, X, O > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xblockwise_reducer<CT, F, X, O>
 
using raw_options_type = std::decay_t<O>
 
using keep_dims = xtl::mpl::contains<raw_options_type, xt::keep_dims_type>
 
using xexpression_type = std::decay_t<CT>
 
using shape_type = typename xreducer_shape_type<typename xexpression_type::shape_type, std::decay_t<X>, keep_dims>::type
 
using functor_type = F
 
using value_type = typename functor_type::value_type
 
using input_shape_type = typename xexpression_type::shape_type
 
using input_chunk_index_type = filter_fixed_shape_t<input_shape_type>
 
using input_grid_strides = filter_fixed_shape_t<input_shape_type>
 
using axes_type = X
 
using chunk_shape_type = filter_fixed_shape_t<shape_type>
 
+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class E, class BS, class XX, class OO, class FF>
 xblockwise_reducer (E &&e, BS &&block_shape, XX &&axes, OO &&options, FF &&functor)
 
const input_shape_type & input_shape () const
 
const axes_type & axes () const
 
std::size_t dimension () const
 
const shape_type & shape () const
 
const chunk_shape_type & chunk_shape () const
 
template<class R>
void assign_to (R &result) const
 
template<class CI>
auto compute_input_chunk_range (CI &result_chunk_iter) const -> input_chunk_range_type
 
+

Detailed Description

+
template<class CT, class F, class X, class O>
+class xt::xblockwise_reducer< CT, F, X, O >
+

Definition at line 15 of file xblockwise_reducer.hpp.

+

Member Typedef Documentation

+ +

◆ axes_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::axes_type = X
+
+ +

Definition at line 29 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ chunk_shape_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::chunk_shape_type = filter_fixed_shape_t<shape_type>
+
+ +

Definition at line 30 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::functor_type = F
+
+ +

Definition at line 24 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ input_chunk_index_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::input_chunk_index_type = filter_fixed_shape_t<input_shape_type>
+
+ +

Definition at line 27 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ input_grid_strides

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::input_grid_strides = filter_fixed_shape_t<input_shape_type>
+
+ +

Definition at line 28 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ input_shape_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::input_shape_type = typename xexpression_type::shape_type
+
+ +

Definition at line 26 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ keep_dims

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::keep_dims = xtl::mpl::contains<raw_options_type, xt::keep_dims_type>
+
+ +

Definition at line 21 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ raw_options_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::raw_options_type = std::decay_t<O>
+
+ +

Definition at line 20 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::self_type = xblockwise_reducer<CT, F, X, O>
+
+ +

Definition at line 19 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::shape_type = typename xreducer_shape_type<typename xexpression_type::shape_type, std::decay_t<X>, keep_dims>::type
+
+ +

Definition at line 23 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::value_type = typename functor_type::value_type
+
+ +

Definition at line 25 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + +
using xt::xblockwise_reducer< CT, F, X, O >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 22 of file xblockwise_reducer.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xblockwise_reducer()

+ +
+
+
+template<class CT, class F, class X, class O>
+
+template<class E, class BS, class XX, class OO, class FF>
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
xt::xblockwise_reducer< CT, F, X, O >::xblockwise_reducer (E && e,
BS && block_shape,
XX && axes,
OO && options,
FF && functor )
+
+ +

Definition at line 77 of file xblockwise_reducer.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign_to()

+ +
+
+
+template<class CT, class F, class X, class O>
+
+template<class R>
+ + + + + +
+ + + + + + + +
void xt::xblockwise_reducer< CT, F, X, O >::assign_to (R & result) const
+ 		+inline
+
+ +

Definition at line 131 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ axes()

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::xblockwise_reducer< CT, F, X, O >::axes () const
+ 		+inline
+
+ +

Definition at line 106 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ chunk_shape()

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::xblockwise_reducer< CT, F, X, O >::chunk_shape () const
+ 		+inline
+
+ +

Definition at line 124 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ compute_input_chunk_range()

+ +
+
+
+template<class CT, class F, class X, class O>
+
+template<class CI>
+ + + + + + + +
auto xt::xblockwise_reducer< CT, F, X, O >::compute_input_chunk_range (CI & result_chunk_iter) const -> input_chunk_range_type +
+
+ +

Definition at line 189 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + + +
+ + + + + + + +
std::size_t xt::xblockwise_reducer< CT, F, X, O >::dimension () const
+ 		+inline
+
+ +

Definition at line 112 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ input_shape()

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::xblockwise_reducer< CT, F, X, O >::input_shape () const
+ 		+inline
+
+ +

Definition at line 100 of file xblockwise_reducer.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class CT, class F, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::xblockwise_reducer< CT, F, X, O >::shape () const
+ 		+inline
+
+ +

Definition at line 118 of file xblockwise_reducer.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xbounded__iterator-members.html b/classxt_1_1xbounded__iterator-members.html new file mode 100644 index 000000000..2dc091d93 --- /dev/null +++ b/classxt_1_1xbounded__iterator-members.html @@ -0,0 +1,138 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xbounded_iterator< It, BIt > Member List
+
+
+ +

This is the complete list of members for xt::xbounded_iterator< It, BIt >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
bound_iterator_type typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
difference_type typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
equal(const self_type &rhs) const (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
iterator_category typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
less_than(const self_type &rhs) const (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
operator*() const (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
operator++() (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
operator+=(difference_type n) (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
operator-(const self_type &rhs) const (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
operator--() (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
operator-=(difference_type n) (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >inline
pointer typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
reference typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
self_type typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
subiterator_type typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
value_type typedef (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
xbounded_iterator()=default (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
xbounded_iterator(It it, BIt bound_it) (defined in xt::xbounded_iterator< It, BIt >)xt::xbounded_iterator< It, BIt >
+
+ + + + diff --git a/classxt_1_1xbounded__iterator.html b/classxt_1_1xbounded__iterator.html new file mode 100644 index 000000000..c76495e74 --- /dev/null +++ b/classxt_1_1xbounded__iterator.html @@ -0,0 +1,580 @@ + + + + + + + +xtensor: xt::xbounded_iterator< It, BIt > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xbounded_iterator< It, BIt > Class Template Reference
+
+
+
+Inheritance diagram for xt::xbounded_iterator< It, BIt >:
+
+
+ +
+ + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xbounded_iterator<It, BIt>
 
using subiterator_type = It
 
using bound_iterator_type = BIt
 
using value_type = typename std::iterator_traits<It>::value_type
 
using reference = typename std::iterator_traits<It>::reference
 
using pointer = typename std::iterator_traits<It>::pointer
 
using difference_type = typename std::iterator_traits<It>::difference_type
 
using iterator_category = std::random_access_iterator_tag
 
+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xbounded_iterator (It it, BIt bound_it)
 
self_type & operator++ ()
 
self_type & operator-- ()
 
self_type & operator+= (difference_type n)
 
self_type & operator-= (difference_type n)
 
difference_type operator- (const self_type &rhs) const
 
value_type operator* () const
 
bool equal (const self_type &rhs) const
 
bool less_than (const self_type &rhs) const
 
+

Detailed Description

+
template<class It, class BIt>
+class xt::xbounded_iterator< It, BIt >
+

Definition at line 355 of file xiterator.hpp.

+

Member Typedef Documentation

+ +

◆ bound_iterator_type

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::bound_iterator_type = BIt
+
+ +

Definition at line 367 of file xiterator.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::difference_type = typename std::iterator_traits<It>::difference_type
+
+ +

Definition at line 371 of file xiterator.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::iterator_category = std::random_access_iterator_tag
+
+ +

Definition at line 372 of file xiterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::pointer = typename std::iterator_traits<It>::pointer
+
+ +

Definition at line 370 of file xiterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::reference = typename std::iterator_traits<It>::reference
+
+ +

Definition at line 369 of file xiterator.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::self_type = xbounded_iterator<It, BIt>
+
+ +

Definition at line 364 of file xiterator.hpp.

+ +
+
+ +

◆ subiterator_type

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::subiterator_type = It
+
+ +

Definition at line 366 of file xiterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class It, class BIt>
+ + + + +
using xt::xbounded_iterator< It, BIt >::value_type = typename std::iterator_traits<It>::value_type
+
+ +

Definition at line 368 of file xiterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xbounded_iterator()

+ +
+
+
+template<class It, class BIt>
+ + + + + + + + + + + +
xt::xbounded_iterator< It, BIt >::xbounded_iterator (It it,
BIt bound_it )
+
+ +

Definition at line 1214 of file xiterator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ equal()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
bool xt::xbounded_iterator< It, BIt >::equal (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 1266 of file xiterator.hpp.

+ +
+
+ +

◆ less_than()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
bool xt::xbounded_iterator< It, BIt >::less_than (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 1272 of file xiterator.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
auto xt::xbounded_iterator< It, BIt >::operator* () const
+ 		+inline
+
+ +

Definition at line 1259 of file xiterator.hpp.

+ +
+
+ +

◆ operator++()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
auto xt::xbounded_iterator< It, BIt >::operator++ ()
+ 		+inline
+
+ +

Definition at line 1221 of file xiterator.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
auto xt::xbounded_iterator< It, BIt >::operator+= (difference_type n)
+ 		+inline
+
+ +

Definition at line 1237 of file xiterator.hpp.

+ +
+
+ +

◆ operator-()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
auto xt::xbounded_iterator< It, BIt >::operator- (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 1253 of file xiterator.hpp.

+ +
+
+ +

◆ operator--()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
auto xt::xbounded_iterator< It, BIt >::operator-- ()
+ 		+inline
+
+ +

Definition at line 1229 of file xiterator.hpp.

+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<class It, class BIt>
+ + + + + +
+ + + + + + + +
auto xt::xbounded_iterator< It, BIt >::operator-= (difference_type n)
+ 		+inline
+
+ +

Definition at line 1245 of file xiterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xiterator.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xbounded__iterator.png b/classxt_1_1xbounded__iterator.png new file mode 100644 index 000000000..94047c442 Binary files /dev/null and b/classxt_1_1xbounded__iterator.png differ diff --git a/classxt_1_1xbroadcast-members.html b/classxt_1_1xbroadcast-members.html new file mode 100644 index 000000000..078a161b5 --- /dev/null +++ b/classxt_1_1xbroadcast-members.html @@ -0,0 +1,211 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xbroadcast< CT, X > Member List
+
+
+ +

This is the complete list of members for xt::xbroadcast< CT, X >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
assign_to(xexpression< E > &e) const (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >inline
at(Args... args) const -> const_referencext::xconst_accessible< xbroadcast< CT, X > >inline
at(Args... args) const -> const_referencext::xconst_accessible< xbroadcast< CT, X > >inline
back() constxt::xconst_accessible< xbroadcast< CT, X > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
bool_load_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xbroadcast< CT, X >inline
build_broadcast(E &&e) const (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
build_broadcast(E &&e) const -> rebind_t< E > (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
const_pointer typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
const_reference typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
const_stepper typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
contiguous_layout (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >static
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
xt::derived_cast() &noexceptxt::xexpression< xbroadcast< CT, X > >inline
xt::derived_cast() const &noexceptxt::xexpression< xbroadcast< CT, X > >inline
xt::derived_cast() &&noexceptxt::xexpression< xbroadcast< CT, X > >inline
difference_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
dimension() const noexceptxt::xconst_accessible< xbroadcast< CT, X > >inline
element(It first, It last) const (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
element(It, It last) const -> const_referencext::xbroadcast< CT, X >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
expression() const noexceptxt::xbroadcast< CT, X >inline
expression_tag typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
extension_base typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
front() constxt::xconst_accessible< xbroadcast< CT, X > >inline
has_linear_assign(const S &strides) const noexceptxt::xbroadcast< CT, X >inline
in_bounds(Args... args) constxt::xconst_accessible< xbroadcast< CT, X > >inline
inner_shape_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
inner_types typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
is_contiguous() const noexcept (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >inline
iterable_base typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
layout() const noexceptxt::xbroadcast< CT, X >inline
operator()(Args... args) const (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
operator()(Args... args) const -> const_referencext::xbroadcast< CT, X >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xconst_accessible< xbroadcast< CT, X > >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xconst_accessible< xbroadcast< CT, X > >inline
periodic(Args... args) const -> const_referencext::xconst_accessible< xbroadcast< CT, X > >inline
periodic(Args... args) const -> const_referencext::xconst_accessible< xbroadcast< CT, X > >inline
pointer typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
rebind_t typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
reference typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xbroadcast< CT, X > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xbroadcast< CT, X > >inline
self_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
shape() const noexceptxt::xbroadcast< CT, X >inline
shape(size_type index) constxt::xbroadcast< CT, X >
xt::xconst_accessible< xbroadcast< CT, X > >::shape(size_type index) constxt::xconst_accessible< xbroadcast< CT, X > >inline
shape_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
size() const noexcept(noexcept(derived_cast().shape()))xt::xbroadcast< CT, X >
size_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
static_layout (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >static
stepper typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
stepper_begin(const S &shape) const noexcept (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >inline
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >inline
unchecked(Args... args) const (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
unchecked(Args... args) const -> const_referencext::xbroadcast< CT, X >inline
value_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
xbroadcast(CTA &&e, const S &s)xt::xbroadcast< CT, X >inline
xbroadcast(CTA &&e, shape_type &&s)xt::xbroadcast< CT, X >inline
xexpression_type typedef (defined in xt::xbroadcast< CT, X >)xt::xbroadcast< CT, X >
+
+ + + + diff --git a/classxt_1_1xbroadcast.html b/classxt_1_1xbroadcast.html new file mode 100644 index 000000000..b7d08d01d --- /dev/null +++ b/classxt_1_1xbroadcast.html @@ -0,0 +1,1606 @@ + + + + + + + +xtensor: xt::xbroadcast< CT, X > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::xbroadcast< CT, X > Class Template Reference
+
+
+ +

Broadcasted xexpression to a specified shape. + More...

+ +

#include <xbroadcast.hpp>

+
+Inheritance diagram for xt::xbroadcast< CT, X >:
+
+
+ + +xt::xsharable_expression< xbroadcast< CT, X > > +xt::xconst_iterable< xbroadcast< CT, X > > +xt::xconst_accessible< xbroadcast< CT, X > > +xt::xexpression< xbroadcast< CT, X > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xbroadcast<CT, X>
 
using xexpression_type = std::decay_t<CT>
 
using accessible_base = xconst_accessible<self_type>
 
using extension_base = extension::xbroadcast_base_t<CT, X>
 
using expression_tag = typename extension_base::expression_tag
 
using inner_types = xcontainer_inner_types<self_type>
 
using value_type = typename xexpression_type::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = typename xexpression_type::const_pointer
 
using const_pointer = typename xexpression_type::const_pointer
 
using size_type = typename inner_types::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using iterable_base = xconst_iterable<self_type>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using shape_type = inner_shape_type
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using bool_load_type = typename xexpression_type::bool_load_type
 
template<class E>
using rebind_t = xbroadcast<E, X>
 
- Public Types inherited from xt::xexpression< xbroadcast< CT, X > >
using derived_type
 
- Public Types inherited from xt::xconst_iterable< xbroadcast< CT, X > >
using derived_type
 
using iterable_types
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xconst_accessible< xbroadcast< CT, X > >
using derived_type
 
using inner_types
 
using reference
 
using const_reference
 
using size_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+template<class E>
rebind_t< E > build_broadcast (E &&e) const
 
+size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
+size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
Constructor
template<class CTA, class S>
 xbroadcast (CTA &&e, const S &s)
 Constructs an xbroadcast expression broadcasting the specified xexpression to the given shape.
 
template<class CTA>
 xbroadcast (CTA &&e, shape_type &&s)
 Constructs an xbroadcast expression broadcasting the specified xexpression to the given shape.
 
Size and shape
const inner_shape_type & shape () const noexcept
 Returns the shape of the expression.
 
layout_type layout () const noexcept
 Returns the layout_type of the expression.
 
bool is_contiguous () const noexcept
 
Data
const xexpression_type & expression () const noexcept
 Returns a constant reference to the underlying expression of the broadcast expression.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class It>
auto element (It, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
Broadcasting
template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the function to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xbroadcast can be linearly assigned to an expression with the specified strides.
 
template<class E, xscalar_concept XCT = CT>
void assign_to (xexpression< E > &e) const
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
template<class E>
auto build_broadcast (E &&e) const -> rebind_t< E >
 
- Public Member Functions inherited from xt::xexpression< xbroadcast< CT, X > >
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
- Public Member Functions inherited from xt::xconst_iterable< xbroadcast< CT, X > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_layout_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_layout_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xconst_accessible< xbroadcast< CT, X > >
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+const_reference at (Args... args) const
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
+const_reference periodic (Args... args) const
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = layout_type::dynamic
 
static constexpr bool contiguous_layout = false
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xsharable_expression< xbroadcast< CT, X > >
+ xsharable_expression (const xsharable_expression &)=default
 
+ xsharable_expression (xsharable_expression &&)=default
 
+xsharable_expression & operator= (const xsharable_expression &)=default
 
+xsharable_expression & operator= (xsharable_expression &&)=default
 
- Protected Member Functions inherited from xt::xexpression< xbroadcast< CT, X > >
+ xexpression (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (const xexpression &)=default
 
+xexpression & operator= (xexpression &&)=default
 
const inner_shape_type & get_shape () const
 
- Protected Member Functions inherited from xt::xconst_accessible< xbroadcast< CT, X > >
+ xconst_accessible (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
+

Detailed Description

+
template<class CT, class X>
+class xt::xbroadcast< CT, X >

Broadcasted xexpression to a specified shape.

+

The xbroadcast class implements the broadcasting of an xexpression to a specified shape. xbroadcast is not meant to be used directly, but only with the broadcast helper functions.

+
Template Parameters
+ + + +
CTthe closure type of the xexpression to broadcast
Xthe type of the specified shape.
+
+
+
See also
broadcast
+ +

Definition at line 158 of file xbroadcast.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::accessible_base = xconst_accessible<self_type>
+
+ +

Definition at line 167 of file xbroadcast.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::bool_load_type = typename xexpression_type::bool_load_type
+
+ +

Definition at line 187 of file xbroadcast.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::const_pointer = typename xexpression_type::const_pointer
+
+ +

Definition at line 176 of file xbroadcast.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 174 of file xbroadcast.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 185 of file xbroadcast.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 178 of file xbroadcast.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 169 of file xbroadcast.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::extension_base = extension::xbroadcast_base_t<CT, X>
+
+ +

Definition at line 168 of file xbroadcast.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 181 of file xbroadcast.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 171 of file xbroadcast.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::iterable_base = xconst_iterable<self_type>
+
+ +

Definition at line 180 of file xbroadcast.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::pointer = typename xexpression_type::const_pointer
+
+ +

Definition at line 175 of file xbroadcast.hpp.

+ +
+
+ +

◆ rebind_t

+ +
+
+
+template<class CT, class X>
+
+template<class E>
+ + + + +
using xt::xbroadcast< CT, X >::rebind_t = xbroadcast<E, X>
+
+ +

Definition at line 230 of file xbroadcast.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::reference = typename inner_types::reference
+
+ +

Definition at line 173 of file xbroadcast.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::self_type = xbroadcast<CT, X>
+
+ +

Definition at line 165 of file xbroadcast.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::shape_type = inner_shape_type
+
+ +

Definition at line 182 of file xbroadcast.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::size_type = typename inner_types::size_type
+
+ +

Definition at line 177 of file xbroadcast.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 184 of file xbroadcast.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::value_type = typename xexpression_type::value_type
+
+ +

Definition at line 172 of file xbroadcast.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT, class X>
+ + + + +
using xt::xbroadcast< CT, X >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 166 of file xbroadcast.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xbroadcast() [1/2]

+ +
+
+
+template<class CT, class X>
+
+template<class CTA, class S>
+ + + + + +
+ + + + + + + + + + + +
xt::xbroadcast< CT, X >::xbroadcast (CTA && e,
const S & s )
+ 		+inline
+
+ +

Constructs an xbroadcast expression broadcasting the specified xexpression to the given shape.

+
Parameters
+ + + +
ethe expression to broadcast
sthe shape to apply
+
+
+ +

Definition at line 288 of file xbroadcast.hpp.

+ +
+
+ +

◆ xbroadcast() [2/2]

+ +
+
+
+template<class CT, class X>
+
+template<class CTA>
+ + + + + +
+ + + + + + + + + + + +
xt::xbroadcast< CT, X >::xbroadcast (CTA && e,
shape_type && s )
+ 		+inline
+
+ +

Constructs an xbroadcast expression broadcasting the specified xexpression to the given shape.

+
Parameters
+ + + +
ethe expression to broadcast
sthe shape to apply
+
+
+ +

Definition at line 309 of file xbroadcast.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign_to()

+ +
+
+
+template<class CT, class X>
+
+template<class E, xscalar_concept XCT>
+ + + + + +
+ + + + + + + +
void xt::xbroadcast< CT, X >::assign_to (xexpression< E > & e) const
+ 		+inline
+
+ +

Definition at line 467 of file xbroadcast.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class CT, class X>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xbroadcast< CT, X >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the function to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 428 of file xbroadcast.hpp.

+ +
+
+ +

◆ build_broadcast()

+ +
+
+
+template<class CT, class X>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xbroadcast< CT, X >::build_broadcast (E && e) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 476 of file xbroadcast.hpp.

+ +
+
+ +

◆ element()

+ +
+
+
+template<class CT, class X>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xbroadcast< CT, X >::element (It ,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the function.
+
+
+ +

Definition at line 400 of file xbroadcast.hpp.

+ +
+
+ +

◆ expression()

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + + + + +
auto xt::xbroadcast< CT, X >::expression () const
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the underlying expression of the broadcast expression.

+ +

Definition at line 409 of file xbroadcast.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CT, class X>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xbroadcast< CT, X >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xbroadcast can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 440 of file xbroadcast.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + + + + +
bool xt::xbroadcast< CT, X >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 341 of file xbroadcast.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + + + + +
layout_type xt::xbroadcast< CT, X >::layout () const
+ 		+inlinenoexcept
+
+ +

Returns the layout_type of the expression.

+ +

Definition at line 335 of file xbroadcast.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class CT, class X>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xbroadcast< CT, X >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the function. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the expression.
+
+
+ +

Definition at line 360 of file xbroadcast.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + + + + +
auto xt::xbroadcast< CT, X >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the expression.

+ +

Definition at line 326 of file xbroadcast.hpp.

+ +
+
+ +

◆ stepper_begin()

+ +
+
+
+template<class CT, class X>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xbroadcast< CT, X >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 451 of file xbroadcast.hpp.

+ +
+
+ +

◆ stepper_end()

+ +
+
+
+template<class CT, class X>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xbroadcast< CT, X >::stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 459 of file xbroadcast.hpp.

+ +
+
+ +

◆ unchecked()

+ +
+
+
+template<class CT, class X>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xbroadcast< CT, X >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the expression, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 386 of file xbroadcast.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + +
bool xt::xbroadcast< CT, X >::contiguous_layout = false
+ 		+staticconstexpr
+
+ +

Definition at line 190 of file xbroadcast.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CT, class X>
+ + + + + +
+ + + + +
layout_type xt::xbroadcast< CT, X >::static_layout = layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 189 of file xbroadcast.hpp.

+ +
+
+
The documentation for this class was generated from the following files:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xmime.hpp
    • +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xbroadcast.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xbroadcast.js b/classxt_1_1xbroadcast.js new file mode 100644 index 000000000..69e608384 --- /dev/null +++ b/classxt_1_1xbroadcast.js @@ -0,0 +1,15 @@ +var classxt_1_1xbroadcast = +[ + [ "xbroadcast", "classxt_1_1xbroadcast.html#aebbad01548cd2a4f5955c20f813b6314", null ], + [ "xbroadcast", "classxt_1_1xbroadcast.html#ad96d515ec253f2745da1ccd7cbf44c97", null ], + [ "broadcast_shape", "classxt_1_1xbroadcast.html#ad91b61dbfe7d500131c6f001aa0461e6", null ], + [ "element", "classxt_1_1xbroadcast.html#a0c5eeee79d7da9ebbe4bab731e7bdbdf", null ], + [ "expression", "classxt_1_1xbroadcast.html#a11fafd46c5300907473db9afddfb5969", null ], + [ "has_linear_assign", "classxt_1_1xbroadcast.html#afa95389819f8e9168213041757730903", null ], + [ "layout", "classxt_1_1xbroadcast.html#aca1bb5d073d6fbbfec6e82cbc456cadd", null ], + [ "operator()", "classxt_1_1xbroadcast.html#afca42261ce09c53e109862b63ea8bf87", null ], + [ "shape", "classxt_1_1xbroadcast.html#ab55ff6c03aac9708dd319a0936a3fd18", null ], + [ "shape", "classxt_1_1xbroadcast.html#ae7b5c2b34c43d49a8f2f82bd80ef30eb", null ], + [ "size", "classxt_1_1xbroadcast.html#acf990ad65941e747a737622343bb43c2", null ], + [ "unchecked", "classxt_1_1xbroadcast.html#aecb99b5176966ab47f4dfe2b66385d56", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xbroadcast.png b/classxt_1_1xbroadcast.png new file mode 100644 index 000000000..3765e326d Binary files /dev/null and b/classxt_1_1xbroadcast.png differ diff --git a/classxt_1_1xbuffer__adaptor-members.html b/classxt_1_1xbuffer__adaptor-members.html new file mode 100644 index 000000000..331f17f22 --- /dev/null +++ b/classxt_1_1xbuffer__adaptor-members.html @@ -0,0 +1,144 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xbuffer_adaptor< CP, O, A > Member List
+
+
+ +

This is the complete list of members for xt::xbuffer_adaptor< CP, O, A >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
base_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
buffer_base_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
const_iterator typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
const_pointer typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
const_reference typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
const_reverse_iterator typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
destructor_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
difference_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
iterator typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
operator=(const self_type &)=default (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
operator=(self_type &&)=default (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
operator=(temporary_type &&) (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >inline
pointer typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
reference typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
reverse_iterator typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
self_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
size_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
temporary_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
value_type typedef (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
xbuffer_adaptor()=default (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
xbuffer_adaptor(const self_type &)=default (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
xbuffer_adaptor(self_type &&)=default (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
~xbuffer_adaptor()=default (defined in xt::xbuffer_adaptor< CP, O, A >)xt::xbuffer_adaptor< CP, O, A >
+
+ + + + diff --git a/classxt_1_1xbuffer__adaptor.html b/classxt_1_1xbuffer__adaptor.html new file mode 100644 index 000000000..4226e0311 --- /dev/null +++ b/classxt_1_1xbuffer__adaptor.html @@ -0,0 +1,620 @@ + + + + + + + +xtensor: xt::xbuffer_adaptor< CP, O, A > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xbuffer_adaptor< CP, O, A > Class Template Reference
+
+
+
+Inheritance diagram for xt::xbuffer_adaptor< CP, O, A >:
+
+
+ + +xt::xbuffer_adaptor_base< xbuffer_adaptor< CP, O, A > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xbuffer_adaptor<CP, O, A>
 
using base_type = detail::buffer_storage_t<CP, A, O>
 
using buffer_base_type = xbuffer_adaptor_base<self_type>
 
using allocator_type = typename base_type::allocator_type
 
using destructor_type = typename base_type::destructor_type
 
using value_type = typename buffer_base_type::value_type
 
using reference = typename buffer_base_type::reference
 
using const_reference = typename buffer_base_type::const_reference
 
using pointer = typename buffer_base_type::pointer
 
using const_pointer = typename buffer_base_type::const_pointer
 
using size_type = typename buffer_base_type::size_type
 
using difference_type = typename buffer_base_type::difference_type
 
using iterator = typename buffer_base_type::iterator
 
using const_iterator = typename buffer_base_type::const_iterator
 
using reverse_iterator = typename buffer_base_type::reverse_iterator
 
using const_reverse_iterator = typename buffer_base_type::const_reverse_iterator
 
using temporary_type = uvector<value_type, allocator_type>
 
- Public Types inherited from xt::xbuffer_adaptor_base< xbuffer_adaptor< CP, O, A > >
using self_type
 
using derived_type
 
using inner_types
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
using index_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xbuffer_adaptor (const self_type &)=default
 
+self_type & operator= (const self_type &)=default
 
+ xbuffer_adaptor (self_type &&)=default
 
+xbuffer_adaptor & operator= (self_type &&)=default
 
self_type & operator= (temporary_type &&)
 
- Public Member Functions inherited from xt::xbuffer_adaptor_base< xbuffer_adaptor< CP, O, A > >
bool empty () const noexcept
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rend () noexcept
 
const_reverse_iterator rend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xbuffer_adaptor_base< xbuffer_adaptor< CP, O, A > >
+ xbuffer_adaptor_base (const self_type &)=default
 
+ xbuffer_adaptor_base (self_type &&)=default
 
+self_type & operator= (const self_type &)=default
 
+self_type & operator= (self_type &&)=default
 
+

Detailed Description

+
template<class CP, class O, class A>
+class xt::xbuffer_adaptor< CP, O, A >
+

Definition at line 365 of file xbuffer_adaptor.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::allocator_type = typename base_type::allocator_type
+
+ +

Definition at line 373 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::base_type = detail::buffer_storage_t<CP, A, O>
+
+ +

Definition at line 371 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ buffer_base_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::buffer_base_type = xbuffer_adaptor_base<self_type>
+
+ +

Definition at line 372 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::const_iterator = typename buffer_base_type::const_iterator
+
+ +

Definition at line 383 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::const_pointer = typename buffer_base_type::const_pointer
+
+ +

Definition at line 379 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::const_reference = typename buffer_base_type::const_reference
+
+ +

Definition at line 377 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::const_reverse_iterator = typename buffer_base_type::const_reverse_iterator
+
+ +

Definition at line 385 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ destructor_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::destructor_type = typename base_type::destructor_type
+
+ +

Definition at line 374 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::difference_type = typename buffer_base_type::difference_type
+
+ +

Definition at line 381 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::iterator = typename buffer_base_type::iterator
+
+ +

Definition at line 382 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::pointer = typename buffer_base_type::pointer
+
+ +

Definition at line 378 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::reference = typename buffer_base_type::reference
+
+ +

Definition at line 376 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::reverse_iterator = typename buffer_base_type::reverse_iterator
+
+ +

Definition at line 384 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::self_type = xbuffer_adaptor<CP, O, A>
+
+ +

Definition at line 370 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::size_type = typename buffer_base_type::size_type
+
+ +

Definition at line 380 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::temporary_type = uvector<value_type, allocator_type>
+
+ +

Definition at line 386 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CP, class O, class A>
+ + + + +
using xt::xbuffer_adaptor< CP, O, A >::value_type = typename buffer_base_type::value_type
+
+ +

Definition at line 375 of file xbuffer_adaptor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator=()

+ +
+
+
+template<class CP, class O, class A>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor< CP, O, A >::operator= (temporary_type && tmp)
+ 		+inline
+
+ +

Definition at line 1059 of file xbuffer_adaptor.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xbuffer__adaptor.png b/classxt_1_1xbuffer__adaptor.png new file mode 100644 index 000000000..de3511d24 Binary files /dev/null and b/classxt_1_1xbuffer__adaptor.png differ diff --git a/classxt_1_1xbuffer__adaptor__base-members.html b/classxt_1_1xbuffer__adaptor__base-members.html new file mode 100644 index 000000000..494fc8cee --- /dev/null +++ b/classxt_1_1xbuffer__adaptor__base-members.html @@ -0,0 +1,162 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xbuffer_adaptor_base< D > Member List
+
+
+ +

This is the complete list of members for xt::xbuffer_adaptor_base< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
back() (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
back() const (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
begin() noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
begin() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
cbegin() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
cend() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
const_iterator typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
const_pointer typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
const_reference typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
const_reverse_iterator typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
crbegin() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
crend() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
derived_cast() noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
derived_cast() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
derived_type typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
difference_type typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
empty() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
end() noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
end() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
front() (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
front() const (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
index_type typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
inner_types typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
iterator typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
operator=(const self_type &)=default (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >protected
operator=(self_type &&)=default (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >protected
operator[](size_type i) (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
operator[](size_type i) const (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
pointer typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
rbegin() noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
rbegin() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
reference typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
rend() noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
rend() const noexcept (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >inline
reverse_iterator typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
self_type typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
size_type typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
value_type typedef (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >
xbuffer_adaptor_base()=default (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >protected
xbuffer_adaptor_base(const self_type &)=default (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >protected
xbuffer_adaptor_base(self_type &&)=default (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >protected
~xbuffer_adaptor_base()=default (defined in xt::xbuffer_adaptor_base< D >)xt::xbuffer_adaptor_base< D >protected
+
+ + + + diff --git a/classxt_1_1xbuffer__adaptor__base.html b/classxt_1_1xbuffer__adaptor__base.html new file mode 100644 index 000000000..4d2355bfe --- /dev/null +++ b/classxt_1_1xbuffer__adaptor__base.html @@ -0,0 +1,1114 @@ + + + + + + + +xtensor: xt::xbuffer_adaptor_base< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xbuffer_adaptor_base< D > Class Template Reference
+
+
+
+Inheritance diagram for xt::xbuffer_adaptor_base< D >:
+
+
+ + +xt::xiterator_adaptor< iterator, const_iterator > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xbuffer_adaptor_base<D>
 
using derived_type = D
 
using inner_types = buffer_inner_types<D>
 
using value_type = typename inner_types::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = typename inner_types::pointer
 
using const_pointer = typename inner_types::const_pointer
 
using size_type = typename inner_types::size_type
 
using difference_type = typename inner_types::difference_type
 
using iterator = typename inner_types::iterator
 
using const_iterator = typename inner_types::const_iterator
 
using reverse_iterator = typename inner_types::reverse_iterator
 
using const_reverse_iterator = typename inner_types::const_reverse_iterator
 
using index_type = typename inner_types::index_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

bool empty () const noexcept
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
iterator begin () noexcept
 
iterator end () noexcept
 
const_iterator begin () const noexcept
 
const_iterator end () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
reverse_iterator rbegin () noexcept
 
reverse_iterator rend () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
const_reverse_iterator rend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + +

+Protected Member Functions

+ xbuffer_adaptor_base (const self_type &)=default
 
+self_type & operator= (const self_type &)=default
 
+ xbuffer_adaptor_base (self_type &&)=default
 
+self_type & operator= (self_type &&)=default
 
+

Detailed Description

+
template<class D>
+class xt::xbuffer_adaptor_base< D >
+

Definition at line 262 of file xbuffer_adaptor.hpp.

+

Member Typedef Documentation

+ +

◆ const_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::const_iterator = typename inner_types::const_iterator
+
+ +

Definition at line 277 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::const_pointer = typename inner_types::const_pointer
+
+ +

Definition at line 273 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 271 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::const_reverse_iterator = typename inner_types::const_reverse_iterator
+
+ +

Definition at line 279 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::derived_type = D
+
+ +

Definition at line 267 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::difference_type = typename inner_types::difference_type
+
+ +

Definition at line 275 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ index_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::index_type = typename inner_types::index_type
+
+ +

Definition at line 280 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::inner_types = buffer_inner_types<D>
+
+ +

Definition at line 268 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::iterator = typename inner_types::iterator
+
+ +

Definition at line 276 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::pointer = typename inner_types::pointer
+
+ +

Definition at line 272 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::reference = typename inner_types::reference
+
+ +

Definition at line 270 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::reverse_iterator = typename inner_types::reverse_iterator
+
+ +

Definition at line 278 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::self_type = xbuffer_adaptor_base<D>
+
+ +

Definition at line 266 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::size_type = typename inner_types::size_type
+
+ +

Definition at line 274 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xbuffer_adaptor_base< D >::value_type = typename inner_types::value_type
+
+ +

Definition at line 269 of file xbuffer_adaptor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ back() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::back ()
+ 		+inline
+
+ +

Definition at line 898 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ back() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::back () const
+ 		+inline
+
+ +

Definition at line 904 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ begin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 922 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ begin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 910 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 934 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 940 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ crbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 970 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ crend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 976 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ derived_cast() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::derived_cast () const
+ 		+inlinenoexcept
+
+ +

Definition at line 988 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ derived_cast() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::derived_cast ()
+ 		+inlinenoexcept
+
+ +

Definition at line 982 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
bool xt::xbuffer_adaptor_base< D >::empty () const
+ 		+inlinenoexcept
+
+ +

Definition at line 868 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 928 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ end() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 916 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ front() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::front ()
+ 		+inline
+
+ +

Definition at line 886 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ front() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::front () const
+ 		+inline
+
+ +

Definition at line 892 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 874 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 880 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ rbegin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 958 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ rbegin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::rbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 946 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ rend() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 964 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ rend() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xbuffer_adaptor_base< D >::rend ()
+ 		+inlinenoexcept
+
+ +

Definition at line 952 of file xbuffer_adaptor.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xbuffer__adaptor__base.png b/classxt_1_1xbuffer__adaptor__base.png new file mode 100644 index 000000000..5559d9dd5 Binary files /dev/null and b/classxt_1_1xbuffer__adaptor__base.png differ diff --git a/classxt_1_1xchunk__iterator-members.html b/classxt_1_1xchunk__iterator-members.html new file mode 100644 index 000000000..81d92df08 --- /dev/null +++ b/classxt_1_1xchunk__iterator-members.html @@ -0,0 +1,140 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xchunk_iterator< E > Member List
+
+
+ +

This is the complete list of members for xt::xchunk_iterator< E >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + +
base_type typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
chunk_index() const (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
difference_type typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
get_chunk_slice_vector() const (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
get_slice_vector() const (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
iterator_category typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
operator!=(const self_type &rhs) const (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
operator*() const (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
operator++() (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
operator++(int) (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
operator==(const self_type &rhs) const (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
pointer typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
reference typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
self_type typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
shape_type typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
size_type typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
slice_vector typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
value_type typedef (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
xchunk_iterator()=default (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >
xchunk_iterator(E &chunked_expression, shape_type &&chunk_index, size_type chunk_linear_index) (defined in xt::xchunk_iterator< E >)xt::xchunk_iterator< E >inline
+
+ + + + diff --git a/classxt_1_1xchunk__iterator.html b/classxt_1_1xchunk__iterator.html new file mode 100644 index 000000000..9e7f3a812 --- /dev/null +++ b/classxt_1_1xchunk__iterator.html @@ -0,0 +1,625 @@ + + + + + + + +xtensor: xt::xchunk_iterator< E > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xchunk_iterator< E > Class Template Reference
+
+
+
+Inheritance diagram for xt::xchunk_iterator< E >:
+
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using base_type = detail::xchunk_iterator_base<E>
 
using self_type = xchunk_iterator<E>
 
using size_type = typename E::size_type
 
using shape_type = typename E::shape_type
 
using slice_vector = xstrided_slice_vector
 
using reference = typename base_type::reference
 
using value_type = std::remove_reference_t<reference>
 
using pointer = value_type*
 
using difference_type = typename E::difference_type
 
using iterator_category = std::forward_iterator_tag
 
+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xchunk_iterator (E &chunked_expression, shape_type &&chunk_index, size_type chunk_linear_index)
 
self_type & operator++ ()
 
self_type operator++ (int)
 
decltype(auto) operator* () const
 
bool operator== (const self_type &rhs) const
 
bool operator!= (const self_type &rhs) const
 
const shape_type & chunk_index () const
 
const slice_vector & get_slice_vector () const
 
slice_vector get_chunk_slice_vector () const
 
+

Detailed Description

+
template<class E>
+class xt::xchunk_iterator< E >
+

Definition at line 149 of file xchunked_assign.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::base_type = detail::xchunk_iterator_base<E>
+
+ +

Definition at line 153 of file xchunked_assign.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::difference_type = typename E::difference_type
+
+ +

Definition at line 162 of file xchunked_assign.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::iterator_category = std::forward_iterator_tag
+
+ +

Definition at line 163 of file xchunked_assign.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::pointer = value_type*
+
+ +

Definition at line 161 of file xchunked_assign.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::reference = typename base_type::reference
+
+ +

Definition at line 159 of file xchunked_assign.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::self_type = xchunk_iterator<E>
+
+ +

Definition at line 154 of file xchunked_assign.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::shape_type = typename E::shape_type
+
+ +

Definition at line 156 of file xchunked_assign.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::size_type = typename E::size_type
+
+ +

Definition at line 155 of file xchunked_assign.hpp.

+ +
+
+ +

◆ slice_vector

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::slice_vector = xstrided_slice_vector
+
+ +

Definition at line 157 of file xchunked_assign.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunk_iterator< E >::value_type = std::remove_reference_t<reference>
+
+ +

Definition at line 160 of file xchunked_assign.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xchunk_iterator()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xchunk_iterator< E >::xchunk_iterator (E & chunked_expression,
shape_type && chunk_index,
size_type chunk_linear_index )
+ 		+inline
+
+ +

Definition at line 274 of file xchunked_assign.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ chunk_index()

+ +
+
+
+template<class E>
+ + + + + + + +
auto xt::xchunk_iterator< E >::chunk_index () const
+
+ +

Definition at line 345 of file xchunked_assign.hpp.

+ +
+
+ +

◆ get_chunk_slice_vector()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunk_iterator< E >::get_chunk_slice_vector () const
+ 		+inline
+
+ +

Definition at line 351 of file xchunked_assign.hpp.

+ +
+
+ +

◆ get_slice_vector()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunk_iterator< E >::get_slice_vector () const
+ 		+inline
+
+ +

Definition at line 339 of file xchunked_assign.hpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
bool xt::xchunk_iterator< E >::operator!= (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 333 of file xchunked_assign.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
decltype(auto) xt::xchunk_iterator< E >::operator* () const
+ 		+inline
+
+ +

Definition at line 321 of file xchunked_assign.hpp.

+ +
+
+ +

◆ operator++() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
xchunk_iterator< E > & xt::xchunk_iterator< E >::operator++ ()
+ 		+inline
+
+ +

Definition at line 287 of file xchunked_assign.hpp.

+ +
+
+ +

◆ operator++() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
xchunk_iterator< E > xt::xchunk_iterator< E >::operator++ (int )
+ 		+inline
+
+ +

Definition at line 313 of file xchunked_assign.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
bool xt::xchunk_iterator< E >::operator== (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 327 of file xchunked_assign.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xchunk__iterator.png b/classxt_1_1xchunk__iterator.png new file mode 100644 index 000000000..c2a8628f1 Binary files /dev/null and b/classxt_1_1xchunk__iterator.png differ diff --git a/classxt_1_1xchunked__array-members.html b/classxt_1_1xchunked__array-members.html new file mode 100644 index 000000000..50d6f0a7d --- /dev/null +++ b/classxt_1_1xchunked__array-members.html @@ -0,0 +1,291 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xchunked_array< chunk_storage > Member List
+
+
+ +

This is the complete list of members for xt::xchunked_array< chunk_storage >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
at(Args... args) -> referencext::xaccessible< xchunked_array< chunk_storage > >inline
at(Args... args) -> referencext::xaccessible< xchunked_array< chunk_storage > >inline
back() constxt::xaccessible< xchunked_array< chunk_storage > >
back()xt::xaccessible< xchunked_array< chunk_storage > >inline
back() constxt::xaccessible< xchunked_array< chunk_storage > >inline
begin() noexcept -> layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
begin() noexcept -> layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
bool_load_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
broadcast_shape(S &s, bool reuse_cache=false) const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
chunk_begin() (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunk_begin() const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunk_cbegin() const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunk_cend() const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunk_end() (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunk_end() const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunk_iterator typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
chunk_shape() const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunk_storage_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
chunk_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
chunks() (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
chunks() const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
const_chunk_iterator typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
const_pointer typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
const_reference typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
const_stepper typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
contiguous_layout (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >static
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xchunked_array< chunk_storage > >inline
difference_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
dimension() const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
element(It first, It last) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
element(It first, It last) const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
element(It first, It last) -> reference (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
element(It first, It last) const -> const_reference (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
end() noexcept -> layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
end() noexcept -> layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
front() constxt::xaccessible< xchunked_array< chunk_storage > >
front()xt::xaccessible< xchunked_array< chunk_storage > >inline
front() constxt::xaccessible< xchunked_array< chunk_storage > >inline
get_chunk_indexes(std::index_sequence< dims... >, Idxs... idxs) const -> chunk_indexes_type< Idxs... > (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
get_indexes(Idxs... idxs) const -> indexes_type< Idxs... > (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
get_indexes_dynamic(It first, It last) const -> dynamic_indexes_type (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
grid_shape() const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
grid_shape_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
grid_size() const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
has_linear_assign(const S &strides) const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
in_bounds(Args... args) constxt::xconst_accessible< xchunked_array< chunk_storage > >inline
inner_types typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
is_contiguous() const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
iterable_base typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
layout() const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator()(Idxs... idxs) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
operator()(Idxs... idxs) const (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
operator()(Idxs... idxs) -> reference (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
operator()(Idxs... idxs) const -> const_reference (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator=(const xchunked_array &)=default (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
operator=(xchunked_array &&)=default (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
operator=(const xexpression< E > &e) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
operator=(const xexpression< E > &e) -> self_type & (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< xchunked_array< chunk_storage > >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< xchunked_array< chunk_storage > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xchunked_array< chunk_storage > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
periodic(Args... args) -> referencext::xaccessible< xchunked_array< chunk_storage > >inline
periodic(Args... args) -> referencext::xaccessible< xchunked_array< chunk_storage > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xchunked_array< chunk_storage > >inline
pointer typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
rbegin() noexcept -> reverse_layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
rbegin() noexcept -> reverse_layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
reference typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
rend() noexcept -> reverse_layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
rend() noexcept -> reverse_layout_iterator< L >xt::xiterable< xchunked_array< chunk_storage > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xchunked_array< chunk_storage > >inline
self_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
semantic_base typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
shape() const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
xt::xaccessible< xchunked_array< chunk_storage > >::shape(size_type index) constxt::xconst_accessible< xchunked_array< chunk_storage > >inline
shape_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
size() const noexcept(noexcept(derived_cast().shape()))xt::xconst_accessible< xchunked_array< chunk_storage > >inline
size_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
static_layout (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >static
stepper typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
stepper_begin(const S &shape) noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
stepper_begin(const S &shape) const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
stepper_end(const S &shape, layout_type) noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
stepper_end(const S &shape, layout_type) const noexcept (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
stepper_end(const S &shape, layout_type) noexcept -> stepper (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
stepper_end(const S &shape, layout_type) const noexcept -> const_stepper (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
storage_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
temporary_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
unpack(const std::array< T, N > &arr) const -> static_indexes_type< N > (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
value_type typedef (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
xchunked_array(chunk_storage_type &&chunks, S &&shape, S &&chunk_shape, layout_type chunk_memory_layout=::xt::layout_type::row_major) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
xchunked_array(const xchunked_array &)=default (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
xchunked_array(xchunked_array &&)=default (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
xchunked_array(const xexpression< E > &e, chunk_storage_type &&chunks, layout_type chunk_memory_layout=::xt::layout_type::row_major) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
xchunked_array(const xexpression< E > &e, chunk_storage_type &&chunks, S &&chunk_shape, layout_type chunk_memory_layout=::xt::layout_type::row_major) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
xchunked_array(CS &&chunks, S &&shape, S &&chunk_shape, layout_type chunk_memory_layout) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
xchunked_array(const xexpression< E > &e, CS &&chunks, layout_type chunk_memory_layout) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
xchunked_array(const xexpression< E > &e, CS &&chunks, S &&chunk_shape, layout_type chunk_memory_layout) (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >inline
~xchunked_array()=default (defined in xt::xchunked_array< chunk_storage >)xt::xchunked_array< chunk_storage >
+
+ + + + diff --git a/classxt_1_1xchunked__array.html b/classxt_1_1xchunked__array.html new file mode 100644 index 000000000..0c8ed5db7 --- /dev/null +++ b/classxt_1_1xchunked__array.html @@ -0,0 +1,2771 @@ + + + + + + + +xtensor: xt::xchunked_array< chunk_storage > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::xchunked_array< chunk_storage > Class Template Reference
+
+
+
+Inheritance diagram for xt::xchunked_array< chunk_storage >:
+
+
+ + +xt::xaccessible< xchunked_array< chunk_storage > > +xt::xiterable< xchunked_array< chunk_storage > > +xt::xchunked_semantic< xchunked_array< chunk_storage > > +xt::xconst_accessible< xchunked_array< chunk_storage > > +xt::xconst_iterable< xchunked_array< chunk_storage > > +xt::xsemantic_base< xchunked_array< chunk_storage > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using chunk_storage_type = chunk_storage
 
using chunk_type = typename chunk_storage::value_type
 
using grid_shape_type = typename chunk_storage::shape_type
 
using const_reference = typename chunk_type::const_reference
 
using reference = typename chunk_type::reference
 
using self_type = xchunked_array<chunk_storage>
 
using semantic_base = xchunked_semantic<self_type>
 
using iterable_base = xconst_iterable<self_type>
 
using const_stepper = typename iterable_base::const_stepper
 
using stepper = typename iterable_base::stepper
 
using inner_types = xcontainer_inner_types<self_type>
 
using size_type = typename inner_types::size_type
 
using storage_type = typename inner_types::storage_type
 
using value_type = typename storage_type::value_type
 
using pointer = value_type*
 
using const_pointer = const value_type*
 
using difference_type = std::ptrdiff_t
 
using shape_type = typename chunk_type::shape_type
 
using temporary_type = typename inner_types::temporary_type
 
using bool_load_type = xt::bool_load_type<value_type>
 
using chunk_iterator = xchunk_iterator<self_type>
 
using const_chunk_iterator = xchunk_iterator<const self_type>
 
- Public Types inherited from xt::xaccessible< xchunked_array< chunk_storage > >
using base_type
 
using derived_type
 
using reference
 
using size_type
 
- Public Types inherited from xt::xconst_accessible< xchunked_array< chunk_storage > >
using derived_type
 
using inner_types
 
using reference
 
using const_reference
 
using size_type
 
- Public Types inherited from xt::xiterable< xchunked_array< chunk_storage > >
using derived_type
 
using base_type
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using linear_iterator
 
using reverse_linear_iterator
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xconst_iterable< xchunked_array< chunk_storage > >
using derived_type
 
using iterable_types
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xchunked_semantic< xchunked_array< chunk_storage > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xchunked_array< chunk_storage > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class S>
 xchunked_array (chunk_storage_type &&chunks, S &&shape, S &&chunk_shape, layout_type chunk_memory_layout=::xt::layout_type::row_major)
 
+ xchunked_array (const xchunked_array &)=default
 
+xchunked_array & operator= (const xchunked_array &)=default
 
+ xchunked_array (xchunked_array &&)=default
 
+xchunked_array & operator= (xchunked_array &&)=default
 
+template<class E>
 xchunked_array (const xexpression< E > &e, chunk_storage_type &&chunks, layout_type chunk_memory_layout=::xt::layout_type::row_major)
 
+template<class E, class S>
 xchunked_array (const xexpression< E > &e, chunk_storage_type &&chunks, S &&chunk_shape, layout_type chunk_memory_layout=::xt::layout_type::row_major)
 
+template<class E>
xchunked_array & operator= (const xexpression< E > &e)
 
size_type dimension () const noexcept
 
const shape_type & shape () const noexcept
 
layout_type layout () const noexcept
 
bool is_contiguous () const noexcept
 
+template<class... Idxs>
reference operator() (Idxs... idxs)
 
+template<class... Idxs>
const_reference operator() (Idxs... idxs) const
 
+template<class It>
reference element (It first, It last)
 
+template<class It>
const_reference element (It first, It last) const
 
template<class S>
bool broadcast_shape (S &s, bool reuse_cache=false) const
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 
+template<class S>
stepper stepper_begin (const S &shape) noexcept
 
+template<class S>
stepper stepper_end (const S &shape, layout_type) noexcept
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type) const noexcept
 
const shape_type & chunk_shape () const noexcept
 
size_type grid_size () const noexcept
 
const grid_shape_type & grid_shape () const noexcept
 
chunk_storage_type & chunks ()
 
const chunk_storage_type & chunks () const
 
chunk_iterator chunk_begin ()
 
chunk_iterator chunk_end ()
 
const_chunk_iterator chunk_begin () const
 
const_chunk_iterator chunk_end () const
 
const_chunk_iterator chunk_cbegin () const
 
const_chunk_iterator chunk_cend () const
 
template<class S>
 xchunked_array (CS &&chunks, S &&shape, S &&chunk_shape, layout_type chunk_memory_layout)
 
template<class E>
 xchunked_array (const xexpression< E > &e, CS &&chunks, layout_type chunk_memory_layout)
 
template<class E, class S>
 xchunked_array (const xexpression< E > &e, CS &&chunks, S &&chunk_shape, layout_type chunk_memory_layout)
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 
template<class... Idxs>
auto operator() (Idxs... idxs) -> reference
 
template<class... Idxs>
auto operator() (Idxs... idxs) const -> const_reference
 
template<class It>
auto element (It first, It last) -> reference
 
template<class It>
auto element (It first, It last) const -> const_reference
 
template<class S>
auto stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type) noexcept -> stepper
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type) const noexcept -> const_stepper
 
template<class... Idxs>
auto get_indexes (Idxs... idxs) const -> indexes_type< Idxs... >
 
template<std::size_t... dims, class... Idxs>
auto get_chunk_indexes (std::index_sequence< dims... >, Idxs... idxs) const -> chunk_indexes_type< Idxs... >
 
template<class T, std::size_t N>
auto unpack (const std::array< T, N > &arr) const -> static_indexes_type< N >
 
template<class It>
auto get_indexes_dynamic (It first, It last) const -> dynamic_indexes_type
 
- Public Member Functions inherited from xt::xaccessible< xchunked_array< chunk_storage > >
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+const_reference operator[] (size_type i) const
 
+const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+const_reference periodic (Args... args) const
 
+reference at (Args... args)
 
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
+reference periodic (Args... args)
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+const_reference periodic (Args... args) const
 
reference front ()
 Returns a reference to the first element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
reference back ()
 Returns a reference to the last element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
- Public Member Functions inherited from xt::xconst_accessible< xchunked_array< chunk_storage > >
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+const_reference at (Args... args) const
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
+const_reference periodic (Args... args) const
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
- Public Member Functions inherited from xt::xiterable< xchunked_array< chunk_storage > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+layout_iterator< L > begin () noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+layout_iterator< L > end () noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rbegin () noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rend () noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
auto begin () noexcept -> layout_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> layout_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () noexcept -> layout_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> layout_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto get_begin (bool end_index) noexcept -> layout_iterator< L >
 
auto get_end (bool end_index) noexcept -> layout_iterator< L >
 
auto get_begin (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_end (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) noexcept -> stepper
 
auto get_stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto get_begin (bool end_index) noexcept -> layout_iterator< L >
 
auto get_begin (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_end (bool end_index) noexcept -> layout_iterator< L >
 
auto get_end (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) noexcept -> stepper
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xconst_iterable< xchunked_array< chunk_storage > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_layout_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_layout_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xchunked_semantic< xchunked_array< chunk_storage > >
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto get_assigner (const CS &) const -> xchunked_assigner< temporary_type, CS >
 
+derived_type & assign_xexpression (const xexpression< E > &e)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
+derived_type & computed_assign (const xexpression< E > &e)
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto get_assigner (const CS &) const -> xchunked_assigner< temporary_type, CS >
 
- Public Member Functions inherited from xt::xsemantic_base< xchunked_array< chunk_storage > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = layout_type::dynamic
 
static constexpr bool contiguous_layout = false
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xaccessible< xchunked_array< chunk_storage > >
+ xaccessible (const xaccessible &)=default
 
+ xaccessible (xaccessible &&)=default
 
+xaccessible & operator= (const xaccessible &)=default
 
+xaccessible & operator= (xaccessible &&)=default
 
- Protected Member Functions inherited from xt::xconst_accessible< xchunked_array< chunk_storage > >
+ xconst_accessible (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
const inner_shape_type & get_shape () const
 
- Protected Member Functions inherited from xt::xchunked_semantic< xchunked_array< chunk_storage > >
+ xchunked_semantic (const xchunked_semantic &)=default
 
+ xchunked_semantic (xchunked_semantic &&)=default
 
+xchunked_semantic & operator= (const xchunked_semantic &)=default
 
+xchunked_semantic & operator= (xchunked_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &e)
 
- Protected Member Functions inherited from xt::xsemantic_base< xchunked_array< chunk_storage > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class chunk_storage>
+class xt::xchunked_array< chunk_storage >
+

Definition at line 56 of file xchunked_array.hpp.

+

Member Typedef Documentation

+ +

◆ bool_load_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::bool_load_type = xt::bool_load_type<value_type>
+
+ +

Definition at line 81 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_iterator

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::chunk_iterator = xchunk_iterator<self_type>
+
+ +

Definition at line 84 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_storage_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::chunk_storage_type = chunk_storage
+
+ +

Definition at line 62 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::chunk_type = typename chunk_storage::value_type
+
+ +

Definition at line 63 of file xchunked_array.hpp.

+ +
+
+ +

◆ const_chunk_iterator

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::const_chunk_iterator = xchunk_iterator<const self_type>
+
+ +

Definition at line 85 of file xchunked_array.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::const_pointer = const value_type*
+
+ +

Definition at line 77 of file xchunked_array.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::const_reference = typename chunk_type::const_reference
+
+ +

Definition at line 65 of file xchunked_array.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 70 of file xchunked_array.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::difference_type = std::ptrdiff_t
+
+ +

Definition at line 78 of file xchunked_array.hpp.

+ +
+
+ +

◆ grid_shape_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::grid_shape_type = typename chunk_storage::shape_type
+
+ +

Definition at line 64 of file xchunked_array.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 72 of file xchunked_array.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::iterable_base = xconst_iterable<self_type>
+
+ +

Definition at line 69 of file xchunked_array.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::pointer = value_type*
+
+ +

Definition at line 76 of file xchunked_array.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::reference = typename chunk_type::reference
+
+ +

Definition at line 66 of file xchunked_array.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::self_type = xchunked_array<chunk_storage>
+
+ +

Definition at line 67 of file xchunked_array.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::semantic_base = xchunked_semantic<self_type>
+
+ +

Definition at line 68 of file xchunked_array.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::shape_type = typename chunk_type::shape_type
+
+ +

Definition at line 79 of file xchunked_array.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::size_type = typename inner_types::size_type
+
+ +

Definition at line 73 of file xchunked_array.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 71 of file xchunked_array.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::storage_type = typename inner_types::storage_type
+
+ +

Definition at line 74 of file xchunked_array.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::temporary_type = typename inner_types::temporary_type
+
+ +

Definition at line 80 of file xchunked_array.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class chunk_storage>
+ + + + +
using xt::xchunked_array< chunk_storage >::value_type = typename storage_type::value_type
+
+ +

Definition at line 75 of file xchunked_array.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xchunked_array() [1/3]

+ +
+
+
+template<class chunk_storage>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xchunked_array< chunk_storage >::xchunked_array (CS && chunks,
S && shape,
S && chunk_shape,
layout_type chunk_memory_layout )
+ 		+inline
+
+ +

Definition at line 390 of file xchunked_array.hpp.

+ +
+
+ +

◆ xchunked_array() [2/3]

+ +
+
+
+template<class chunk_storage>
+
+template<class E>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xchunked_array< chunk_storage >::xchunked_array (const xexpression< E > & e,
CS && chunks,
layout_type chunk_memory_layout )
+ 		+inline
+
+ +

Definition at line 398 of file xchunked_array.hpp.

+ +
+
+ +

◆ xchunked_array() [3/3]

+ +
+
+
+template<class chunk_storage>
+
+template<class E, class S>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xchunked_array< chunk_storage >::xchunked_array (const xexpression< E > & e,
CS && chunks,
S && chunk_shape,
layout_type chunk_memory_layout )
+ 		+inline
+
+ +

Definition at line 405 of file xchunked_array.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ broadcast_shape()

+ +
+
+
+template<class CS>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xchunked_array< CS >::broadcast_shape (S & s,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Definition at line 486 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_begin() [1/2]

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunk_begin ()
+ 		+inline
+
+ +

Definition at line 561 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_begin() [2/2]

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunk_begin () const
+ 		+inline
+
+ +

Definition at line 575 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_cbegin()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunk_cbegin () const
+ 		+inline
+
+ +

Definition at line 589 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_cend()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunk_cend () const
+ 		+inline
+
+ +

Definition at line 595 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_end() [1/2]

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunk_end ()
+ 		+inline
+
+ +

Definition at line 568 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_end() [2/2]

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunk_end () const
+ 		+inline
+
+ +

Definition at line 582 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunk_shape()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunk_shape () const
+ 		+inlinenoexcept
+
+ +

Definition at line 531 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunks() [1/2]

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunks ()
+ 		+inline
+
+ +

Definition at line 549 of file xchunked_array.hpp.

+ +
+
+ +

◆ chunks() [2/2]

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::chunks () const
+ 		+inline
+
+ +

Definition at line 555 of file xchunked_array.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::dimension () const
+ 		+inlinenoexcept
+
+ +

Definition at line 425 of file xchunked_array.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xchunked_array< chunk_storage >::element (It first,
It last ) -> reference +
+ 		+inline
+
+ +

Definition at line 468 of file xchunked_array.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xchunked_array< chunk_storage >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 477 of file xchunked_array.hpp.

+ +
+
+ +

◆ get_chunk_indexes()

+ +
+
+
+template<class chunk_storage>
+
+template<std::size_t... dims, class... Idxs>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xchunked_array< chunk_storage >::get_chunk_indexes (std::index_sequence< dims... > ,
Idxs... idxs ) const -> chunk_indexes_type<Idxs...> +
+ 		+inline
+
+ +

Definition at line 648 of file xchunked_array.hpp.

+ +
+
+ +

◆ get_indexes()

+ +
+
+
+template<class chunk_storage>
+
+template<class... Idxs>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< chunk_storage >::get_indexes (Idxs... idxs) const -> indexes_type<Idxs...> +
+ 		+inline
+
+ +

Definition at line 630 of file xchunked_array.hpp.

+ +
+
+ +

◆ get_indexes_dynamic()

+ +
+
+
+template<class chunk_storage>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xchunked_array< chunk_storage >::get_indexes_dynamic (It first,
It last ) const -> dynamic_indexes_type +
+ 		+inline
+
+ +

Definition at line 671 of file xchunked_array.hpp.

+ +
+
+ +

◆ grid_shape()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::grid_shape () const
+ 		+inlinenoexcept
+
+ +

Definition at line 543 of file xchunked_array.hpp.

+ +
+
+ +

◆ grid_size()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::grid_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 537 of file xchunked_array.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CS>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xchunked_array< CS >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Definition at line 493 of file xchunked_array.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
bool xt::xchunked_array< CS >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 443 of file xchunked_array.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::layout () const
+ 		+inlinenoexcept
+
+ +

Definition at line 437 of file xchunked_array.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class... Idxs>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< chunk_storage >::operator() (Idxs... idxs) -> reference +
+ 		+inline
+
+ +

Definition at line 450 of file xchunked_array.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class... Idxs>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< chunk_storage >::operator() (Idxs... idxs) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 459 of file xchunked_array.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<class chunk_storage>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< chunk_storage >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

Definition at line 419 of file xchunked_array.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< CS >::shape () const
+ 		+inlinenoexcept
+
+ +

Definition at line 431 of file xchunked_array.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< chunk_storage >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 516 of file xchunked_array.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< chunk_storage >::stepper_begin (const S & shape) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 500 of file xchunked_array.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xchunked_array< chunk_storage >::stepper_end (const S & shape,
layout_type  ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 524 of file xchunked_array.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class chunk_storage>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xchunked_array< chunk_storage >::stepper_end (const S & shape,
layout_type  ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 508 of file xchunked_array.hpp.

+ +
+
+ +

◆ unpack()

+ +
+
+
+template<class chunk_storage>
+
+template<class T, std::size_t N>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_array< chunk_storage >::unpack (const std::array< T, N > & arr) const -> static_indexes_type<N> +
+ 		+inline
+
+ +

Definition at line 657 of file xchunked_array.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class chunk_storage>
+ + + + + +
+ + + + +
bool xt::xchunked_array< chunk_storage >::contiguous_layout = false
+ 		+staticconstexpr
+
+ +

Definition at line 83 of file xchunked_array.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class chunk_storage>
+ + + + + +
+ + + + +
layout_type xt::xchunked_array< chunk_storage >::static_layout = layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 82 of file xchunked_array.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xchunked__array.png b/classxt_1_1xchunked__array.png new file mode 100644 index 000000000..76ac41941 Binary files /dev/null and b/classxt_1_1xchunked__array.png differ diff --git a/classxt_1_1xchunked__assigner-members.html b/classxt_1_1xchunked__assigner-members.html new file mode 100644 index 000000000..12e54469f --- /dev/null +++ b/classxt_1_1xchunked__assigner-members.html @@ -0,0 +1,122 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xchunked_assigner< T, chunk_storage > Member List
+
+
+ +

This is the complete list of members for xt::xchunked_assigner< T, chunk_storage >, including all inherited members.

+ + + +
build_and_assign_temporary(const xexpression< E > &e, DST &dst) (defined in xt::xchunked_assigner< T, chunk_storage >)xt::xchunked_assigner< T, chunk_storage >inline
temporary_type typedef (defined in xt::xchunked_assigner< T, chunk_storage >)xt::xchunked_assigner< T, chunk_storage >
+
+ + + + diff --git a/classxt_1_1xchunked__assigner.html b/classxt_1_1xchunked__assigner.html new file mode 100644 index 000000000..1ff9ced90 --- /dev/null +++ b/classxt_1_1xchunked__assigner.html @@ -0,0 +1,196 @@ + + + + + + + +xtensor: xt::xchunked_assigner< T, chunk_storage > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xchunked_assigner< T, chunk_storage > Class Template Reference
+
+
+ + + + +

+Public Types

using temporary_type = T
 
+ + + + +

+Public Member Functions

template<class E, class DST>
void build_and_assign_temporary (const xexpression< E > &e, DST &dst)
 
+

Detailed Description

+
template<class T, class chunk_storage>
+class xt::xchunked_assigner< T, chunk_storage >
+

Definition at line 24 of file xchunked_assign.hpp.

+

Member Typedef Documentation

+ +

◆ temporary_type

+ +
+
+
+template<class T, class chunk_storage>
+ + + + +
using xt::xchunked_assigner< T, chunk_storage >::temporary_type = T
+
+ +

Definition at line 28 of file xchunked_assign.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ build_and_assign_temporary()

+ +
+
+
+template<class T, class CS>
+
+template<class E, class DST>
+ + + + + +
+ + + + + + + + + + + +
void xt::xchunked_assigner< T, CS >::build_and_assign_temporary (const xexpression< E > & e,
DST & dst )
+ 		+inline
+
+ +

Definition at line 197 of file xchunked_assign.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xchunked__semantic-members.html b/classxt_1_1xchunked__semantic-members.html new file mode 100644 index 000000000..abe78032a --- /dev/null +++ b/classxt_1_1xchunked__semantic-members.html @@ -0,0 +1,194 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xchunked_semantic< D > Member List
+
+
+ +

This is the complete list of members for xt::xchunked_semantic< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
assign_xexpression(const xexpression< E > &e) (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >
assign_xexpression(const xexpression< E > &e) -> derived_type & (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >inline
base_type typedef (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >
bit_and_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_or_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_xor_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
computed_assign(const xexpression< E > &e) (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >
computed_assign(const xexpression< E > &e) -> derived_type & (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >inline
derived_type typedef (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >
divides_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
get_assigner(const CS &) const -> xchunked_assigner< temporary_type, CS > (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >inline
minus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
modulus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
multiplies_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator%=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator&=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator*=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator+=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator-=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator/=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator=(const xchunked_semantic &)=default (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >protected
operator=(xchunked_semantic &&)=default (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >protected
operator=(const xexpression< E > &e) (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >protected
operator=(const xexpression< E > &e) -> derived_type & (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >inline
operator=(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator^=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator|=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
plus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
scalar_computed_assign(const E &e, F &&f) (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >
scalar_computed_assign(const E &e, F &&f) -> derived_type & (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >inline
temporary_type typedef (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >
xchunked_semantic()=default (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >protected
xchunked_semantic(const xchunked_semantic &)=default (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >protected
xchunked_semantic(xchunked_semantic &&)=default (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >protected
xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
~xchunked_semantic()=default (defined in xt::xchunked_semantic< D >)xt::xchunked_semantic< D >protected
~xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
+
+ + + + diff --git a/classxt_1_1xchunked__semantic.html b/classxt_1_1xchunked__semantic.html new file mode 100644 index 000000000..ea40cd430 --- /dev/null +++ b/classxt_1_1xchunked__semantic.html @@ -0,0 +1,646 @@ + + + + + + + +xtensor: xt::xchunked_semantic< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xchunked_semantic< D > Class Template Reference
+
+
+
+Inheritance diagram for xt::xchunked_semantic< D >:
+
+
+ + +xt::xsemantic_base< D > + +
+ + + + + + + + + + + + + + + +

+Public Types

using base_type = xsemantic_base<D>
 
using derived_type = D
 
using temporary_type = typename base_type::temporary_type
 
- Public Types inherited from xt::xsemantic_base< D >
using base_type = select_expression_base_t<D>
 
using derived_type = typename base_type::derived_type
 
using temporary_type = typename xcontainer_inner_types<D>::temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
derived_type & assign_xexpression (const xexpression< E > &e)
 
+template<class E>
derived_type & computed_assign (const xexpression< E > &e)
 
+template<class E, class F>
derived_type & scalar_computed_assign (const E &e, F &&f)
 
template<class E>
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
template<class E>
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
template<class E, class F>
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
template<class CS>
auto get_assigner (const CS &) const -> xchunked_assigner< temporary_type, CS >
 
- Public Member Functions inherited from xt::xsemantic_base< D >
+template<class E>
disable_xexpression< E, derived_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator^= (const E &)
 
+template<class E>
derived_type & operator+= (const xexpression< E > &)
 
+template<class E>
derived_type & operator-= (const xexpression< E > &)
 
+template<class E>
derived_type & operator*= (const xexpression< E > &)
 
+template<class E>
derived_type & operator/= (const xexpression< E > &)
 
+template<class E>
derived_type & operator%= (const xexpression< E > &)
 
+template<class E>
derived_type & operator&= (const xexpression< E > &)
 
+template<class E>
derived_type & operator|= (const xexpression< E > &)
 
+template<class E>
derived_type & operator^= (const xexpression< E > &)
 
+template<class E>
derived_type & assign (const xexpression< E > &)
 
+template<class E>
derived_type & plus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & minus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & multiplies_assign (const xexpression< E > &)
 
+template<class E>
derived_type & divides_assign (const xexpression< E > &)
 
+template<class E>
derived_type & modulus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_and_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_or_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_xor_assign (const xexpression< E > &)
 
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
template<class E>
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
template<class E>
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
template<class E>
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
template<class E>
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
template<class E>
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

+ xchunked_semantic (const xchunked_semantic &)=default
 
+xchunked_semantic & operator= (const xchunked_semantic &)=default
 
+ xchunked_semantic (xchunked_semantic &&)=default
 
+xchunked_semantic & operator= (xchunked_semantic &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &e)
 
- Protected Member Functions inherited from xt::xsemantic_base< D >
+ xsemantic_base (const xsemantic_base &)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class D>
+class xt::xchunked_semantic< D >
+

Definition at line 39 of file xchunked_assign.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xchunked_semantic< D >::base_type = xsemantic_base<D>
+
+ +

Definition at line 43 of file xchunked_assign.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xchunked_semantic< D >::derived_type = D
+
+ +

Definition at line 44 of file xchunked_assign.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xchunked_semantic< D >::temporary_type = typename base_type::temporary_type
+
+ +

Definition at line 45 of file xchunked_assign.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign_xexpression()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_semantic< D >::assign_xexpression (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 205 of file xchunked_assign.hpp.

+ +
+
+ +

◆ computed_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_semantic< D >::computed_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 229 of file xchunked_assign.hpp.

+ +
+
+ +

◆ get_assigner()

+ +
+
+
+template<class D>
+
+template<class CS>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_semantic< D >::get_assigner (const CS & ) const -> xchunked_assigner<temporary_type, CS> +
+ 		+inline
+
+ +

Definition at line 264 of file xchunked_assign.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_semantic< D >::operator= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 255 of file xchunked_assign.hpp.

+ +
+
+ +

◆ scalar_computed_assign()

+ +
+
+
+template<class D>
+
+template<class E, class F>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xchunked_semantic< D >::scalar_computed_assign (const E & e,
F && f ) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 244 of file xchunked_assign.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xchunked__semantic.png b/classxt_1_1xchunked__semantic.png new file mode 100644 index 000000000..016739075 Binary files /dev/null and b/classxt_1_1xchunked__semantic.png differ diff --git a/classxt_1_1xchunked__view-members.html b/classxt_1_1xchunked__view-members.html new file mode 100644 index 000000000..d149de4b4 --- /dev/null +++ b/classxt_1_1xchunked__view-members.html @@ -0,0 +1,150 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xchunked_view< E > Member List
+
+
+ +

This is the complete list of members for xt::xchunked_view< E >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
chunk_begin() (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
chunk_begin() const (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
chunk_cbegin() const (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
chunk_cend() const (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
chunk_end() (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
chunk_end() const (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
chunk_iterator typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
chunk_shape() const noexcept (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
const_chunk_iterator typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
const_pointer typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
const_reference typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
difference_type typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
dimension() const noexcept (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
expression() noexcept (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
expression() const noexcept (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
expression_type typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
grid_shape() const noexcept (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
grid_size() const noexcept (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
init() (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
operator=(const OE &e) (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
operator=(const OE &e) (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
pointer typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
reference typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
self_type typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
shape() const noexcept (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
shape_type typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
size_type typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
value_type typedef (defined in xt::xchunked_view< E >)xt::xchunked_view< E >
xchunked_view(OE &&e, S &&chunk_shape) (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
xchunked_view(OE &&e) (defined in xt::xchunked_view< E >)xt::xchunked_view< E >inline
+
+ + + + diff --git a/classxt_1_1xchunked__view.html b/classxt_1_1xchunked__view.html new file mode 100644 index 000000000..713961adf --- /dev/null +++ b/classxt_1_1xchunked__view.html @@ -0,0 +1,930 @@ + + + + + + + +xtensor: xt::xchunked_view< E > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xchunked_view< E > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xchunked_view<E>
 
using expression_type = std::decay_t<E>
 
using value_type = typename expression_type::value_type
 
using reference = typename expression_type::reference
 
using const_reference = typename expression_type::const_reference
 
using pointer = typename expression_type::pointer
 
using const_pointer = typename expression_type::const_pointer
 
using size_type = typename expression_type::size_type
 
using difference_type = typename expression_type::difference_type
 
using shape_type = svector<size_type>
 
using chunk_iterator = xchunk_iterator<self_type>
 
using const_chunk_iterator = xchunk_iterator<const self_type>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class OE, class S>
 xchunked_view (OE &&e, S &&chunk_shape)
 
template<class OE>
 xchunked_view (OE &&e)
 
void init ()
 
template<class OE>
std::enable_if_t<!is_chunked_t< OE >::value, xchunked_view< E > & > operator= (const OE &e)
 
template<class OE>
std::enable_if_t< is_chunked_t< OE >::value, xchunked_view< E > & > operator= (const OE &e)
 
size_type dimension () const noexcept
 
const shape_type & shape () const noexcept
 
const shape_type & chunk_shape () const noexcept
 
size_type grid_size () const noexcept
 
const shape_type & grid_shape () const noexcept
 
expression_type & expression () noexcept
 
const expression_type & expression () const noexcept
 
chunk_iterator chunk_begin ()
 
chunk_iterator chunk_end ()
 
const_chunk_iterator chunk_begin () const
 
const_chunk_iterator chunk_end () const
 
const_chunk_iterator chunk_cbegin () const
 
const_chunk_iterator chunk_cend () const
 
+

Detailed Description

+
template<class E>
+class xt::xchunked_view< E >
+

Definition at line 36 of file xchunked_view.hpp.

+

Member Typedef Documentation

+ +

◆ chunk_iterator

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::chunk_iterator = xchunk_iterator<self_type>
+
+ +

Definition at line 50 of file xchunked_view.hpp.

+ +
+
+ +

◆ const_chunk_iterator

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::const_chunk_iterator = xchunk_iterator<const self_type>
+
+ +

Definition at line 51 of file xchunked_view.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::const_pointer = typename expression_type::const_pointer
+
+ +

Definition at line 46 of file xchunked_view.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::const_reference = typename expression_type::const_reference
+
+ +

Definition at line 44 of file xchunked_view.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::difference_type = typename expression_type::difference_type
+
+ +

Definition at line 48 of file xchunked_view.hpp.

+ +
+
+ +

◆ expression_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::expression_type = std::decay_t<E>
+
+ +

Definition at line 41 of file xchunked_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::pointer = typename expression_type::pointer
+
+ +

Definition at line 45 of file xchunked_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::reference = typename expression_type::reference
+
+ +

Definition at line 43 of file xchunked_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::self_type = xchunked_view<E>
+
+ +

Definition at line 40 of file xchunked_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::shape_type = svector<size_type>
+
+ +

Definition at line 49 of file xchunked_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::size_type = typename expression_type::size_type
+
+ +

Definition at line 47 of file xchunked_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xchunked_view< E >::value_type = typename expression_type::value_type
+
+ +

Definition at line 42 of file xchunked_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xchunked_view() [1/2]

+ +
+
+
+template<class E>
+
+template<class OE, class S>
+ + + + + +
+ + + + + + + + + + + +
xt::xchunked_view< E >::xchunked_view (OE && e,
S && chunk_shape )
+ 		+inline
+
+ +

Definition at line 102 of file xchunked_view.hpp.

+ +
+
+ +

◆ xchunked_view() [2/2]

+ +
+
+
+template<class E>
+
+template<class OE>
+ + + + + +
+ + + + + + + +
xt::xchunked_view< E >::xchunked_view (OE && e)
+ 		+inline
+
+ +

Definition at line 114 of file xchunked_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ chunk_begin() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::chunk_begin ()
+ 		+inline
+
+ +

Definition at line 245 of file xchunked_view.hpp.

+ +
+
+ +

◆ chunk_begin() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::chunk_begin () const
+ 		+inline
+
+ +

Definition at line 258 of file xchunked_view.hpp.

+ +
+
+ +

◆ chunk_cbegin()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::chunk_cbegin () const
+ 		+inline
+
+ +

Definition at line 271 of file xchunked_view.hpp.

+ +
+
+ +

◆ chunk_cend()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::chunk_cend () const
+ 		+inline
+
+ +

Definition at line 277 of file xchunked_view.hpp.

+ +
+
+ +

◆ chunk_end() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::chunk_end ()
+ 		+inline
+
+ +

Definition at line 252 of file xchunked_view.hpp.

+ +
+
+ +

◆ chunk_end() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::chunk_end () const
+ 		+inline
+
+ +

Definition at line 265 of file xchunked_view.hpp.

+ +
+
+ +

◆ chunk_shape()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::chunk_shape () const
+ 		+inlinenoexcept
+
+ +

Definition at line 215 of file xchunked_view.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::dimension () const
+ 		+inlinenoexcept
+
+ +

Definition at line 203 of file xchunked_view.hpp.

+ +
+
+ +

◆ expression() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::expression () const
+ 		+inlinenoexcept
+
+ +

Definition at line 239 of file xchunked_view.hpp.

+ +
+
+ +

◆ expression() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::expression ()
+ 		+inlinenoexcept
+
+ +

Definition at line 233 of file xchunked_view.hpp.

+ +
+
+ +

◆ grid_shape()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::grid_shape () const
+ 		+inlinenoexcept
+
+ +

Definition at line 227 of file xchunked_view.hpp.

+ +
+
+ +

◆ grid_size()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::grid_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 221 of file xchunked_view.hpp.

+ +
+
+ +

◆ init()

+ +
+
+
+template<class E>
+ + + + + + + +
void xt::xchunked_view< E >::init ()
+
+ +

Definition at line 123 of file xchunked_view.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class E>
+
+template<class OE>
+ + + + + + + +
std::enable_if_t<!is_chunked_t< OE >::value, xchunked_view< E > & > xt::xchunked_view< E >::operator= (const OE & e)
+
+ +

Definition at line 153 of file xchunked_view.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class E>
+
+template<class OE>
+ + + + + + + +
std::enable_if_t< is_chunked_t< OE >::value, xchunked_view< E > & > xt::xchunked_view< E >::operator= (const OE & e)
+
+ +

Definition at line 167 of file xchunked_view.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xchunked_view< E >::shape () const
+ 		+inlinenoexcept
+
+ +

Definition at line 209 of file xchunked_view.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+
+ + + + diff --git a/classxt_1_1xconst__accessible-members.html b/classxt_1_1xconst__accessible-members.html new file mode 100644 index 000000000..12334b953 --- /dev/null +++ b/classxt_1_1xconst__accessible-members.html @@ -0,0 +1,146 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xconst_accessible< D > Member List
+
+
+ +

This is the complete list of members for xt::xconst_accessible< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
at(Args... args) const (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
at(Args... args) const -> const_referencext::xconst_accessible< D >inline
back() constxt::xconst_accessible< D >inline
const_reference typedef (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
derived_type typedef (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
dimension() const noexceptxt::xconst_accessible< D >inline
front() constxt::xconst_accessible< D >inline
in_bounds(Args... args) constxt::xconst_accessible< D >inline
inner_types typedef (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
operator=(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator=(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator[](const S &index) const (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
operator[](std::initializer_list< I > index) const (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
operator[](size_type i) const (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xconst_accessible< D >inline
operator[](std::initializer_list< I > index) const -> const_reference (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >inline
periodic(Args... args) const (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
periodic(Args... args) const -> const_referencext::xconst_accessible< D >inline
reference typedef (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
shape(size_type index) constxt::xconst_accessible< D >inline
size() const noexcept(noexcept(derived_cast().shape()))xt::xconst_accessible< D >inline
size_type typedef (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >
xconst_accessible()=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
xconst_accessible(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
xconst_accessible(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
~xconst_accessible()=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
+
+ + + + diff --git a/classxt_1_1xconst__accessible.html b/classxt_1_1xconst__accessible.html new file mode 100644 index 000000000..c0e99d42b --- /dev/null +++ b/classxt_1_1xconst__accessible.html @@ -0,0 +1,732 @@ + + + + + + + +xtensor: xt::xconst_accessible< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xconst_accessible< D > Class Template Reference
+
+
+ +

Base class for implementation of common expression constant access methods. + More...

+ +

#include <xaccessible.hpp>

+
+Inheritance diagram for xt::xconst_accessible< D >:
+
+
+ + +xt::xbroadcast< E, X > +xt::xgenerator< OF, OR, S > +xt::xgenerator< value_functor, value_closure, S > +xt::xgenerator< flag_functor, flag_closure, S > +xt::xaccessible< D > +xt::xreducer< Func, E, X, Opts > +xt::xscalar< xtl::closure_type_t< E > > +xt::xscalar< xtl::const_closure_type_t< E > > +xt::xscalar< T > +xt::xscalar< bool > +xt::xscalar< std::conditional_t< is_const, const_value_closure, value_closure > > +xt::xscalar< std::conditional_t< is_const, const_flag_closure, flag_closure > > +xt::xscalar< const_value_closure > +xt::xscalar< const_flag_closure > +xt::xview< uvt, S... > +xt::xview< uft, S... > +xt::xview< ucvt, S... > +xt::xview< ucft, S... > +xt::xview< UnderlyingContainer, Slices... > +xt::xview< E, S... > +xt::xcontainer< D > +xt::xfunctor_applier_base< D > +xt::xstrided_view_base< D > + +
+ + + + + + + + + + + + +

+Public Types

using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using size_type = typename inner_types::size_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+template<class... Args>
const_reference at (Args... args) const
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class I>
const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
+template<class... Args>
const_reference periodic (Args... args) const
 
template<class... Args>
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
template<class... Args>
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
template<class S>
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
template<class I>
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
template<class... Args>
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+ + + + + + + + + +

+Protected Member Functions

+ xconst_accessible (const xconst_accessible &)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
+

Detailed Description

+
template<class D>
+class xt::xconst_accessible< D >

Base class for implementation of common expression constant access methods.

+

The xaccessible class implements constant access methods common to all expressions.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xconst_accessible provides the interface.
+
+
+ +

Definition at line 29 of file xaccessible.hpp.

+

Member Typedef Documentation

+ +

◆ const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_accessible< D >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 36 of file xaccessible.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_accessible< D >::derived_type = D
+
+ +

Definition at line 33 of file xaccessible.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_accessible< D >::inner_types = xcontainer_inner_types<D>
+
+ +

Definition at line 34 of file xaccessible.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_accessible< D >::reference = typename inner_types::reference
+
+ +

Definition at line 35 of file xaccessible.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_accessible< D >::size_type = typename inner_types::size_type
+
+ +

Definition at line 37 of file xaccessible.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ at()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::at (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices should be equal to the number of dimensions of the expression.
+
+
+
Exceptions
+ + +
std::out_of_rangeif the number of argument is greater than the number of dimensions or if indices are out of bounds.
+
+
+ +

Definition at line 175 of file xaccessible.hpp.

+ +
+
+ +

◆ back()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::back () const
+ 		+inline
+
+ +

Returns a constant reference to last the element of the expression.

+ +

Definition at line 236 of file xaccessible.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::dimension () const
+ 		+inlinenoexcept
+
+ +

Returns the number of dimensions of the expression.

+ +

Definition at line 150 of file xaccessible.hpp.

+ +
+
+ +

◆ front()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::front () const
+ 		+inline
+
+ +

Returns a constant reference to first the element of the expression.

+ +

Definition at line 227 of file xaccessible.hpp.

+ +
+
+ +

◆ in_bounds()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
bool xt::xconst_accessible< D >::in_bounds (Args... args) const
+ 		+inline
+
+ +

Returns true only if the the specified position is a valid entry in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression.
+
+
+
Returns
bool
+ +

Definition at line 248 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [1/3]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::operator[] (const S & index) const -> disable_integral_t<S, const_reference> +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
indexa sequence of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices in the list should be equal or greater than the number of dimensions of the expression.
+
+
+ +

Definition at line 189 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [2/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 203 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [3/3]

+ +
+
+
+template<class D>
+
+template<class I>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::operator[] (std::initializer_list< I > index) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 197 of file xaccessible.hpp.

+ +
+
+ +

◆ periodic()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::periodic (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be integers, the number of indices should be equal to the number of dimensions of the expression.
+
+
+ +

Definition at line 217 of file xaccessible.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::shape (size_type index) const
+ 		+inline
+
+ +

Returns the i-th dimension of the expression.

+ +

Definition at line 159 of file xaccessible.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::size () const
+ 		+inlinenoexcept
+
+ +

Returns the size of the expression.

+ +

Definition at line 141 of file xaccessible.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xconst__accessible.js b/classxt_1_1xconst__accessible.js new file mode 100644 index 000000000..6075e00a3 --- /dev/null +++ b/classxt_1_1xconst__accessible.js @@ -0,0 +1,12 @@ +var classxt_1_1xconst__accessible = +[ + [ "at", "classxt_1_1xconst__accessible.html#a340069d14699c36602889101dd1f932a", null ], + [ "back", "classxt_1_1xconst__accessible.html#ae8c11bf107fb871f054e2194163778fd", null ], + [ "dimension", "classxt_1_1xconst__accessible.html#a4b1a7ad9b1f0863c672782e53eed3042", null ], + [ "front", "classxt_1_1xconst__accessible.html#a06f3bb2ce9e0c3081ef0ce0ae40d1fe8", null ], + [ "in_bounds", "classxt_1_1xconst__accessible.html#ace939a65a328afe7ef9241d4cc84b881", null ], + [ "operator[]", "classxt_1_1xconst__accessible.html#a125b98dd7a0ea4919f19b69256930ff8", null ], + [ "periodic", "classxt_1_1xconst__accessible.html#a34d4a20e640737443fd0a7266b77b2b2", null ], + [ "shape", "classxt_1_1xconst__accessible.html#aec0ae6f83f7e86f32e083cb6714af552", null ], + [ "size", "classxt_1_1xconst__accessible.html#a1a12c20a1915c492894e68c39053cd1b", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xconst__accessible.png b/classxt_1_1xconst__accessible.png new file mode 100644 index 000000000..977dcccaf Binary files /dev/null and b/classxt_1_1xconst__accessible.png differ diff --git a/classxt_1_1xconst__iterable-members.html b/classxt_1_1xconst__iterable-members.html new file mode 100644 index 000000000..45b5aa769 --- /dev/null +++ b/classxt_1_1xconst__iterable-members.html @@ -0,0 +1,180 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xconst_iterable< D > Member List
+
+
+ +

This is the complete list of members for xt::xconst_iterable< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
begin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
begin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
broadcast_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cbegin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cbegin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
cend() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cend(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
const_broadcast_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_layout_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_reverse_broadcast_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_reverse_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_reverse_layout_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_reverse_linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_stepper typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crbegin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crbegin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
crend() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crend(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
derived_type typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
end() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
end(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
get_cbegin(bool end_index) const noexcept -> const_layout_iterator< L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cbegin(const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cend(bool end_index) const noexcept -> const_layout_iterator< L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cend(const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_shape() const (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inlineprotected
get_stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
inner_shape_type typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
iterable_types typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
layout_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
rbegin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
rbegin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
rend() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
rend(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
reverse_broadcast_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
reverse_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
reverse_layout_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
reverse_linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
stepper typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
+
+ + + + diff --git a/classxt_1_1xconst__iterable.html b/classxt_1_1xconst__iterable.html new file mode 100644 index 000000000..6032ebd51 --- /dev/null +++ b/classxt_1_1xconst__iterable.html @@ -0,0 +1,1715 @@ + + + + + + + +xtensor: xt::xconst_iterable< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xconst_iterable< D > Class Template Reference
+
+
+ +

Base class for multidimensional iterable constant expressions. + More...

+ +

#include <xiterable.hpp>

+
+Inheritance diagram for xt::xconst_iterable< D >:
+
+
+ + +xt::xbroadcast< E, X > +xt::xgenerator< OF, OR, S > +xt::xgenerator< value_functor, value_closure, S > +xt::xgenerator< flag_functor, flag_closure, S > +xt::xiterable< xmasked_view< CTD, CTM > > +xt::xreducer< Func, E, X, Opts > +xt::xiterable< D > +xt::xmasked_view< CTD, CTM > +xt::xdynamic_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xdynamic_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xdynamic_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xdynamic_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xdynamic_view< CT, S, L, FST > +xt::xdynamic_view< E, S, L, typename FST::template rebind_t< E > > +xt::xindex_view< uvt, I > +xt::xindex_view< uft, I > +xt::xindex_view< ucvt, I > +xt::xindex_view< ucft, I > +xt::xindex_view< E, I > +xt::xscalar< xtl::closure_type_t< E > > +xt::xscalar< xtl::const_closure_type_t< E > > +xt::xscalar< T > +xt::xscalar< bool > +xt::xscalar< std::conditional_t< is_const, const_value_closure, value_closure > > +xt::xscalar< std::conditional_t< is_const, const_flag_closure, flag_closure > > +xt::xscalar< const_value_closure > +xt::xscalar< const_flag_closure > +xt::xcontiguous_iterable< D > +xt::xdynamic_view< CT, S, L, FST > +xt::xoptional_assembly_base< D > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using derived_type = D
 
using iterable_types = xiterable_inner_types<D>
 
using inner_shape_type = typename iterable_types::inner_shape_type
 
using stepper = typename iterable_types::stepper
 
using const_stepper = typename iterable_types::const_stepper
 
template<layout_type L>
using layout_iterator = xiterator<stepper, inner_shape_type*, L>
 
template<layout_type L>
using const_layout_iterator = xiterator<const_stepper, inner_shape_type*, L>
 
template<layout_type L>
using reverse_layout_iterator = std::reverse_iterator<layout_iterator<L>>
 
template<layout_type L>
using const_reverse_layout_iterator = std::reverse_iterator<const_layout_iterator<L>>
 
using linear_iterator = layout_iterator< ::xt::layout_type::row_major >
 
using const_linear_iterator = const_layout_iterator< ::xt::layout_type::row_major >
 
using reverse_linear_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
 
using const_reverse_linear_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
 
template<class S, layout_type L>
using broadcast_iterator = xiterator<stepper, S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = xiterator<const_stepper, S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = std::reverse_iterator<broadcast_iterator<S, L>>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = std::reverse_iterator<const_broadcast_iterator<S, L>>
 
using iterator = layout_iterator< ::xt::layout_type::row_major >
 
using const_iterator = const_layout_iterator< ::xt::layout_type::row_major >
 
using reverse_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
 
using const_reverse_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > cbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > cend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > crbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > crend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
Constant iterators
template<layout_type L>
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
Constant reverse iterators
template<layout_type L>
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
Constant broadcast iterators
template<layout_type L, class S>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Constant reverse broadcast iterators

template<layout_type L, class S>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
template<layout_type L>
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
template<layout_type L, class S>
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
template<layout_type L, class S>
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
template<class S>
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
const inner_shape_type & get_shape () const
 
+

Detailed Description

+
template<class D>
+class xt::xconst_iterable< D >

Base class for multidimensional iterable constant expressions.

+

The xconst_iterable class defines the interface for multidimensional constant expressions that can be iterated.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xconst_iterable provides the interface.
+
+
+ +

Definition at line 36 of file xiterable.hpp.

+

Member Typedef Documentation

+ +

◆ broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xconst_iterable< D >::broadcast_iterator = xiterator<stepper, S, L>
+
+ +

Definition at line 63 of file xiterable.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xconst_iterable< D >::const_broadcast_iterator = xiterator<const_stepper, S, L>
+
+ +

Definition at line 65 of file xiterable.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::const_iterator = const_layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 72 of file xiterable.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xconst_iterable< D >::const_layout_iterator = xiterator<const_stepper, inner_shape_type*, L>
+
+ +

Definition at line 51 of file xiterable.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::const_linear_iterator = const_layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 58 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xconst_iterable< D >::const_reverse_broadcast_iterator = std::reverse_iterator<const_broadcast_iterator<S, L>>
+
+ +

Definition at line 69 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::const_reverse_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 74 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xconst_iterable< D >::const_reverse_layout_iterator = std::reverse_iterator<const_layout_iterator<L>>
+
+ +

Definition at line 55 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::const_reverse_linear_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 60 of file xiterable.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::const_stepper = typename iterable_types::const_stepper
+
+ +

Definition at line 46 of file xiterable.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::derived_type = D
+
+ +

Definition at line 40 of file xiterable.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::inner_shape_type = typename iterable_types::inner_shape_type
+
+ +

Definition at line 43 of file xiterable.hpp.

+ +
+
+ +

◆ iterable_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::iterable_types = xiterable_inner_types<D>
+
+ +

Definition at line 42 of file xiterable.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::iterator = layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 71 of file xiterable.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xconst_iterable< D >::layout_iterator = xiterator<stepper, inner_shape_type*, L>
+
+ +

Definition at line 49 of file xiterable.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::linear_iterator = layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 57 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xconst_iterable< D >::reverse_broadcast_iterator = std::reverse_iterator<broadcast_iterator<S, L>>
+
+ +

Definition at line 67 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::reverse_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 73 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xconst_iterable< D >::reverse_layout_iterator = std::reverse_iterator<layout_iterator<L>>
+
+ +

Definition at line 53 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::reverse_linear_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 59 of file xiterable.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xconst_iterable< D >::stepper = typename iterable_types::stepper
+
+ +

Definition at line 45 of file xiterable.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::begin () const -> const_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 464 of file xiterable.hpp.

+ +
+
+ +

◆ begin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::begin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 571 of file xiterable.hpp.

+ +
+
+ +

◆ cbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::cbegin () const -> const_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 487 of file xiterable.hpp.

+ +
+
+ +

◆ cbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::cbegin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 599 of file xiterable.hpp.

+ +
+
+ +

◆ cend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::cend () const -> const_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 499 of file xiterable.hpp.

+ +
+
+ +

◆ cend() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::cend (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 613 of file xiterable.hpp.

+ +
+
+ +

◆ crbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::crbegin () const -> const_reverse_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 539 of file xiterable.hpp.

+ +
+
+ +

◆ crbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::crbegin (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 663 of file xiterable.hpp.

+ +
+
+ +

◆ crend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::crend () const -> const_reverse_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 551 of file xiterable.hpp.

+ +
+
+ +

◆ crend() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::crend (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 678 of file xiterable.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::end () const -> const_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 476 of file xiterable.hpp.

+ +
+
+ +

◆ end() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::end (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 585 of file xiterable.hpp.

+ +
+
+ +

◆ get_cbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::get_cbegin (bool end_index) const -> const_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 688 of file xiterable.hpp.

+ +
+
+ +

◆ get_cbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xconst_iterable< D >::get_cbegin (const S & shape,
bool end_index ) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 702 of file xiterable.hpp.

+ +
+
+ +

◆ get_cend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::get_cend (bool end_index) const -> const_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 695 of file xiterable.hpp.

+ +
+
+ +

◆ get_cend() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xconst_iterable< D >::get_cend (const S & shape,
bool end_index ) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 710 of file xiterable.hpp.

+ +
+
+ +

◆ get_shape()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::get_shape () const
+ 		+inlineprotected
+
+ +

Definition at line 732 of file xiterable.hpp.

+ +
+
+ +

◆ get_stepper_begin()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::get_stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 718 of file xiterable.hpp.

+ +
+
+ +

◆ get_stepper_end()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xconst_iterable< D >::get_stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 725 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::rbegin () const -> const_reverse_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 516 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::rbegin (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 633 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::rend () const -> const_reverse_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 528 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xconst_iterable< D >::rend (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 648 of file xiterable.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xiterable.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xconst__iterable.js b/classxt_1_1xconst__iterable.js new file mode 100644 index 000000000..d55a43b8f --- /dev/null +++ b/classxt_1_1xconst__iterable.js @@ -0,0 +1,19 @@ +var classxt_1_1xconst__iterable = +[ + [ "begin", "classxt_1_1xconst__iterable.html#a6ab0e76125fa876b97b53a813a3d4713", null ], + [ "begin", "classxt_1_1xconst__iterable.html#a095cfd6ccf0bb5696073af2c8536f8e9", null ], + [ "cbegin", "classxt_1_1xconst__iterable.html#a8e90c4de11331d25fcf27944833280af", null ], + [ "cbegin", "classxt_1_1xconst__iterable.html#a212ee6280ccfa5814e4f2c16d1880a84", null ], + [ "cend", "classxt_1_1xconst__iterable.html#a6b266693e1dfec18e39baf2d3b34c20e", null ], + [ "cend", "classxt_1_1xconst__iterable.html#abc45bc962caf2ab0978a775836c6b3b8", null ], + [ "crbegin", "classxt_1_1xconst__iterable.html#a425b0d85a0ffbb1752c6f45f211c471b", null ], + [ "crbegin", "classxt_1_1xconst__iterable.html#a6fdbad0911ef9a473a18f109eb33a7ba", null ], + [ "crend", "classxt_1_1xconst__iterable.html#a804a4b52bdfa60d1855f9081fb11fb13", null ], + [ "crend", "classxt_1_1xconst__iterable.html#a851fb3a86aacc069921e8719ec2a21e9", null ], + [ "end", "classxt_1_1xconst__iterable.html#a74906f6a3242a5a2b001e6a534007589", null ], + [ "end", "classxt_1_1xconst__iterable.html#a8ca771d1dda2e42203cfdaaebfeba601", null ], + [ "rbegin", "classxt_1_1xconst__iterable.html#a52be134ecb3d529fddf7e8ba888a59a0", null ], + [ "rbegin", "classxt_1_1xconst__iterable.html#a3671f77843974f6962cd425318c0ef00", null ], + [ "rend", "classxt_1_1xconst__iterable.html#ade7cb42ea93353d00bbb739743be090d", null ], + [ "rend", "classxt_1_1xconst__iterable.html#a634cb122a80a40c5c38ff2b4527e3f26", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xconst__iterable.png b/classxt_1_1xconst__iterable.png new file mode 100644 index 000000000..74bb68932 Binary files /dev/null and b/classxt_1_1xconst__iterable.png differ diff --git a/classxt_1_1xcontainer-members.html b/classxt_1_1xcontainer-members.html new file mode 100644 index 000000000..1adb166ff --- /dev/null +++ b/classxt_1_1xcontainer-members.html @@ -0,0 +1,308 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xcontainer< D > Member List
+
+
+ +

This is the complete list of members for xt::xcontainer< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
allocator_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
at(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
at(Args... args) const (defined in xt::xaccessible< D >)xt::xaccessible< D >private
back()xt::xcontainer< D >inline
xt::xaccessible::back() constxt::xaccessible< D >inlineprivate
backstrides() const noexceptxt::xcontainer< D >
backstrides_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
base_type typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >private
begin() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< D >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
bool_load_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< D >inline
cbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
cend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
const_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_container_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_pointer typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_reference typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_reverse_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_stepper typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
container_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
contiguous_layout (defined in xt::xcontainer< D >)xt::xcontainer< D >static
crbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
crend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
data() noexceptxt::xcontainer< D >inline
data() const noexceptxt::xcontainer< D >inline
data_alignment typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
data_element(size_type i) (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
data_element(size_type i) const (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
data_offset() const noexceptxt::xcontainer< D >inline
data_xbegin() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
data_xbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
data_xend(layout_type l, size_type offset) noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
data_xend(layout_type l, size_type offset) const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_cast() &noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_cast() const &noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_cast() &&noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
difference_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
dimension() const noexceptxt::xcontainer< D >
element(It first, It last) (defined in xt::xcontainer< D >)xt::xcontainer< D >
element(It first, It last) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
element(It first, It last) -> referencext::xcontainer< D >inline
element(It first, It last) const -> const_referencext::xcontainer< D >inline
end() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< D >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
fill(const T &value)xt::xcontainer< D >inline
flat(size_type i)xt::xcontainer< D >inline
flat(size_type i) constxt::xcontainer< D >inline
front()xt::xcontainer< D >inline
xt::xaccessible::front() constxt::xaccessible< D >inlineprivate
has_linear_assign(const S &strides) const noexceptxt::xcontainer< D >inline
inner_backstrides_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
inner_shape_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
inner_strides_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
inner_types typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
iterable_base typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
linear_begin() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_begin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_cbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_cend() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_crbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_crend() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_end() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_end() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
linear_rbegin() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_rbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_rend() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_rend() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_traits typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
load_simd(size_type i) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
load_simd(size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type > (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
operator()(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator()(Args... args) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator()(Args... args) -> referencext::xcontainer< D >inline
operator()(Args... args) const -> const_referencext::xcontainer< D >inline
operator=(const xcontainer &)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
operator=(xcontainer &&)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
operator=(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator=(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator=(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >private
operator=(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >private
operator[](const S &index) (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator[](std::initializer_list< I > index) (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator[](size_type i) (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
operator[](const S &index) const (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator[](std::initializer_list< I > index) const (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator[](size_type i) const (defined in xt::xaccessible< D >)xt::xaccessible< D >inlineprivate
periodic(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
periodic(Args... args) const (defined in xt::xaccessible< D >)xt::xaccessible< D >private
pointer typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
rbegin() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
reference typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
rend() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
reverse_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
select_const_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_const_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_iterator_impl typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
shape() const noexceptxt::xcontainer< D >
xt::xaccessible::shape(size_type index) constxt::xconst_accessible< D >inlineprivate
shape_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
simd_return_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
simd_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
simd_value_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
size() const noexceptxt::xcontainer< D >inline
size_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
static_layout (defined in xt::xcontainer< D >)xt::xcontainer< D >static
stepper typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_begin(const S &shape) noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_begin(const S &shape) const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
stepper_end(const S &shape, layout_type l) noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_end(const S &shape, layout_type l) noexcept -> stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
storage() noexceptxt::xcontainer< D >inline
storage() const noexceptxt::xcontainer< D >inline
storage_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
store_simd(size_type i, const simd &e) (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
strides() const noexceptxt::xcontainer< D >
strides_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
unchecked(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
unchecked(Args... args) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
unchecked(Args... args) -> referencext::xcontainer< D >inline
unchecked(Args... args) const -> const_referencext::xcontainer< D >inline
value_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
xaccessible< D > (defined in xt::xcontainer< D >)xt::xcontainer< D >friend
xconst_accessible< D > (defined in xt::xcontainer< D >)xt::xcontainer< D >friend
xcontainer()=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
xcontainer(const xcontainer &)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
xcontainer(xcontainer &&)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
xstepper (defined in xt::xcontainer< D >)xt::xcontainer< D >friend
~xcontainer()=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
+
+ + + + diff --git a/classxt_1_1xcontainer.html b/classxt_1_1xcontainer.html new file mode 100644 index 000000000..0b291dc56 --- /dev/null +++ b/classxt_1_1xcontainer.html @@ -0,0 +1,3145 @@ + + + + + + + +xtensor: xt::xcontainer< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Protected Member Functions | +Friends | +List of all members
+
xt::xcontainer< D > Class Template Reference
+
+
+ +

Base class for dense multidimensional containers. + More...

+ +

#include <xcontainer.hpp>

+
+Inheritance diagram for xt::xcontainer< D >:
+
+
+ + +xt::xcontiguous_iterable< D > +xt::xaccessible< D > +xt::xiterable< D > +xt::xfixed_container< typename storage_type::value_type, S, L, SH, Tag > +xt::xfixed_container< T, FSH, L, Sharable > +xt::xstrided_container< D > +xt::xarray_adaptor< value_container &, L, SC > +xt::xarray_adaptor< flag_container &, L, SC > +xt::xarray_adaptor< const value_container &, L, SC > +xt::xarray_adaptor< const flag_container &, L, SC > +xt::xarray_adaptor< EC, L, SC, xoptional_expression_tag > +xt::xarray_container< temporary_container_t< storage_type >, L, SC, Tag > +xt::xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > +xt::xarray_container< xtl::xoptional_vector< T, A, BC >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true >, xoptional_expression_tag > +xt::xarray_container< EC, L, SC, xoptional_expression_tag > +xt::xtensor_adaptor< value_container &, N, L > +xt::xtensor_adaptor< flag_container &, N, L > +xt::xtensor_adaptor< const value_container &, N, L > +xt::xtensor_adaptor< const flag_container &, N, L > +xt::xtensor_adaptor< EC, N, L, xoptional_expression_tag > +xt::xtensor_container< temporary_container_t< storage_type >, N, L, Tag > +xt::xtensor_container< uvector< T, A >, N, L > +xt::xtensor_container< xtl::xoptional_vector< T, A, BC >, N, L, xoptional_expression_tag > +xt::xtensor_container< std::vector< T, A >, 2, layout_type::row_major > +xt::xtensor_container< EC, N, L, xoptional_expression_tag > +xt::xtensor_view< EC, N, L, xoptional_expression_tag > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using storage_type = typename inner_types::storage_type
 
using allocator_type = allocator_type_t<std::decay_t<storage_type>>
 
using value_type = typename storage_type::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = typename storage_type::pointer
 
using const_pointer = typename storage_type::const_pointer
 
using size_type = typename inner_types::size_type
 
using difference_type = typename storage_type::difference_type
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = xt::bool_load_type<value_type>
 
using shape_type = typename inner_types::shape_type
 
using strides_type = typename inner_types::strides_type
 
using backstrides_type = typename inner_types::backstrides_type
 
using inner_shape_type = typename inner_types::inner_shape_type
 
using inner_strides_type = typename inner_types::inner_strides_type
 
using inner_backstrides_type = typename inner_types::inner_backstrides_type
 
using iterable_base = xcontiguous_iterable<D>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using accessible_base = xaccessible<D>
 
using data_alignment = xt_simd::container_alignment_t<storage_type>
 
using simd_type = xt_simd::simd_type<value_type>
 
using linear_iterator = typename iterable_base::linear_iterator
 
using const_linear_iterator = typename iterable_base::const_linear_iterator
 
using reverse_linear_iterator = typename iterable_base::reverse_linear_iterator
 
using const_reverse_linear_iterator = typename iterable_base::const_reverse_linear_iterator
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
using container_iterator = linear_iterator
 
using const_container_iterator = const_linear_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< D >
using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using iterable_base = xiterable<D>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
template<layout_type L>
using layout_iterator = typename iterable_base::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
 
using linear_traits = detail::linear_iterator_traits<D>
 
using linear_iterator = typename linear_traits::linear_iterator
 
using const_linear_iterator = typename linear_traits::const_linear_iterator
 
using reverse_linear_iterator = typename linear_traits::reverse_linear_iterator
 
using const_reverse_linear_iterator = typename linear_traits::const_reverse_linear_iterator
 
template<layout_type L, class It1, class It2>
using select_iterator_impl = std::conditional_t<L == static_layout, It1, It2>
 
template<layout_type L>
using select_iterator = select_iterator_impl<L, linear_iterator, layout_iterator<L>>
 
template<layout_type L>
using select_const_iterator = select_iterator_impl<L, const_linear_iterator, const_layout_iterator<L>>
 
template<layout_type L>
using select_reverse_iterator = select_iterator_impl<L, reverse_linear_iterator, reverse_layout_iterator<L>>
 
template<layout_type L>
using select_const_reverse_iterator
 
using iterator = select_iterator< ::xt::layout_type::row_major >
 
using const_iterator = select_const_iterator< ::xt::layout_type::row_major >
 
using reverse_iterator = select_reverse_iterator< ::xt::layout_type::row_major >
 
using const_reverse_iterator = select_const_reverse_iterator< ::xt::layout_type::row_major >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
reference element (It first, It last)
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class S>
stepper stepper_begin (const S &shape) noexcept
 
+template<class S>
stepper stepper_end (const S &shape, layout_type l) noexcept
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+template<class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+template<class... Args>
reference at (Args... args)
 
+template<class S>
disable_integral_t< S, reference > operator[] (const S &index)
 
+template<class I>
reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+template<class... Args>
reference periodic (Args... args)
 
Size and shape
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
Data
template<class T>
void fill (const T &value)
 Fills the container with the given value.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
template<class... Args>
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
template<class... Args>
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
template<class It>
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
- Public Member Functions inherited from xt::xcontiguous_iterable< D >
+template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L > begin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L > end () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > cbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > cend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L > rbegin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L > rend () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > crbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > crend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
template<layout_type L>
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L>
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L>
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
+ + + + + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = inner_types::layout
 
static constexpr bool contiguous_layout = static_layout != layout_type::dynamic
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< D >
static constexpr layout_type static_layout = inner_types::layout
 
+ + + + + + + + + +

+Protected Member Functions

+ xcontainer (const xcontainer &)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
+ + + + + + + + +

+Friends

template<class C>
class xstepper
 
class xaccessible< D >
 
class xconst_accessible< D >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
template<class align, class simd>
void store_simd (size_type i, const simd &e)
 
linear_iterator linear_begin () noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
template<class S>
auto stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
template<class alignment, class requested_type, std::size_t N>
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
+

Detailed Description

+
template<class D>
+class xt::xcontainer< D >

Base class for dense multidimensional containers.

+

The xcontainer class defines the interface for dense multidimensional container classes. It does not embed any data container, this responsibility is delegated to the inheriting classes.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xcontainer provides the interface.
+
+
+ +

Definition at line 69 of file xcontainer.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::accessible_base = xaccessible<D>
+
+ +

Definition at line 101 of file xcontainer.hpp.

+ +
+
+ +

◆ allocator_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::allocator_type = allocator_type_t<std::decay_t<storage_type>>
+
+ +

Definition at line 78 of file xcontainer.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::backstrides_type = typename inner_types::backstrides_type
+
+ +

Definition at line 91 of file xcontainer.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::bool_load_type = xt::bool_load_type<value_type>
+
+ +

Definition at line 87 of file xcontainer.hpp.

+ +
+
+ +

◆ const_container_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::const_container_iterator = const_linear_iterator
+
+ +

Definition at line 205 of file xcontainer.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::const_linear_iterator = typename iterable_base::const_linear_iterator
+
+ +

Definition at line 109 of file xcontainer.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::const_pointer = typename storage_type::const_pointer
+
+ +

Definition at line 83 of file xcontainer.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 81 of file xcontainer.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::const_reverse_linear_iterator = typename iterable_base::const_reverse_linear_iterator
+
+ +

Definition at line 111 of file xcontainer.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 99 of file xcontainer.hpp.

+ +
+
+ +

◆ container_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::container_iterator = linear_iterator
+
+ +

Definition at line 204 of file xcontainer.hpp.

+ +
+
+ +

◆ data_alignment

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::data_alignment = xt_simd::container_alignment_t<storage_type>
+
+ +

Definition at line 105 of file xcontainer.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::derived_type = D
+
+ +

Definition at line 74 of file xcontainer.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::difference_type = typename storage_type::difference_type
+
+ +

Definition at line 85 of file xcontainer.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::inner_backstrides_type = typename inner_types::inner_backstrides_type
+
+ +

Definition at line 95 of file xcontainer.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::inner_shape_type = typename inner_types::inner_shape_type
+
+ +

Definition at line 93 of file xcontainer.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::inner_strides_type = typename inner_types::inner_strides_type
+
+ +

Definition at line 94 of file xcontainer.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::inner_types = xcontainer_inner_types<D>
+
+ +

Definition at line 76 of file xcontainer.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::iterable_base = xcontiguous_iterable<D>
+
+ +

Definition at line 97 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::linear_iterator = typename iterable_base::linear_iterator
+
+ +

Definition at line 108 of file xcontainer.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::pointer = typename storage_type::pointer
+
+ +

Definition at line 82 of file xcontainer.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::reference = typename inner_types::reference
+
+ +

Definition at line 80 of file xcontainer.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::reverse_linear_iterator = typename iterable_base::reverse_linear_iterator
+
+ +

Definition at line 110 of file xcontainer.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::shape_type = typename inner_types::shape_type
+
+ +

Definition at line 89 of file xcontainer.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<class D>
+
+template<class requested_type>
+ + + + +
using xt::xcontainer< D >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 180 of file xcontainer.hpp.

+ +
+
+ +

◆ simd_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::simd_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 106 of file xcontainer.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 86 of file xcontainer.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::size_type = typename inner_types::size_type
+
+ +

Definition at line 84 of file xcontainer.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 98 of file xcontainer.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::storage_type = typename inner_types::storage_type
+
+ +

Definition at line 77 of file xcontainer.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::strides_type = typename inner_types::strides_type
+
+ +

Definition at line 90 of file xcontainer.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer< D >::value_type = typename storage_type::value_type
+
+ +

Definition at line 79 of file xcontainer.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ back()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::back ()
+ 		+inline
+
+ +

Returns a reference to the last element of the expression.

+ +

Definition at line 109 of file xaccessible.hpp.

+ +
+
+ +

◆ backstrides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::backstrides () const
+ 		+constexprnoexcept
+
+ +

Returns the backstrides of the container.

+ +

Definition at line 403 of file xcontainer.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xcontainer< D >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the container to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 619 of file xcontainer.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::data () const
+ 		+inlinenoexcept
+
+ +

Returns a constant pointer to the underlying array serving as element storage.

+

The pointer is such that range [data(); data() + size()] is always a valid range, even if the container is empty (data() is not is not dereferenceable in that case)

+ +

Definition at line 591 of file xcontainer.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::data ()
+ 		+inlinenoexcept
+
+ +

Returns a pointer to the underlying array serving as element storage.

+

The pointer is such that range [data(); data() + size()] is always a valid range, even if the container is empty (data() is not is not dereferenceable in that case)

+ +

Definition at line 580 of file xcontainer.hpp.

+ +
+
+ +

◆ data_element() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::data_element (size_type i)
+ 		+inline
+
+ +

Definition at line 651 of file xcontainer.hpp.

+ +
+
+ +

◆ data_element() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::data_element (size_type i) const
+ 		+inline
+
+ +

Definition at line 657 of file xcontainer.hpp.

+ +
+
+ +

◆ data_offset()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::data_offset () const
+ 		+inlinenoexcept
+
+ +

Returns the offset to the first element in the container.

+ +

Definition at line 600 of file xcontainer.hpp.

+ +
+
+ +

◆ data_xbegin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::data_xbegin () const
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 731 of file xcontainer.hpp.

+ +
+
+ +

◆ data_xbegin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::data_xbegin ()
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 725 of file xcontainer.hpp.

+ +
+
+ +

◆ data_xend() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xcontainer< D >::data_xend (layout_type l,
size_type offset ) const
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 743 of file xcontainer.hpp.

+ +
+
+ +

◆ data_xend() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xcontainer< D >::data_xend (layout_type l,
size_type offset )
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 737 of file xcontainer.hpp.

+ +
+
+ +

◆ derived_cast() [1/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::derived_cast () &&
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 645 of file xcontainer.hpp.

+ +
+
+ +

◆ derived_cast() [2/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::derived_cast () &
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 839 of file xcontainer.hpp.

+ +
+
+ +

◆ derived_cast() [3/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::derived_cast () const &
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 639 of file xcontainer.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::dimension () const
+ 		+constexprnoexcept
+
+ +

Returns the number of dimensions of the container.

+ +

Definition at line 376 of file xcontainer.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class D>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xcontainer< D >::element (It first,
It last ) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the container.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 534 of file xcontainer.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class D>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xcontainer< D >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the container.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 549 of file xcontainer.hpp.

+ +
+
+ +

◆ fill()

+ +
+
+
+template<class D>
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xcontainer< D >::fill (const T & value)
+ 		+inline
+
+ +

Fills the container with the given value.

+
Parameters
+ + +
valuethe value to fill the container with.
+
+
+ +

Definition at line 421 of file xcontainer.hpp.

+ +
+
+ +

◆ flat() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::flat (size_type i)
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).

+
Parameters
+ + +
iindex specifying the position in the storage. Must be smaller than the number of elements in the container.
+
+
+ +

Definition at line 669 of file xcontainer.hpp.

+ +
+
+ +

◆ flat() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::flat (size_type i) const
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).

+
Parameters
+ + +
iindex specifying the position in the storage. Must be smaller than the number of elements in the container.
+
+
+ +

Definition at line 682 of file xcontainer.hpp.

+ +
+
+ +

◆ front()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::front ()
+ 		+inline
+
+ +

Returns a reference to the first element of the expression.

+ +

Definition at line 108 of file xaccessible.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xcontainer< D >::has_linear_assign (const S & str) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 631 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_begin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 779 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_begin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 767 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 791 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 797 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 827 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 833 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_end() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 785 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_end() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 773 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_rbegin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 815 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_rbegin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_rbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 803 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_rend() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 821 of file xcontainer.hpp.

+ +
+
+ +

◆ linear_rend() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::linear_rend ()
+ 		+inlinenoexcept
+
+ +

Definition at line 809 of file xcontainer.hpp.

+ +
+
+ +

◆ load_simd()

+ +
+
+
+template<class D>
+
+template<class alignment, class requested_type, std::size_t N>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::load_simd (size_type i) const -> container_simd_return_type_t<storage_type, value_type, requested_type> +
+ 		+inline
+
+ +

Definition at line 759 of file xcontainer.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::operator() (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the container.

+
Parameters
+ + +
argsa list of indices specifying the position in the container. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 441 of file xcontainer.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the container.

+
Parameters
+ + +
argsa list of indices specifying the position in the container. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 457 of file xcontainer.hpp.

+ +
+
+ +

◆ operator[]()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 103 of file xaccessible.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::shape () const
+ 		+constexprnoexcept
+
+ +

Returns the shape of the container.

+ +

Definition at line 385 of file xcontainer.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::size () const
+ 		+inlinenoexcept
+
+ +

Returns the number of element in the container.

+ +

Definition at line 367 of file xcontainer.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 710 of file xcontainer.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::stepper_begin (const S & shape) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 694 of file xcontainer.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xcontainer< D >::stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 718 of file xcontainer.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xcontainer< D >::stepper_end (const S & shape,
layout_type l ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 702 of file xcontainer.hpp.

+ +
+
+ +

◆ storage() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::storage () const
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the buffer containing the elements of the container.

+ +

Definition at line 569 of file xcontainer.hpp.

+ +
+
+ +

◆ storage() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::storage ()
+ 		+inlinenoexcept
+
+ +

Returns a reference to the buffer containing the elements of the container.

+ +

Definition at line 559 of file xcontainer.hpp.

+ +
+
+ +

◆ store_simd()

+ +
+
+
+template<class D>
+
+template<class alignment, class simd>
+ + + + + +
+ + + + + + + + + + + +
void xt::xcontainer< D >::store_simd (size_type i,
const simd & e )
+ 		+inline
+
+ +

Definition at line 751 of file xcontainer.hpp.

+ +
+
+ +

◆ strides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::strides () const
+ 		+constexprnoexcept
+
+ +

Returns the strides of the container.

+ +

Definition at line 394 of file xcontainer.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::unchecked (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the container.

+
Parameters
+ + +
argsa list of indices specifying the position in the container. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the container, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 486 of file xcontainer.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer< D >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the container.

+
Parameters
+ + +
argsa list of indices specifying the position in the container. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the container, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
+ +

Definition at line 516 of file xcontainer.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xaccessible< D >
+ 		+friend
+
+ +

Definition at line 239 of file xcontainer.hpp.

+ +
+
+ +

◆ xconst_accessible< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xconst_accessible< D >
+ 		+friend
+
+ +

Definition at line 239 of file xcontainer.hpp.

+ +
+
+ +

◆ xstepper

+ +
+
+
+template<class D>
+
+template<class C>
+ + + + + +
+ + + + +
friend class xstepper
+ 		+friend
+
+ +

Definition at line 239 of file xcontainer.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
bool xt::xcontainer< D >::contiguous_layout = static_layout != layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 104 of file xcontainer.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
layout_type xt::xcontainer< D >::static_layout = inner_types::layout
+ 		+staticconstexpr
+
+ +

Definition at line 103 of file xcontainer.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xcontainer.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xcontainer.js b/classxt_1_1xcontainer.js new file mode 100644 index 000000000..189d66efe --- /dev/null +++ b/classxt_1_1xcontainer.js @@ -0,0 +1,26 @@ +var classxt_1_1xcontainer = +[ + [ "back", "classxt_1_1xcontainer.html#a905660a4d87f4d3e7b651bcf6bb690d0", null ], + [ "backstrides", "classxt_1_1xcontainer.html#a238a7ac8797b8afa4906e6445483aa1d", null ], + [ "broadcast_shape", "classxt_1_1xcontainer.html#a689eeba5b9b1b4e8943c335d39ecc240", null ], + [ "data", "classxt_1_1xcontainer.html#a4a86bf768a1595ab704198ed8171b07c", null ], + [ "data", "classxt_1_1xcontainer.html#a71249b300db5d1bbab81c1cf6a5843b2", null ], + [ "data_offset", "classxt_1_1xcontainer.html#a8a1a7ab7c076ce9b48301c42b825a83c", null ], + [ "dimension", "classxt_1_1xcontainer.html#a2a8d4b0a73c42555c56b87384b251f2d", null ], + [ "element", "classxt_1_1xcontainer.html#ac2d91aa6cdb9d2970b5505d55f462b61", null ], + [ "element", "classxt_1_1xcontainer.html#a9d3b8aa16501359595778305cdb6c3b4", null ], + [ "fill", "classxt_1_1xcontainer.html#af6898b9f125926922986af040eb90240", null ], + [ "flat", "classxt_1_1xcontainer.html#a416ecf1f18ce38fae7f93d98d0c238e6", null ], + [ "flat", "classxt_1_1xcontainer.html#a58f5504c365d5e9c0ff9783c60e586af", null ], + [ "front", "classxt_1_1xcontainer.html#ad36ac2c194e7e6f470548dad89e88ca2", null ], + [ "has_linear_assign", "classxt_1_1xcontainer.html#a5720f32fcd8bc068a5489eddcf7bd8b1", null ], + [ "operator()", "classxt_1_1xcontainer.html#a6bcf87fdd442aa26095837b359d9b4e8", null ], + [ "operator()", "classxt_1_1xcontainer.html#aeee2e07bb1f3e66193e5ef3432b4011a", null ], + [ "shape", "classxt_1_1xcontainer.html#a69d345a40906cb982d205357520792fc", null ], + [ "size", "classxt_1_1xcontainer.html#a1c0a41d160789e55b7bdfd797b3af1cb", null ], + [ "storage", "classxt_1_1xcontainer.html#a75322e16f42222403daa18be69efa7d7", null ], + [ "storage", "classxt_1_1xcontainer.html#a19d0a91c82d0c35e414cf160751a9cb5", null ], + [ "strides", "classxt_1_1xcontainer.html#a521fff0ce57a45da819d7e313b3133b4", null ], + [ "unchecked", "classxt_1_1xcontainer.html#ac47ed05e4abb19044244cb26307cf8dc", null ], + [ "unchecked", "classxt_1_1xcontainer.html#aa493271826c9bc5298a556949755e84a", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xcontainer.png b/classxt_1_1xcontainer.png new file mode 100644 index 000000000..46350edfa Binary files /dev/null and b/classxt_1_1xcontainer.png differ diff --git a/classxt_1_1xcontainer__semantic-members.html b/classxt_1_1xcontainer__semantic-members.html new file mode 100644 index 000000000..8bf14912c --- /dev/null +++ b/classxt_1_1xcontainer__semantic-members.html @@ -0,0 +1,194 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xcontainer_semantic< D > Member List
+
+
+ +

This is the complete list of members for xt::xcontainer_semantic< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< D >inline
assign_xexpression(const xexpression< E > &e) (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >
assign_xexpression(const xexpression< E > &e) -> derived_type & (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >inline
base_type typedef (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >
bit_and_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_or_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_xor_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
computed_assign(const xexpression< E > &e) (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >
computed_assign(const xexpression< E > &e) -> derived_type & (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >inline
derived_type typedef (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >
divides_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
minus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
modulus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
multiplies_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator%=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator&=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator*=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator+=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator-=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator/=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator=(const xcontainer_semantic &)=default (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >protected
operator=(xcontainer_semantic &&)=default (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >protected
operator=(const xexpression< E > &) (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >protected
operator=(const xexpression< E > &e) -> derived_type & (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >inline
operator=(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator^=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator|=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
plus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
scalar_computed_assign(const E &e, F &&f) (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >
scalar_computed_assign(const E &e, F &&f) -> derived_type & (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >inline
temporary_type typedef (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >
xcontainer_semantic()=default (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >protected
xcontainer_semantic(const xcontainer_semantic &)=default (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >protected
xcontainer_semantic(xcontainer_semantic &&)=default (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >protected
xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
~xcontainer_semantic()=default (defined in xt::xcontainer_semantic< D >)xt::xcontainer_semantic< D >protected
~xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
+
+ + + + diff --git a/classxt_1_1xcontainer__semantic.html b/classxt_1_1xcontainer__semantic.html new file mode 100644 index 000000000..0237793a2 --- /dev/null +++ b/classxt_1_1xcontainer__semantic.html @@ -0,0 +1,688 @@ + + + + + + + +xtensor: xt::xcontainer_semantic< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xcontainer_semantic< D > Class Template Reference
+
+
+ +

Implementation of the xsemantic_base interface for dense multidimensional containers. + More...

+ +

#include <xsemantic.hpp>

+
+Inheritance diagram for xt::xcontainer_semantic< D >:
+
+
+ + +xt::xsemantic_base< D > +xt::xarray_adaptor< value_container &, L, SC > +xt::xarray_adaptor< flag_container &, L, SC > +xt::xarray_adaptor< const value_container &, L, SC > +xt::xarray_adaptor< const flag_container &, L, SC > +xt::xarray_adaptor< EC, L, SC, xoptional_expression_tag > +xt::xarray_container< temporary_container_t< storage_type >, L, SC, Tag > +xt::xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > +xt::xarray_container< xtl::xoptional_vector< T, A, BC >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true >, xoptional_expression_tag > +xt::xarray_container< EC, L, SC, xoptional_expression_tag > +xt::xfixed_container< typename storage_type::value_type, S, L, SH, Tag > +xt::xfixed_container< T, FSH, L, Sharable > +xt::xoptional_assembly< raw_value_expression, raw_flag_expression > +xt::xtensor_adaptor< value_container &, N, L > +xt::xtensor_adaptor< flag_container &, N, L > +xt::xtensor_adaptor< const value_container &, N, L > +xt::xtensor_adaptor< const flag_container &, N, L > +xt::xtensor_adaptor< EC, N, L, xoptional_expression_tag > +xt::xtensor_container< temporary_container_t< storage_type >, N, L, Tag > +xt::xtensor_container< uvector< T, A >, N, L > +xt::xtensor_container< xtl::xoptional_vector< T, A, BC >, N, L, xoptional_expression_tag > +xt::xtensor_container< std::vector< T, A >, 2, layout_type::row_major > +xt::xtensor_container< EC, N, L, xoptional_expression_tag > + +
+ + + + + + + + + + + + + + + +

+Public Types

using base_type = xsemantic_base<D>
 
using derived_type = D
 
using temporary_type = typename base_type::temporary_type
 
- Public Types inherited from xt::xsemantic_base< D >
using base_type = select_expression_base_t<D>
 
using derived_type = typename base_type::derived_type
 
using temporary_type = typename xcontainer_inner_types<D>::temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
derived_type & assign_xexpression (const xexpression< E > &e)
 
+template<class E>
derived_type & computed_assign (const xexpression< E > &e)
 
+template<class E, class F>
derived_type & scalar_computed_assign (const E &e, F &&f)
 
Assign functions
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
template<class E>
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
template<class E>
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
template<class E, class F>
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< D >
+template<class E>
disable_xexpression< E, derived_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator^= (const E &)
 
+template<class E>
derived_type & operator+= (const xexpression< E > &)
 
+template<class E>
derived_type & operator-= (const xexpression< E > &)
 
+template<class E>
derived_type & operator*= (const xexpression< E > &)
 
+template<class E>
derived_type & operator/= (const xexpression< E > &)
 
+template<class E>
derived_type & operator%= (const xexpression< E > &)
 
+template<class E>
derived_type & operator&= (const xexpression< E > &)
 
+template<class E>
derived_type & operator|= (const xexpression< E > &)
 
+template<class E>
derived_type & operator^= (const xexpression< E > &)
 
+template<class E>
derived_type & assign (const xexpression< E > &)
 
+template<class E>
derived_type & plus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & minus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & multiplies_assign (const xexpression< E > &)
 
+template<class E>
derived_type & divides_assign (const xexpression< E > &)
 
+template<class E>
derived_type & modulus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_and_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_or_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_xor_assign (const xexpression< E > &)
 
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
template<class E>
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
template<class E>
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
template<class E>
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
template<class E>
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
template<class E>
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< D >
+ xsemantic_base (const xsemantic_base &)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class D>
+class xt::xcontainer_semantic< D >

Implementation of the xsemantic_base interface for dense multidimensional containers.

+

The xcontainer_semantic class is an implementation of the xsemantic_base interface for dense multidimensional containers.

+
Template Parameters
+ + +
Dthe derived type
+
+
+ +

Definition at line 177 of file xsemantic.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer_semantic< D >::base_type = xsemantic_base<D>
+
+ +

Definition at line 181 of file xsemantic.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer_semantic< D >::derived_type = D
+
+ +

Definition at line 182 of file xsemantic.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontainer_semantic< D >::temporary_type = typename base_type::temporary_type
+
+ +

Definition at line 183 of file xsemantic.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign_temporary()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer_semantic< D >::assign_temporary (temporary_type && tmp)
+ 		+inline
+
+ +

Assigns the temporary tmp to *this.

+
Parameters
+ + +
tmpthe temporary to assign.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 652 of file xsemantic.hpp.

+ +
+
+ +

◆ assign_xexpression()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer_semantic< D >::assign_xexpression (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 659 of file xsemantic.hpp.

+ +
+
+ +

◆ computed_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer_semantic< D >::computed_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 667 of file xsemantic.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xcontainer_semantic< D >::operator= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 683 of file xsemantic.hpp.

+ +
+
+ +

◆ scalar_computed_assign()

+ +
+
+
+template<class D>
+
+template<class E, class F>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xcontainer_semantic< D >::scalar_computed_assign (const E & e,
F && f ) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 675 of file xsemantic.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xsemantic.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xcontainer__semantic.js b/classxt_1_1xcontainer__semantic.js new file mode 100644 index 000000000..0786a8354 --- /dev/null +++ b/classxt_1_1xcontainer__semantic.js @@ -0,0 +1,4 @@ +var classxt_1_1xcontainer__semantic = +[ + [ "assign_temporary", "classxt_1_1xcontainer__semantic.html#aa6fec519f074fe655cd20aa1fd028dd3", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xcontainer__semantic.png b/classxt_1_1xcontainer__semantic.png new file mode 100644 index 000000000..c9e81fa2b Binary files /dev/null and b/classxt_1_1xcontainer__semantic.png differ diff --git a/classxt_1_1xcontiguous__iterable-members.html b/classxt_1_1xcontiguous__iterable-members.html new file mode 100644 index 000000000..45f895584 --- /dev/null +++ b/classxt_1_1xcontiguous__iterable-members.html @@ -0,0 +1,198 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xcontiguous_iterable< D > Member List
+
+
+ +

This is the complete list of members for xt::xcontiguous_iterable< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
begin() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< D >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
cend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
const_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_linear_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_linear_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_stepper typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
crend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
derived_type typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< D >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
inner_types typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
iterable_base typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
linear_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
linear_traits typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
rend() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
reverse_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_linear_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_const_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_const_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_iterator_impl typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
static_layout (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >static
stepper typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
xconst_iterable< D > (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >friend
xiterable< D > (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >friend
+
+ + + + diff --git a/classxt_1_1xcontiguous__iterable.html b/classxt_1_1xcontiguous__iterable.html new file mode 100644 index 000000000..75c888e93 --- /dev/null +++ b/classxt_1_1xcontiguous__iterable.html @@ -0,0 +1,2104 @@ + + + + + + + +xtensor: xt::xcontiguous_iterable< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xcontiguous_iterable< D > Class Template Reference
+
+
+ +

Base class for multidimensional iterable expressions with contiguous storage. + More...

+ +

#include <xiterable.hpp>

+
+Inheritance diagram for xt::xcontiguous_iterable< D >:
+
+
+ + +xt::xiterable< D > +xt::xcontainer< self_type > +xt::xcontainer< D > +xt::xstrided_container< self_type > +xt::xfixed_container< typename storage_type::value_type, S, L, SH, Tag > +xt::xfixed_container< T, FSH, L, Sharable > +xt::xstrided_container< D > +xt::xarray_adaptor< value_container &, L, SC > +xt::xarray_adaptor< flag_container &, L, SC > +xt::xarray_adaptor< const value_container &, L, SC > +xt::xarray_adaptor< const flag_container &, L, SC > +xt::xarray_adaptor< EC, L, SC, xoptional_expression_tag > +xt::xarray_container< temporary_container_t< storage_type >, L, SC, Tag > +xt::xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > +xt::xarray_container< xtl::xoptional_vector< T, A, BC >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true >, xoptional_expression_tag > +xt::xarray_container< EC, L, SC, xoptional_expression_tag > +xt::xtensor_adaptor< value_container &, N, L > +xt::xtensor_adaptor< flag_container &, N, L > +xt::xtensor_adaptor< const value_container &, N, L > +xt::xtensor_adaptor< const flag_container &, N, L > +xt::xtensor_adaptor< EC, N, L, xoptional_expression_tag > +xt::xtensor_container< temporary_container_t< storage_type >, N, L, Tag > +xt::xtensor_container< uvector< T, A >, N, L > +xt::xtensor_container< xtl::xoptional_vector< T, A, BC >, N, L, xoptional_expression_tag > +xt::xtensor_container< std::vector< T, A >, 2, layout_type::row_major > +xt::xtensor_container< EC, N, L, xoptional_expression_tag > +xt::xtensor_view< EC, N, L, xoptional_expression_tag > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using iterable_base = xiterable<D>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
template<layout_type L>
using layout_iterator = typename iterable_base::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
 
using linear_traits = detail::linear_iterator_traits<D>
 
using linear_iterator = typename linear_traits::linear_iterator
 
using const_linear_iterator = typename linear_traits::const_linear_iterator
 
using reverse_linear_iterator = typename linear_traits::reverse_linear_iterator
 
using const_reverse_linear_iterator = typename linear_traits::const_reverse_linear_iterator
 
template<layout_type L, class It1, class It2>
using select_iterator_impl = std::conditional_t<L == static_layout, It1, It2>
 
template<layout_type L>
using select_iterator = select_iterator_impl<L, linear_iterator, layout_iterator<L>>
 
template<layout_type L>
using select_const_iterator = select_iterator_impl<L, const_linear_iterator, const_layout_iterator<L>>
 
template<layout_type L>
using select_reverse_iterator = select_iterator_impl<L, reverse_linear_iterator, reverse_layout_iterator<L>>
 
template<layout_type L>
using select_const_reverse_iterator
 
using iterator = select_iterator< ::xt::layout_type::row_major >
 
using const_iterator = select_const_iterator< ::xt::layout_type::row_major >
 
using reverse_iterator = select_reverse_iterator< ::xt::layout_type::row_major >
 
using const_reverse_iterator = select_const_reverse_iterator< ::xt::layout_type::row_major >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L > begin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L > end () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > cbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > cend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L > rbegin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L > rend () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > crbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > crend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
Iterators
template<layout_type L>
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L>
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L>
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
Reverse iterators
template<layout_type L>
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
Broadcast iterators
template<layout_type L, class S>
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
+ + + +

+Static Public Attributes

static constexpr layout_type static_layout = inner_types::layout
 
+ + + + + +

+Friends

class xiterable< D >
 
class xconst_iterable< D >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + +

Reverse broadcast iterators

template<layout_type L, class S>
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
+

Detailed Description

+
template<class D>
+class xt::xcontiguous_iterable< D >

Base class for multidimensional iterable expressions with contiguous storage.

+

The xcontiguous_iterable class defines the interface for multidimensional expressions with contiguous that can be iterated.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xcontiguous_iterable provides the interface.
+
+
+ +

Definition at line 311 of file xiterable.hpp.

+

Member Typedef Documentation

+ +

◆ broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
+
+ +

Definition at line 351 of file xiterable.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
+
+ +

Definition at line 353 of file xiterable.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::const_iterator = select_const_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 381 of file xiterable.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
+
+ +

Definition at line 343 of file xiterable.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::const_linear_iterator = typename linear_traits::const_linear_iterator
+
+ +

Definition at line 361 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 357 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::const_reverse_iterator = select_const_reverse_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 383 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
+
+ +

Definition at line 347 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::const_reverse_linear_iterator = typename linear_traits::const_reverse_linear_iterator
+
+ +

Definition at line 363 of file xiterable.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 321 of file xiterable.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::derived_type = D
+
+ +

Definition at line 315 of file xiterable.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::inner_types = xcontainer_inner_types<D>
+
+ +

Definition at line 317 of file xiterable.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::iterable_base = xiterable<D>
+
+ +

Definition at line 319 of file xiterable.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::iterator = select_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 380 of file xiterable.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::layout_iterator = typename iterable_base::template layout_iterator<L>
+
+ +

Definition at line 341 of file xiterable.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::linear_iterator = typename linear_traits::linear_iterator
+
+ +

Definition at line 360 of file xiterable.hpp.

+ +
+
+ +

◆ linear_traits

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::linear_traits = detail::linear_iterator_traits<D>
+
+ +

Definition at line 359 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 355 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::reverse_iterator = select_reverse_iterator< ::xt::layout_type::row_major >
+
+ +

Definition at line 382 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
+
+ +

Definition at line 345 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::reverse_linear_iterator = typename linear_traits::reverse_linear_iterator
+
+ +

Definition at line 362 of file xiterable.hpp.

+ +
+
+ +

◆ select_const_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::select_const_iterator = select_iterator_impl<L, const_linear_iterator, const_layout_iterator<L>>
+
+ +

Definition at line 371 of file xiterable.hpp.

+ +
+
+ +

◆ select_const_reverse_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::select_const_reverse_iterator
+
+Initial value:
select_iterator_impl<
+
L,
+
const_reverse_linear_iterator,
+
const_reverse_layout_iterator<L>>
+
+

Definition at line 375 of file xiterable.hpp.

+ +
+
+ +

◆ select_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::select_iterator = select_iterator_impl<L, linear_iterator, layout_iterator<L>>
+
+ +

Definition at line 369 of file xiterable.hpp.

+ +
+
+ +

◆ select_iterator_impl

+ +
+
+
+template<class D>
+
+template<layout_type L, class It1, class It2>
+ + + + +
using xt::xcontiguous_iterable< D >::select_iterator_impl = std::conditional_t<L == static_layout, It1, It2>
+
+ +

Definition at line 366 of file xiterable.hpp.

+ +
+
+ +

◆ select_reverse_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xcontiguous_iterable< D >::select_reverse_iterator = select_iterator_impl<L, reverse_linear_iterator, reverse_layout_iterator<L>>
+
+ +

Definition at line 373 of file xiterable.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xcontiguous_iterable< D >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 320 of file xiterable.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::begin () const -> select_const_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 986 of file xiterable.hpp.

+ +
+
+ +

◆ begin() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::begin () -> select_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 949 of file xiterable.hpp.

+ +
+
+ +

◆ begin() [3/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::begin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1187 of file xiterable.hpp.

+ +
+
+ +

◆ begin() [4/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::begin (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1159 of file xiterable.hpp.

+ +
+
+ +

◆ cbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::cbegin () const -> select_const_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1009 of file xiterable.hpp.

+ +
+
+ +

◆ cbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::cbegin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1215 of file xiterable.hpp.

+ +
+
+ +

◆ cend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::cend () const -> select_const_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1028 of file xiterable.hpp.

+ +
+
+ +

◆ cend() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::cend (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1230 of file xiterable.hpp.

+ +
+
+ +

◆ crbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::crbegin () const -> select_const_reverse_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1112 of file xiterable.hpp.

+ +
+
+ +

◆ crbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::crbegin (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1308 of file xiterable.hpp.

+ +
+
+ +

◆ crend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::crend () const -> select_const_reverse_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1131 of file xiterable.hpp.

+ +
+
+ +

◆ crend() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::crend (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1323 of file xiterable.hpp.

+ +
+
+ +

◆ end() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::end () const -> select_const_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 998 of file xiterable.hpp.

+ +
+
+ +

◆ end() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::end () -> select_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 968 of file xiterable.hpp.

+ +
+
+ +

◆ end() [3/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::end (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1201 of file xiterable.hpp.

+ +
+
+ +

◆ end() [4/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::end (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1173 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rbegin () const -> select_const_reverse_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1089 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rbegin () -> select_reverse_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1052 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [3/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rbegin (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1278 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [4/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rbegin (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1250 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rend () const -> select_const_reverse_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1101 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rend () -> select_reverse_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1071 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [3/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rend (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1293 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [4/4]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xcontiguous_iterable< D >::rend (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1264 of file xiterable.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xconst_iterable< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xconst_iterable< D >
+ 		+friend
+
+ +

Definition at line 444 of file xiterable.hpp.

+ +
+
+ +

◆ xiterable< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xiterable< D >
+ 		+friend
+
+ +

Definition at line 444 of file xiterable.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ static_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
layout_type xt::xcontiguous_iterable< D >::static_layout = inner_types::layout
+ 		+staticconstexpr
+
+ +

Definition at line 323 of file xiterable.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xiterable.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xcontiguous__iterable.js b/classxt_1_1xcontiguous__iterable.js new file mode 100644 index 000000000..2bd427354 --- /dev/null +++ b/classxt_1_1xcontiguous__iterable.js @@ -0,0 +1,27 @@ +var classxt_1_1xcontiguous__iterable = +[ + [ "begin", "classxt_1_1xcontiguous__iterable.html#aa37724c4f2fe4ed455f37a2a485dcebc", null ], + [ "begin", "classxt_1_1xcontiguous__iterable.html#ac598e11fd3eb83a2dcb5c74582ffd95a", null ], + [ "begin", "classxt_1_1xcontiguous__iterable.html#a3b0ee4efcc6ed36094e02631279cb3ce", null ], + [ "begin", "classxt_1_1xcontiguous__iterable.html#aa93641d4488c4ddb95274b41df89401f", null ], + [ "cbegin", "classxt_1_1xcontiguous__iterable.html#a68fed899dcdd91ba8ffe1438f329e0fc", null ], + [ "cbegin", "classxt_1_1xcontiguous__iterable.html#aa38da69077754acd8e5daf5f010b8591", null ], + [ "cend", "classxt_1_1xcontiguous__iterable.html#a2f1e2287962220db88240b3a0e5cf196", null ], + [ "cend", "classxt_1_1xcontiguous__iterable.html#a93eb3f286ccab925d621ef1b87e6d126", null ], + [ "crbegin", "classxt_1_1xcontiguous__iterable.html#ab363ab0f7faf25ed137b432eeaca6f43", null ], + [ "crbegin", "classxt_1_1xcontiguous__iterable.html#a74bc69cf0cbfcb235ec3ca8fe75b962a", null ], + [ "crend", "classxt_1_1xcontiguous__iterable.html#aec3659b2356b81494ebfcb5a4bc0482e", null ], + [ "crend", "classxt_1_1xcontiguous__iterable.html#a0b849e0972151523dd2bf988fe90c7da", null ], + [ "end", "classxt_1_1xcontiguous__iterable.html#a8e0a8bdffdcfd3c5bc80f358a6931f9f", null ], + [ "end", "classxt_1_1xcontiguous__iterable.html#a18eb1a595021e73f682b8443ea50f1ec", null ], + [ "end", "classxt_1_1xcontiguous__iterable.html#a11d0a0ce2bbaef8f6dda78febe364fec", null ], + [ "end", "classxt_1_1xcontiguous__iterable.html#ad75c7cb209c82c2d3ea6fa9e696f329e", null ], + [ "rbegin", "classxt_1_1xcontiguous__iterable.html#a34ab77bf7e6f44cf32100dfa19016985", null ], + [ "rbegin", "classxt_1_1xcontiguous__iterable.html#a9baaf955c445124c0ce0b15e46e9ea67", null ], + [ "rbegin", "classxt_1_1xcontiguous__iterable.html#af72e9e4372c87685b932899a7a411b2f", null ], + [ "rbegin", "classxt_1_1xcontiguous__iterable.html#a2464771d6d90297666b1e7e40ff21f70", null ], + [ "rend", "classxt_1_1xcontiguous__iterable.html#a0fca0441c61348b6eb092456e123b869", null ], + [ "rend", "classxt_1_1xcontiguous__iterable.html#ad8f400de36b11a40a49517ebe2f2f1fa", null ], + [ "rend", "classxt_1_1xcontiguous__iterable.html#a3b9ef9be65f2c10776ee7055f4067bed", null ], + [ "rend", "classxt_1_1xcontiguous__iterable.html#ab805bb1e5bd7b9a0d22fe8fcda0ffeb8", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xcontiguous__iterable.png b/classxt_1_1xcontiguous__iterable.png new file mode 100644 index 000000000..af8af9044 Binary files /dev/null and b/classxt_1_1xcontiguous__iterable.png differ diff --git a/classxt_1_1xdrop__slice-members.html b/classxt_1_1xdrop__slice-members.html new file mode 100644 index 000000000..45775cb96 --- /dev/null +++ b/classxt_1_1xdrop__slice-members.html @@ -0,0 +1,137 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xdrop_slice< T > Member List
+
+
+ +

This is the complete list of members for xt::xdrop_slice< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
container_type typedef (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >
contains(size_type i) const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
convert() const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
normalize(std::size_t s) (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
operator xdrop_slice< S >() const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
operator!=(const self_type &rhs) const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
operator()(size_type i) const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
operator==(const self_type &rhs) const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
revert_index(std::size_t i) const (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
self_type typedef (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >
size() const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
size_type typedef (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >
step_size(std::size_t i, std::size_t n=1) const noexcept (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
xdrop_slice (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >friend
xdrop_slice(C &cont) (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inlineexplicit
xdrop_slice(container_type &&cont) (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inlineexplicit
xdrop_slice(std::initializer_list< S > t) (defined in xt::xdrop_slice< T >)xt::xdrop_slice< T >inline
+
+ + + + diff --git a/classxt_1_1xdrop__slice.html b/classxt_1_1xdrop__slice.html new file mode 100644 index 000000000..9a849591b --- /dev/null +++ b/classxt_1_1xdrop__slice.html @@ -0,0 +1,683 @@ + + + + + + + +xtensor: xt::xdrop_slice< T > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xdrop_slice< T > Class Template Reference
+
+
+
+Inheritance diagram for xt::xdrop_slice< T >:
+
+
+ + +xt::xslice< xdrop_slice< T > > + +
+ + + + + + + + + + + +

+Public Types

using container_type = svector<T>
 
using size_type = typename container_type::value_type
 
using self_type = xdrop_slice<T>
 
- Public Types inherited from xt::xslice< xdrop_slice< T > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class C>
+requires (!detail::is_xdrop_slice<std::decay_t<C>>::value)
 xdrop_slice (C &cont)
 
 xdrop_slice (container_type &&cont)
 
template<class S>
 xdrop_slice (std::initializer_list< S > t)
 
template<std::convertible_to< T > S>
 operator xdrop_slice< S > () const noexcept
 
template<std::convertible_to< T > S>
xdrop_slice< S > convert () const noexcept
 
size_type operator() (size_type i) const noexcept
 
size_type size () const noexcept
 
void normalize (std::size_t s)
 
size_type step_size (std::size_t i, std::size_t n=1) const noexcept
 
size_type revert_index (std::size_t i) const
 
bool contains (size_type i) const noexcept
 
bool operator== (const self_type &rhs) const noexcept
 
bool operator!= (const self_type &rhs) const noexcept
 
- Public Member Functions inherited from xt::xslice< xdrop_slice< T > >
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xslice< xdrop_slice< T > >
+ xslice (const xslice &)=default
 
+ xslice (xslice &&)=default
 
+xslice & operator= (const xslice &)=default
 
+xslice & operator= (xslice &&)=default
 
+

Detailed Description

+
template<class T>
+class xt::xdrop_slice< T >
+

Definition at line 431 of file xslice.hpp.

+

Member Typedef Documentation

+ +

◆ container_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xdrop_slice< T >::container_type = svector<T>
+
+ +

Definition at line 435 of file xslice.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xdrop_slice< T >::self_type = xdrop_slice<T>
+
+ +

Definition at line 437 of file xslice.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xdrop_slice< T >::size_type = typename container_type::value_type
+
+ +

Definition at line 436 of file xslice.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xdrop_slice() [1/3]

+ +
+
+
+template<class T>
+requires (!detail::is_xdrop_slice<std::decay_t<C>>::value)
+
+template<class C>
+requires (!detail::is_xdrop_slice<std::decay_t<C>>::value)
+ + + + + +
+ + + + + + + +
xt::xdrop_slice< T >::xdrop_slice (C & cont)
+ 		+inlineexplicit
+
+ +

Definition at line 1429 of file xslice.hpp.

+ +
+
+ +

◆ xdrop_slice() [2/3]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
xt::xdrop_slice< T >::xdrop_slice (container_type && cont)
+ 		+inlineexplicit
+
+ +

Definition at line 1436 of file xslice.hpp.

+ +
+
+ +

◆ xdrop_slice() [3/3]

+ +
+
+
+template<class T>
+
+template<class S>
+ + + + + +
+ + + + + + + +
xt::xdrop_slice< T >::xdrop_slice (std::initializer_list< S > t)
+ 		+inline
+
+ +

Definition at line 1443 of file xslice.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ contains()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xdrop_slice< T >::contains (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1583 of file xslice.hpp.

+ +
+
+ +

◆ convert()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xdrop_slice< S > xt::xdrop_slice< T >::convert () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1497 of file xslice.hpp.

+ +
+
+ +

◆ normalize()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xdrop_slice< T >::normalize (std::size_t s)
+ 		+inline
+
+ +

Definition at line 1503 of file xslice.hpp.

+ +
+
+ +

◆ operator xdrop_slice< S >()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xt::xdrop_slice< T >::operator xdrop_slice< S > () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1459 of file xslice.hpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xdrop_slice< T >::operator!= (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1595 of file xslice.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xdrop_slice< T >::operator() (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1531 of file xslice.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xdrop_slice< T >::operator== (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1589 of file xslice.hpp.

+ +
+
+ +

◆ revert_index()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xdrop_slice< T >::revert_index (std::size_t i) const
+ 		+inline
+
+ +

Definition at line 1564 of file xslice.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xdrop_slice< T >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1545 of file xslice.hpp.

+ +
+
+ +

◆ step_size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xdrop_slice< T >::step_size (std::size_t i,
std::size_t n = 1 ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1551 of file xslice.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xdrop_slice

+ +
+
+
+template<class T>
+
+template<class S>
+ + + + + +
+ + + + +
friend class xdrop_slice
+ 		+friend
+
+ +

Definition at line 478 of file xslice.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xslice.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xdrop__slice.png b/classxt_1_1xdrop__slice.png new file mode 100644 index 000000000..44b19e344 Binary files /dev/null and b/classxt_1_1xdrop__slice.png differ diff --git a/classxt_1_1xdummy__iterator-members.html b/classxt_1_1xdummy__iterator-members.html new file mode 100644 index 000000000..560bc8b0a --- /dev/null +++ b/classxt_1_1xdummy__iterator-members.html @@ -0,0 +1,136 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xdummy_iterator< is_const, CT > Member List
+
+
+ +

This is the complete list of members for xt::xdummy_iterator< is_const, CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >
equal(const self_type &rhs) const noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
iterator_category typedef (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >
less_than(const self_type &rhs) const noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
operator*() const noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
operator++() noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
operator+=(difference_type n) noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
operator-(const self_type &rhs) const noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
operator--() noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
operator-=(difference_type n) noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inline
pointer typedef (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >
reference typedef (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >
self_type typedef (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >
storage_type typedef (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >
value_type typedef (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >
xdummy_iterator(storage_type *c) noexcept (defined in xt::xdummy_iterator< is_const, CT >)xt::xdummy_iterator< is_const, CT >inlineexplicit
+
+ + + + diff --git a/classxt_1_1xdummy__iterator.html b/classxt_1_1xdummy__iterator.html new file mode 100644 index 000000000..eb36b5737 --- /dev/null +++ b/classxt_1_1xdummy__iterator.html @@ -0,0 +1,564 @@ + + + + + + + +xtensor: xt::xdummy_iterator< is_const, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xdummy_iterator< is_const, CT > Class Template Reference
+
+
+
+Inheritance diagram for xt::xdummy_iterator< is_const, CT >:
+
+
+ +
+ + + + + + + + + + + + + + + + +

+Public Types

using self_type = xdummy_iterator<is_const, CT>
 
using storage_type = std::conditional_t<is_const, const xscalar<CT>, xscalar<CT>>
 
using value_type = typename storage_type::value_type
 
using reference = detail::dummy_reference_t<is_const, CT>
 
using pointer = detail::dummy_pointer_t<is_const, CT>
 
using difference_type = typename storage_type::difference_type
 
using iterator_category = std::random_access_iterator_tag
 
+ + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xdummy_iterator (storage_type *c) noexcept
 
self_type & operator++ () noexcept
 
self_type & operator-- () noexcept
 
self_type & operator+= (difference_type n) noexcept
 
self_type & operator-= (difference_type n) noexcept
 
difference_type operator- (const self_type &rhs) const noexcept
 
reference operator* () const noexcept
 
bool equal (const self_type &rhs) const noexcept
 
bool less_than (const self_type &rhs) const noexcept
 
+

Detailed Description

+
template<bool is_const, class CT>
+class xt::xdummy_iterator< is_const, CT >
+

Definition at line 409 of file xscalar.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xdummy_iterator< is_const, CT >::difference_type = typename storage_type::difference_type
+
+ +

Definition at line 424 of file xscalar.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xdummy_iterator< is_const, CT >::iterator_category = std::random_access_iterator_tag
+
+ +

Definition at line 425 of file xscalar.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xdummy_iterator< is_const, CT >::pointer = detail::dummy_pointer_t<is_const, CT>
+
+ +

Definition at line 423 of file xscalar.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xdummy_iterator< is_const, CT >::reference = detail::dummy_reference_t<is_const, CT>
+
+ +

Definition at line 422 of file xscalar.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xdummy_iterator< is_const, CT >::self_type = xdummy_iterator<is_const, CT>
+
+ +

Definition at line 418 of file xscalar.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xdummy_iterator< is_const, CT >::storage_type = std::conditional_t<is_const, const xscalar<CT>, xscalar<CT>>
+
+ +

Definition at line 419 of file xscalar.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xdummy_iterator< is_const, CT >::value_type = typename storage_type::value_type
+
+ +

Definition at line 421 of file xscalar.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xdummy_iterator()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
xt::xdummy_iterator< is_const, CT >::xdummy_iterator (storage_type * c)
+ 		+inlineexplicitnoexcept
+
+ +

Definition at line 1032 of file xscalar.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ equal()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
bool xt::xdummy_iterator< is_const, CT >::equal (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1074 of file xscalar.hpp.

+ +
+
+ +

◆ less_than()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
bool xt::xdummy_iterator< is_const, CT >::less_than (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1080 of file xscalar.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
auto xt::xdummy_iterator< is_const, CT >::operator* () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1068 of file xscalar.hpp.

+ +
+
+ +

◆ operator++()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
auto xt::xdummy_iterator< is_const, CT >::operator++ ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1038 of file xscalar.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
auto xt::xdummy_iterator< is_const, CT >::operator+= (difference_type n)
+ 		+inlinenoexcept
+
+ +

Definition at line 1050 of file xscalar.hpp.

+ +
+
+ +

◆ operator-()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
auto xt::xdummy_iterator< is_const, CT >::operator- (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1062 of file xscalar.hpp.

+ +
+
+ +

◆ operator--()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
auto xt::xdummy_iterator< is_const, CT >::operator-- ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1044 of file xscalar.hpp.

+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
auto xt::xdummy_iterator< is_const, CT >::operator-= (difference_type n)
+ 		+inlinenoexcept
+
+ +

Definition at line 1056 of file xscalar.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xscalar.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xdummy__iterator.png b/classxt_1_1xdummy__iterator.png new file mode 100644 index 000000000..71d995f3f Binary files /dev/null and b/classxt_1_1xdummy__iterator.png differ diff --git a/classxt_1_1xdynamic__view-members.html b/classxt_1_1xdynamic__view-members.html new file mode 100644 index 000000000..e6e0da8df --- /dev/null +++ b/classxt_1_1xdynamic__view-members.html @@ -0,0 +1,356 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xdynamic_view< CT, S, L, FST > Member List
+
+
+ +

This is the complete list of members for xt::xdynamic_view< CT, S, L, FST >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
adjust_element_offset(offset_type offset, It first, It last) const noexcept -> offset_type (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
adjust_offset(offset_type offset, T idx, Args... args) const noexcept -> offset_type (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
adjust_offset_impl(offset_type offset, size_type idx_offset, T idx, Args... args) const noexcept -> offset_type (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
assign_temporary(temporary_type &&)xt::xview_semantic< D >inline
assign_xexpression(const xexpression< E > &e) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
assign_xexpression(const xexpression< E > &e) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
backstrides_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
base_index_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
base_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
begin() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
begin(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
begin() noexcept -> layout_iterator< L >xt::xiterable< D >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< D >inline
begin() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
begin(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
bit_and_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_or_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_xor_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bool_load_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
broadcast_shape(O &shape, bool reuse_cache=false) constxt::xdynamic_view< CT, S, L, FST >
build_view(E &&e) const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
build_view(E &&e) const -> rebind_t< E > (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
cbegin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cbegin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
cend() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cend(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
computed_assign(const xexpression< E > &e) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
computed_assign(const xexpression< E > &e) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
const_broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_container_iterator typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
const_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_pointer typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
const_reference typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
const_reverse_broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_reverse_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_reverse_layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_reverse_linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_stepper typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
container_iterator typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
contiguous_layout (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >static
crbegin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crbegin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
crend() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crend(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
data() noexcept=delete (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
data() const noexcept=delete (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
data_offset() const noexcept (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
derived_type typedef (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
derived_type typedef (defined in xt::xiterable< D >)xt::xiterable< D >
derived_type typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >private
difference_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
divides_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
element(It first, It last) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
element(It first, It last) const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
element(It first, It last) -> reference (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
element(It first, It last) const -> const_reference (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
end() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
end(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
end() noexcept -> layout_iterator< L >xt::xiterable< D >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< D >inline
end() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
end(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
expression() noexceptxt::xdynamic_view< CT, S, L, FST >
expression() const noexceptxt::xdynamic_view< CT, S, L, FST >
expression_tag typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
extension_base typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
fill(const T &value) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
flat(size_type index) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
flat(size_type index) const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
get_begin(bool end_index) noexcept -> layout_iterator< L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_begin(const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_cbegin(bool end_index) const noexcept -> const_layout_iterator< L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cbegin(const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cend(bool end_index) const noexcept -> const_layout_iterator< L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cend(const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_end(bool end_index) noexcept -> layout_iterator< L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_end(const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_shape() const (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inlineprotected
get_stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_stepper_end(const S &shape, layout_type l) noexcept -> stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
has_linear_assign(const O &str) const noexcept (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
inner_backstrides_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
inner_shape_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
inner_storage_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
inner_strides_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
is_const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >static
is_contiguous() const noexcept (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
iterable_base typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
iterable_types typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
layout() const noexceptxt::xdynamic_view< CT, S, L, FST >
layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
linear_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
minus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
modulus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
multiplies_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator%=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator&=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator()() (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
operator()() const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
operator()(Args... args) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
operator()(Args... args) const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
operator()(Args... args) -> reference (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
operator()(Args... args) const -> const_reference (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
operator*=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator+=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator-=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator/=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator=(const xexpression< E > &e) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
operator=(const E &e) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
operator=(const xexpression< E > &e) -> self_type & (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
operator=(const E &e) -> disable_xexpression< E, self_type > & (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
operator=(const xview_semantic &)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
operator=(xview_semantic &&)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
operator=(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator=(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator=(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >private
operator=(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >private
operator^=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator|=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
plus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
pointer typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
rbegin() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rbegin(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rbegin() noexcept -> reverse_layout_iterator< L >xt::xiterable< D >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< D >inline
rbegin() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rbegin(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rebind_t typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
reference typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
rend() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rend(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rend() noexcept -> reverse_layout_iterator< L >xt::xiterable< D >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< D >inline
rend() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rend(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_linear_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
scalar_computed_assign(const E &e, F &&f) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
scalar_computed_assign(const E &e, F &&f) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
self_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
semantic_base typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
shape() const noexceptxt::xdynamic_view< CT, S, L, FST >
xt::xaccessible::shape(size_type index) constxt::xconst_accessible< D >inlineprivate
shape_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
simd_value_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
size_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
slice_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
slice_vector_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
static_layout (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >static
stepper typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
stepper_begin(const ST &shape) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
stepper_begin(const ST &shape) const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
stepper_begin(const ST &shape) -> stepper (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
stepper_begin(const ST &shape) const -> const_stepper (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
stepper_end(const ST &shape, layout_type l) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
stepper_end(const ST &shape, layout_type l) const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
stepper_end(const ST &shape, layout_type) -> stepper (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
stepper_end(const ST &shape, layout_type) const -> const_stepper (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
storage() noexceptxt::xdynamic_view< CT, S, L, FST >
storage() const noexceptxt::xdynamic_view< CT, S, L, FST >
storage_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
strides() const noexcept=delete (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
strides_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
strides_vt typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
temporary_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
unchecked(Args... args) (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
unchecked(Args... args) const (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
unchecked(Args... args) -> reference (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
unchecked(Args... args) const -> const_reference (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
value_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
xaccessible< self_type > (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >friend
xconst_accessible< self_type > (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >friend
xdynamic_view(CTA &&e, SA &&shape, get_strides_t< S > &&strides, std::size_t offset, layout_type layout, slice_vector_type &&slices, get_strides_t< S > &&adj_strides) noexcept (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >inline
xexpression_type typedef (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >
xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xstepper (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >friend
xview_semantic()=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic(const xview_semantic &)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic(xview_semantic &&)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic< self_type > (defined in xt::xdynamic_view< CT, S, L, FST >)xt::xdynamic_view< CT, S, L, FST >friend
~xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
~xview_semantic()=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
+
+ + + + diff --git a/classxt_1_1xdynamic__view.html b/classxt_1_1xdynamic__view.html new file mode 100644 index 000000000..c4242164f --- /dev/null +++ b/classxt_1_1xdynamic__view.html @@ -0,0 +1,2715 @@ + + + + + + + +xtensor: xt::xdynamic_view< CT, S, L, FST > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xdynamic_view< CT, S, L, FST > Class Template Reference
+
+
+
+Inheritance diagram for xt::xdynamic_view< CT, S, L, FST >:
+
+
+ + +xt::xview_semantic< D > +xt::xiterable< D > +xt::xstrided_view_base< D > +xt::xsemantic_base< D > +xt::xconst_iterable< D > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xdynamic_view<CT, S, L, FST>
 
using base_type = xstrided_view_base<self_type>
 
using semantic_base = xview_semantic<self_type>
 
using extension_base = extension::xdynamic_view_base_t<CT, S, L, FST>
 
using expression_tag = typename extension_base::expression_tag
 
using xexpression_type = typename base_type::xexpression_type
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using size_type = typename base_type::size_type
 
using difference_type = typename base_type::difference_type
 
using inner_storage_type = typename base_type::inner_storage_type
 
using storage_type = typename base_type::storage_type
 
using iterable_base = xiterable<self_type>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using inner_strides_type = typename base_type::inner_strides_type
 
using inner_backstrides_type = typename base_type::inner_backstrides_type
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
 
using base_index_type = xindex_type_t<shape_type>
 
using simd_value_type = typename base_type::simd_value_type
 
using bool_load_type = typename base_type::bool_load_type
 
using strides_vt = typename strides_type::value_type
 
using slice_type = std::variant<detail::xfake_slice<strides_vt>, xkeep_slice<strides_vt>, xdrop_slice<strides_vt>>
 
using slice_vector_type = std::vector<slice_type>
 
using container_iterator
 
using const_container_iterator = typename storage_type::const_iterator
 
template<class E>
using rebind_t = xdynamic_view<E, S, L, typename FST::template rebind_t<E>>
 
- Public Types inherited from xt::xview_semantic< D >
using base_type = xsemantic_base<D>
 
using derived_type = D
 
using temporary_type = typename base_type::temporary_type
 
- Public Types inherited from xt::xsemantic_base< D >
using base_type = select_expression_base_t<D>
 
using derived_type = typename base_type::derived_type
 
using temporary_type = typename xcontainer_inner_types<D>::temporary_type
 
- Public Types inherited from xt::xiterable< D >
using derived_type = D
 
using base_type = xconst_iterable<D>
 
using inner_shape_type = typename base_type::inner_shape_type
 
using stepper = typename base_type::stepper
 
using const_stepper = typename base_type::const_stepper
 
using linear_iterator = typename base_type::linear_iterator
 
using reverse_linear_iterator = typename base_type::reverse_linear_iterator
 
template<layout_type L>
using layout_iterator = typename base_type::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename base_type::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename base_type::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename base_type::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename base_type::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename base_type::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename base_type::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename base_type::template const_reverse_broadcast_iterator<S, L>
 
using iterator = typename base_type::iterator
 
using const_iterator = typename base_type::const_iterator
 
using reverse_iterator = typename base_type::reverse_iterator
 
using const_reverse_iterator = typename base_type::const_reverse_iterator
 
- Public Types inherited from xt::xconst_iterable< D >
using derived_type = D
 
using iterable_types = xiterable_inner_types<D>
 
using inner_shape_type = typename iterable_types::inner_shape_type
 
using stepper = typename iterable_types::stepper
 
using const_stepper = typename iterable_types::const_stepper
 
template<layout_type L>
using layout_iterator = xiterator<stepper, inner_shape_type*, L>
 
template<layout_type L>
using const_layout_iterator = xiterator<const_stepper, inner_shape_type*, L>
 
template<layout_type L>
using reverse_layout_iterator = std::reverse_iterator<layout_iterator<L>>
 
template<layout_type L>
using const_reverse_layout_iterator = std::reverse_iterator<const_layout_iterator<L>>
 
using linear_iterator = layout_iterator< ::xt::layout_type::row_major >
 
using const_linear_iterator = const_layout_iterator< ::xt::layout_type::row_major >
 
using reverse_linear_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
 
using const_reverse_linear_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
 
template<class S, layout_type L>
using broadcast_iterator = xiterator<stepper, S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = xiterator<const_stepper, S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = std::reverse_iterator<broadcast_iterator<S, L>>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = std::reverse_iterator<const_broadcast_iterator<S, L>>
 
using iterator = layout_iterator< ::xt::layout_type::row_major >
 
using const_iterator = const_layout_iterator< ::xt::layout_type::row_major >
 
using reverse_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
 
using const_reverse_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class CTA, class SA>
 xdynamic_view (CTA &&e, SA &&shape, get_strides_t< S > &&strides, std::size_t offset, layout_type layout, slice_vector_type &&slices, get_strides_t< S > &&adj_strides) noexcept
 
+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
+const inner_strides_type & strides () const noexcept=delete
 
reference operator() ()
 
const_reference operator() () const
 
+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
reference flat (size_type index)
 
const_reference flat (size_type index) const
 
+template<class It>
reference element (It first, It last)
 
+template<class It>
const_reference element (It first, It last) const
 
size_type data_offset () const noexcept
 
+value_type * data () noexcept=delete
 
+const value_type * data () const noexcept=delete
 
template<class O>
bool has_linear_assign (const O &str) const noexcept
 
template<class T>
void fill (const T &value)
 
+template<class ST>
stepper stepper_begin (const ST &shape)
 
+template<class ST>
stepper stepper_end (const ST &shape, layout_type l)
 
+template<class ST>
const_stepper stepper_begin (const ST &shape) const
 
+template<class ST>
const_stepper stepper_end (const ST &shape, layout_type l) const
 
+template<class E>
rebind_t< E > build_view (E &&e) const
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type > &
 
template<class... Args>
auto operator() (Args... args) -> reference
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 
template<class... Args>
auto unchecked (Args... args) -> reference
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 
template<class It>
auto element (It first, It last) -> reference
 
template<class It>
auto element (It first, It last) const -> const_reference
 
template<class ST>
auto stepper_begin (const ST &shape) -> stepper
 
template<class ST>
auto stepper_end (const ST &shape, layout_type) -> stepper
 
template<class ST>
auto stepper_begin (const ST &shape) const -> const_stepper
 
template<class ST>
auto stepper_end (const ST &shape, layout_type) const -> const_stepper
 
template<class E>
auto build_view (E &&e) const -> rebind_t< E >
 
template<class T, class... Args>
auto adjust_offset (offset_type offset, T idx, Args... args) const noexcept -> offset_type
 
template<class T, class... Args>
auto adjust_offset_impl (offset_type offset, size_type idx_offset, T idx, Args... args) const noexcept -> offset_type
 
template<class It>
auto adjust_element_offset (offset_type offset, It first, It last) const noexcept -> offset_type
 
+bool is_contiguous () const noexcept
 
+layout_type layout () const noexcept
 Returns the layout of the xtrided_view_base.
 
+const inner_shape_type & shape () const noexcept
 Returns the shape of the xtrided_view_base.
 
bool broadcast_shape (O &shape, bool reuse_cache=false) const
 Broadcast the shape of the view to the specified parameter.
 
+xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
+const xexpression_type & expression () const noexcept
 Returns a constant reference to the underlying expression of the view.
 
+storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the view.
 
+const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the view.
 
- Public Member Functions inherited from xt::xview_semantic< D >
+template<class E>
derived_type & assign_xexpression (const xexpression< E > &e)
 
+template<class E>
derived_type & computed_assign (const xexpression< E > &e)
 
+template<class E, class F>
derived_type & scalar_computed_assign (const E &e, F &&f)
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
template<class E>
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
template<class E>
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
template<class E, class F>
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
template<class E>
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< D >
+template<class E>
disable_xexpression< E, derived_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator^= (const E &)
 
+template<class E>
derived_type & operator+= (const xexpression< E > &)
 
+template<class E>
derived_type & operator-= (const xexpression< E > &)
 
+template<class E>
derived_type & operator*= (const xexpression< E > &)
 
+template<class E>
derived_type & operator/= (const xexpression< E > &)
 
+template<class E>
derived_type & operator%= (const xexpression< E > &)
 
+template<class E>
derived_type & operator&= (const xexpression< E > &)
 
+template<class E>
derived_type & operator|= (const xexpression< E > &)
 
+template<class E>
derived_type & operator^= (const xexpression< E > &)
 
+template<class E>
derived_type & assign (const xexpression< E > &)
 
+template<class E>
derived_type & plus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & minus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & multiplies_assign (const xexpression< E > &)
 
+template<class E>
derived_type & divides_assign (const xexpression< E > &)
 
+template<class E>
derived_type & modulus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_and_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_or_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_xor_assign (const xexpression< E > &)
 
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
template<class E>
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
template<class E>
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
template<class E>
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
template<class E>
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
template<class E>
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xiterable< D >
+template<layout_type L = ::xt::layout_type::row_major>
layout_iterator< L > begin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
layout_iterator< L > end () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_layout_iterator< L > rbegin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_layout_iterator< L > rend () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
template<layout_type L>
auto begin () noexcept -> layout_iterator< L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L>
auto end () noexcept -> layout_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L>
auto rbegin () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto get_begin (bool end_index) noexcept -> layout_iterator< L >
 
template<layout_type L>
auto get_end (bool end_index) noexcept -> layout_iterator< L >
 
template<layout_type L, class S>
auto get_begin (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
template<layout_type L, class S>
auto get_end (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
template<class S>
auto get_stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto get_stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
template<class S>
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xconst_iterable< D >
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > cbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > cend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > crbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > crend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
template<layout_type L>
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
template<layout_type L>
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
template<layout_type L, class S>
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
template<layout_type L, class S>
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
template<class S>
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
+ + + + + + + +

+Static Public Attributes

static constexpr bool is_const
 
static constexpr bool contiguous_layout
 
static constexpr layout_type static_layout
 
+ + + + + + + + + + +

+Friends

template<class C>
class xstepper
 
class xview_semantic< self_type >
 
class xaccessible< self_type >
 
class xconst_accessible< self_type >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xview_semantic< D >
+ xview_semantic (const xview_semantic &)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< D >
+ xsemantic_base (const xsemantic_base &)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
const inner_shape_type & get_shape () const
 
+

Detailed Description

+
template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+class xt::xdynamic_view< CT, S, L, FST >
+

Definition at line 98 of file xdynamic_view.hpp.

+

Member Typedef Documentation

+ +

◆ backstrides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 132 of file xdynamic_view.hpp.

+ +
+
+ +

◆ base_index_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::base_index_type = xindex_type_t<shape_type>
+
+ +

Definition at line 141 of file xdynamic_view.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::base_type = xstrided_view_base<self_type>
+
+ +

Definition at line 106 of file xdynamic_view.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::bool_load_type = typename base_type::bool_load_type
+
+ +

Definition at line 144 of file xdynamic_view.hpp.

+ +
+
+ +

◆ const_container_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::const_container_iterator = typename storage_type::const_iterator
+
+ +

Definition at line 239 of file xdynamic_view.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 118 of file xdynamic_view.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 116 of file xdynamic_view.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 135 of file xdynamic_view.hpp.

+ +
+
+ +

◆ container_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::container_iterator
+
+Initial value:
std::
+
conditional_t<is_const, typename storage_type::const_iterator, typename storage_type::iterator>
+
+

Definition at line 237 of file xdynamic_view.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::difference_type = typename base_type::difference_type
+
+ +

Definition at line 120 of file xdynamic_view.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 109 of file xdynamic_view.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::extension_base = extension::xdynamic_view_base_t<CT, S, L, FST>
+
+ +

Definition at line 108 of file xdynamic_view.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::inner_backstrides_type = typename base_type::inner_backstrides_type
+
+ +

Definition at line 128 of file xdynamic_view.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 126 of file xdynamic_view.hpp.

+ +
+
+ +

◆ inner_storage_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::inner_storage_type = typename base_type::inner_storage_type
+
+ +

Definition at line 122 of file xdynamic_view.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::inner_strides_type = typename base_type::inner_strides_type
+
+ +

Definition at line 127 of file xdynamic_view.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::iterable_base = xiterable<self_type>
+
+ +

Definition at line 125 of file xdynamic_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::pointer = typename base_type::pointer
+
+ +

Definition at line 117 of file xdynamic_view.hpp.

+ +
+
+ +

◆ rebind_t

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::rebind_t = xdynamic_view<E, S, L, typename FST::template rebind_t<E>>
+
+ +

Definition at line 242 of file xdynamic_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::reference = typename base_type::reference
+
+ +

Definition at line 115 of file xdynamic_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::self_type = xdynamic_view<CT, S, L, FST>
+
+ +

Definition at line 105 of file xdynamic_view.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::semantic_base = xview_semantic<self_type>
+
+ +

Definition at line 107 of file xdynamic_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 130 of file xdynamic_view.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::simd_value_type = typename base_type::simd_value_type
+
+ +

Definition at line 143 of file xdynamic_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::size_type = typename base_type::size_type
+
+ +

Definition at line 119 of file xdynamic_view.hpp.

+ +
+
+ +

◆ slice_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::slice_type = std::variant<detail::xfake_slice<strides_vt>, xkeep_slice<strides_vt>, xdrop_slice<strides_vt>>
+
+ +

Definition at line 147 of file xdynamic_view.hpp.

+ +
+
+ +

◆ slice_vector_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::slice_vector_type = std::vector<slice_type>
+
+ +

Definition at line 148 of file xdynamic_view.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 134 of file xdynamic_view.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 123 of file xdynamic_view.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 131 of file xdynamic_view.hpp.

+ +
+
+ +

◆ strides_vt

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::strides_vt = typename strides_type::value_type
+
+ +

Definition at line 146 of file xdynamic_view.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
+
+ +

Definition at line 140 of file xdynamic_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::value_type = typename base_type::value_type
+
+ +

Definition at line 114 of file xdynamic_view.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xdynamic_view< CT, S, L, FST >::xexpression_type = typename base_type::xexpression_type
+
+ +

Definition at line 111 of file xdynamic_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xdynamic_view()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class CTA, class SA>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
xt::xdynamic_view< CT, S, L, FST >::xdynamic_view (CTA && e,
SA && shape,
get_strides_t< S > && strides,
std::size_t offset,
layout_type layout,
slice_vector_type && slices,
get_strides_t< S > && adj_strides )
+ 		+inlinenoexcept
+
+ +

Definition at line 384 of file xdynamic_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ adjust_element_offset()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::adjust_element_offset (offset_type offset,
It first,
It last ) const -> offset_type +
+ 		+inlinenoexcept
+
+ +

Definition at line 674 of file xdynamic_view.hpp.

+ +
+
+ +

◆ adjust_offset()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class T, class... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::adjust_offset (offset_type offset,
T idx,
Args... args ) const -> offset_type +
+ 		+inlinenoexcept
+
+ +

Definition at line 630 of file xdynamic_view.hpp.

+ +
+
+ +

◆ adjust_offset_impl()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class T, class... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::adjust_offset_impl (offset_type offset,
size_type idx_offset,
T idx,
Args... args ) const -> offset_type +
+ 		+inlinenoexcept
+
+ +

Definition at line 649 of file xdynamic_view.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + + + + + + + +
bool xt::xstrided_view_base< self_type >::broadcast_shape (O & shape,
bool reuse_cache = false ) const
+
+ +

Broadcast the shape of the view to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +
+
+ +

◆ build_view()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::build_view (E && e) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 561 of file xdynamic_view.hpp.

+ +
+
+ +

◆ data_offset()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::data_offset () const
+ 		+inlinenoexcept
+
+ +

Definition at line 506 of file xdynamic_view.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::element (It first,
It last ) -> reference +
+ 		+inline
+
+ +

Definition at line 487 of file xdynamic_view.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 497 of file xdynamic_view.hpp.

+ +
+
+ +

◆ fill()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xdynamic_view< CT, S, L, FST >::fill (const T & value)
+ 		+inline
+
+ +

Definition at line 521 of file xdynamic_view.hpp.

+ +
+
+ +

◆ flat() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::flat (size_type index)
+ 		+inline
+
+ +

Definition at line 474 of file xdynamic_view.hpp.

+ +
+
+ +

◆ flat() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::flat (size_type index) const
+ 		+inline
+
+ +

Definition at line 480 of file xdynamic_view.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class O>
+ + + + + +
+ + + + + + + +
bool xt::xdynamic_view< CT, S, L, FST >::has_linear_assign (const O & str) const
+ 		+inlinenoexcept
+
+ +

Definition at line 450 of file xdynamic_view.hpp.

+ +
+
+ +

◆ operator()() [1/4]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::operator() ()
+ 		+inline
+
+ +

Definition at line 415 of file xdynamic_view.hpp.

+ +
+
+ +

◆ operator()() [2/4]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::operator() () const
+ 		+inline
+
+ +

Definition at line 421 of file xdynamic_view.hpp.

+ +
+
+ +

◆ operator()() [3/4]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::operator() (Args... args) -> reference +
+ 		+inline
+
+ +

Definition at line 428 of file xdynamic_view.hpp.

+ +
+
+ +

◆ operator()() [4/4]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 439 of file xdynamic_view.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::operator= (const E & e) -> disable_xexpression<E, self_type>& +
+ 		+inline
+
+ +

Definition at line 408 of file xdynamic_view.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

Definition at line 401 of file xdynamic_view.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::stepper_begin (const ST & shape) -> stepper +
+ 		+inline
+
+ +

Definition at line 528 of file xdynamic_view.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::stepper_begin (const ST & shape) const -> const_stepper +
+ 		+inline
+
+ +

Definition at line 544 of file xdynamic_view.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::stepper_end (const ST & shape,
layout_type  ) -> stepper +
+ 		+inline
+
+ +

Definition at line 536 of file xdynamic_view.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::stepper_end (const ST & shape,
layout_type  ) const -> const_stepper +
+ 		+inline
+
+ +

Definition at line 552 of file xdynamic_view.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::unchecked (Args... args) -> reference +
+ 		+inline
+
+ +

Definition at line 457 of file xdynamic_view.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xdynamic_view< CT, S, L, FST >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 466 of file xdynamic_view.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< self_type >

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
friend class xaccessible< self_type >
+ 		+friend
+
+ +

Definition at line 280 of file xdynamic_view.hpp.

+ +
+
+ +

◆ xconst_accessible< self_type >

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
friend class xconst_accessible< self_type >
+ 		+friend
+
+ +

Definition at line 280 of file xdynamic_view.hpp.

+ +
+
+ +

◆ xstepper

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class C>
+ + + + + +
+ + + + +
friend class xstepper
+ 		+friend
+
+ +

Definition at line 280 of file xdynamic_view.hpp.

+ +
+
+ +

◆ xview_semantic< self_type >

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
friend class xview_semantic< self_type >
+ 		+friend
+
+ +

Definition at line 280 of file xdynamic_view.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
bool xt::xstrided_view_base< self_type >::contiguous_layout
+ 		+staticconstexpr
+
+ +

Definition at line 133 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ is_const

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
bool xt::xstrided_view_base< self_type >::is_const
+ 		+staticconstexpr
+
+ +

Definition at line 104 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
layout_type xt::xstrided_view_base< self_type >::static_layout
+ 		+staticconstexpr
+
+ +

Definition at line 132 of file xstrided_view_base.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xdynamic__view.js b/classxt_1_1xdynamic__view.js new file mode 100644 index 000000000..30fbee8e4 --- /dev/null +++ b/classxt_1_1xdynamic__view.js @@ -0,0 +1,10 @@ +var classxt_1_1xdynamic__view = +[ + [ "broadcast_shape", "classxt_1_1xdynamic__view.html#a0f7c1e14391c357570e1d054b19b6165", null ], + [ "expression", "classxt_1_1xdynamic__view.html#a929958921ea6477ce8a3c5aba3936146", null ], + [ "expression", "classxt_1_1xdynamic__view.html#a0ab07e56a411fedb9e0e213b8ddbc693", null ], + [ "layout", "classxt_1_1xdynamic__view.html#ae3ff4c9cf2e6873fbc934e946f1b702b", null ], + [ "shape", "classxt_1_1xdynamic__view.html#a63efb4c728be80dc8154df1b578c33cd", null ], + [ "storage", "classxt_1_1xdynamic__view.html#a12ee07f7bf30d89f9ea691a03a122e3d", null ], + [ "storage", "classxt_1_1xdynamic__view.html#a515e8cbd36c5494ab188f4c3e9d90861", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xdynamic__view.png b/classxt_1_1xdynamic__view.png new file mode 100644 index 000000000..712d65fae Binary files /dev/null and b/classxt_1_1xdynamic__view.png differ diff --git a/classxt_1_1xexpression-members.html b/classxt_1_1xexpression-members.html new file mode 100644 index 000000000..79eee2caf --- /dev/null +++ b/classxt_1_1xexpression-members.html @@ -0,0 +1,130 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xexpression< D > Member List
+
+
+ +

This is the complete list of members for xt::xexpression< D >, including all inherited members.

+ + + + + + + + + + + +
derived_cast() &noexceptxt::xexpression< D >inline
derived_cast() const &noexceptxt::xexpression< D >inline
derived_cast() &&noexceptxt::xexpression< D >inline
derived_type typedef (defined in xt::xexpression< D >)xt::xexpression< D >
operator=(const xexpression &)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
operator=(xexpression &&)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
xexpression()=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
xexpression(const xexpression &)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
xexpression(xexpression &&)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
~xexpression()=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
+
+ + + + diff --git a/classxt_1_1xexpression.html b/classxt_1_1xexpression.html new file mode 100644 index 000000000..9e9e64d4f --- /dev/null +++ b/classxt_1_1xexpression.html @@ -0,0 +1,311 @@ + + + + + + + +xtensor: xt::xexpression< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Protected Member Functions | +List of all members
+
xt::xexpression< D > Class Template Reference
+
+
+ +

Base class for xexpressions. + More...

+ +

#include <xexpression.hpp>

+
+Inheritance diagram for xt::xexpression< D >:
+
+
+ + +xt::xsharable_expression< D > +xt::xbroadcast< E, X > +xt::xgenerator< OF, OR, S > +xt::xgenerator< value_functor, value_closure, S > +xt::xgenerator< flag_functor, flag_closure, S > +xt::xreducer< Func, E, X, Opts > +xt::xscalar< xtl::closure_type_t< E > > +xt::xscalar< xtl::const_closure_type_t< E > > +xt::xscalar< T > +xt::xscalar< bool > +xt::xscalar< std::conditional_t< is_const, const_value_closure, value_closure > > +xt::xscalar< std::conditional_t< is_const, const_flag_closure, flag_closure > > +xt::xscalar< const_value_closure > +xt::xscalar< const_flag_closure > + +
+ + + + +

+Public Types

using derived_type = D
 
+ + + + + + + + + + + +

+Public Member Functions

Downcast functions
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
+ + + + + + + + + +

+Protected Member Functions

+ xexpression (const xexpression &)=default
 
+xexpression & operator= (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (xexpression &&)=default
 
+

Detailed Description

+
template<class D>
+class xt::xexpression< D >

Base class for xexpressions.

+

The xexpression class is the base class for all classes representing an expression that can be evaluated to a multidimensional container with tensor semantic. Functions that can apply to any xexpression regardless of its specific type should take a xexpression argument.

+
Template Parameters
+ + +
EThe derived type.
+
+
+ +

Definition at line 44 of file xexpression.hpp.

+

Member Typedef Documentation

+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xexpression< D >::derived_type = D
+
+ +

Definition at line 48 of file xexpression.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ derived_cast() [1/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xexpression< D >::derived_cast () &&
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the actual derived type of the xexpression.

+ +

Definition at line 133 of file xexpression.hpp.

+ +
+
+ +

◆ derived_cast() [2/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xexpression< D >::derived_cast () &
+ 		+inlinenoexcept
+
+ +

Returns a reference to the actual derived type of the xexpression.

+ +

Definition at line 115 of file xexpression.hpp.

+ +
+
+ +

◆ derived_cast() [3/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xexpression< D >::derived_cast () const &
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the actual derived type of the xexpression.

+ +

Definition at line 124 of file xexpression.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xexpression.js b/classxt_1_1xexpression.js new file mode 100644 index 000000000..420a231d7 --- /dev/null +++ b/classxt_1_1xexpression.js @@ -0,0 +1,6 @@ +var classxt_1_1xexpression = +[ + [ "derived_cast", "classxt_1_1xexpression.html#abf1d99fb093b7bab105ea3d8c4d8a548", null ], + [ "derived_cast", "classxt_1_1xexpression.html#a96fe8ebe879202c5a053ae5e0067b231", null ], + [ "derived_cast", "classxt_1_1xexpression.html#ab08a20008d390c970283c26f9f882483", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xexpression.png b/classxt_1_1xexpression.png new file mode 100644 index 000000000..e6089d3ec Binary files /dev/null and b/classxt_1_1xexpression.png differ diff --git a/classxt_1_1xexpression__assigner-members.html b/classxt_1_1xexpression__assigner-members.html new file mode 100644 index 000000000..48aa5704f --- /dev/null +++ b/classxt_1_1xexpression__assigner-members.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xexpression_assigner< Tag > Member List
+
+
+ +

This is the complete list of members for xt::xexpression_assigner< Tag >, including all inherited members.

+ + + + + + +
assert_compatible_shape(const xexpression< E1 > &e1, const xexpression< E2 > &e2) (defined in xt::xexpression_assigner< Tag >)xt::xexpression_assigner< Tag >inlinestatic
assign_xexpression(E1 &e1, const E2 &e2) (defined in xt::xexpression_assigner< Tag >)xt::xexpression_assigner< Tag >inlinestatic
base_type typedef (defined in xt::xexpression_assigner< Tag >)xt::xexpression_assigner< Tag >
computed_assign(xexpression< E1 > &e1, const xexpression< E2 > &e2) (defined in xt::xexpression_assigner< Tag >)xt::xexpression_assigner< Tag >inlinestatic
scalar_computed_assign(xexpression< E1 > &e1, const E2 &e2, F &&f) (defined in xt::xexpression_assigner< Tag >)xt::xexpression_assigner< Tag >inlinestatic
+
+ + + + diff --git a/classxt_1_1xexpression__assigner.html b/classxt_1_1xexpression__assigner.html new file mode 100644 index 000000000..44842ae49 --- /dev/null +++ b/classxt_1_1xexpression__assigner.html @@ -0,0 +1,324 @@ + + + + + + + +xtensor: xt::xexpression_assigner< Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Static Public Member Functions | +List of all members
+
xt::xexpression_assigner< Tag > Class Template Reference
+
+
+
+Inheritance diagram for xt::xexpression_assigner< Tag >:
+
+
+ + +xt::xexpression_assigner_base< Tag > + +
+ + + + +

+Public Types

using base_type = xexpression_assigner_base<Tag>
 
+ + + + + + + + + + + + + +

+Static Public Member Functions

template<class E1, class E2>
static void assign_xexpression (E1 &e1, const E2 &e2)
 
template<class E1, class E2>
static void computed_assign (xexpression< E1 > &e1, const xexpression< E2 > &e2)
 
template<class E1, class E2, class F>
static void scalar_computed_assign (xexpression< E1 > &e1, const E2 &e2, F &&f)
 
template<class E1, class E2>
static void assert_compatible_shape (const xexpression< E1 > &e1, const xexpression< E2 > &e2)
 
+

Detailed Description

+
template<class Tag>
+class xt::xexpression_assigner< Tag >
+

Definition at line 78 of file xassign.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class Tag>
+ + + + +
using xt::xexpression_assigner< Tag >::base_type = xexpression_assigner_base<Tag>
+
+ +

Definition at line 82 of file xassign.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assert_compatible_shape()

+ +
+
+
+template<class Tag>
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + +
void xt::xexpression_assigner< Tag >::assert_compatible_shape (const xexpression< E1 > & e1,
const xexpression< E2 > & e2 )
+ 		+inlinestatic
+
+ +

Definition at line 542 of file xassign.hpp.

+ +
+
+ +

◆ assign_xexpression()

+ +
+
+
+template<class Tag>
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + +
void xt::xexpression_assigner< Tag >::assign_xexpression (E1 & e1,
const E2 & e2 )
+ 		+inlinestatic
+
+ +

Definition at line 482 of file xassign.hpp.

+ +
+
+ +

◆ computed_assign()

+ +
+
+
+template<class Tag>
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + +
void xt::xexpression_assigner< Tag >::computed_assign (xexpression< E1 > & e1,
const xexpression< E2 > & e2 )
+ 		+inlinestatic
+
+ +

Definition at line 490 of file xassign.hpp.

+ +
+
+ +

◆ scalar_computed_assign()

+ +
+
+
+template<class Tag>
+
+template<class E1, class E2, class F>
+ + + + + +
+ + + + + + + + + + + + + + + + +
void xt::xexpression_assigner< Tag >::scalar_computed_assign (xexpression< E1 > & e1,
const E2 & e2,
F && f )
+ 		+inlinestatic
+
+ +

Definition at line 527 of file xassign.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xexpression__assigner.png b/classxt_1_1xexpression__assigner.png new file mode 100644 index 000000000..d4a3fba48 Binary files /dev/null and b/classxt_1_1xexpression__assigner.png differ diff --git a/classxt_1_1xexpression__assigner__base.html b/classxt_1_1xexpression__assigner__base.html new file mode 100644 index 000000000..bcdfa900e --- /dev/null +++ b/classxt_1_1xexpression__assigner__base.html @@ -0,0 +1,134 @@ + + + + + + + +xtensor: xt::xexpression_assigner_base< Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xexpression_assigner_base< Tag > Class Template Reference
+
+
+
+Inheritance diagram for xt::xexpression_assigner_base< Tag >:
+
+
+ + +xt::xexpression_assigner< Tag > + +
+

Detailed Description

+
template<class Tag>
+class xt::xexpression_assigner_base< Tag >
+

Definition at line 66 of file xassign.hpp.

+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xexpression__assigner__base.png b/classxt_1_1xexpression__assigner__base.png new file mode 100644 index 000000000..2181cf3f6 Binary files /dev/null and b/classxt_1_1xexpression__assigner__base.png differ diff --git a/classxt_1_1xexpression__assigner__base_3_01xoptional__expression__tag_01_4-members.html b/classxt_1_1xexpression__assigner__base_3_01xoptional__expression__tag_01_4-members.html new file mode 100644 index 000000000..bfa6e93f9 --- /dev/null +++ b/classxt_1_1xexpression__assigner__base_3_01xoptional__expression__tag_01_4-members.html @@ -0,0 +1,121 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xexpression_assigner_base< xoptional_expression_tag > Member List
+
+
+ +

This is the complete list of members for xt::xexpression_assigner_base< xoptional_expression_tag >, including all inherited members.

+ + +
assign_data(xexpression< E1 > &e1, const xexpression< E2 > &e2, bool trivial) (defined in xt::xexpression_assigner_base< xoptional_expression_tag >)xt::xexpression_assigner_base< xoptional_expression_tag >inlinestatic
+
+ + + + diff --git a/classxt_1_1xexpression__assigner__base_3_01xoptional__expression__tag_01_4.html b/classxt_1_1xexpression__assigner__base_3_01xoptional__expression__tag_01_4.html new file mode 100644 index 000000000..f82050ae3 --- /dev/null +++ b/classxt_1_1xexpression__assigner__base_3_01xoptional__expression__tag_01_4.html @@ -0,0 +1,173 @@ + + + + + + + +xtensor: xt::xexpression_assigner_base< xoptional_expression_tag > Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Static Public Member Functions | +List of all members
+
xt::xexpression_assigner_base< xoptional_expression_tag > Class Reference
+
+
+ + + + + +

+Static Public Member Functions

template<class E1, class E2>
static void assign_data (xexpression< E1 > &e1, const xexpression< E2 > &e2, bool trivial)
 
+

Detailed Description

+
+

Definition at line 263 of file xoptional.hpp.

+

Member Function Documentation

+ +

◆ assign_data()

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + + + + + + +
void xt::xexpression_assigner_base< xoptional_expression_tag >::assign_data (xexpression< E1 > & e1,
const xexpression< E2 > & e2,
bool trivial )
+ 		+inlinestatic
+
+ +

Definition at line 1344 of file xoptional.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/optional/xoptional.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xexpression__assigner__base_3_01xtensor__expression__tag_01_4-members.html b/classxt_1_1xexpression__assigner__base_3_01xtensor__expression__tag_01_4-members.html new file mode 100644 index 000000000..b09301f20 --- /dev/null +++ b/classxt_1_1xexpression__assigner__base_3_01xtensor__expression__tag_01_4-members.html @@ -0,0 +1,121 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xexpression_assigner_base< xtensor_expression_tag > Member List
+
+
+ +

This is the complete list of members for xt::xexpression_assigner_base< xtensor_expression_tag >, including all inherited members.

+ + +
assign_data(xexpression< E1 > &e1, const xexpression< E2 > &e2, bool trivial) (defined in xt::xexpression_assigner_base< xtensor_expression_tag >)xt::xexpression_assigner_base< xtensor_expression_tag >inlinestatic
+
+ + + + diff --git a/classxt_1_1xexpression__assigner__base_3_01xtensor__expression__tag_01_4.html b/classxt_1_1xexpression__assigner__base_3_01xtensor__expression__tag_01_4.html new file mode 100644 index 000000000..b767a4ba9 --- /dev/null +++ b/classxt_1_1xexpression__assigner__base_3_01xtensor__expression__tag_01_4.html @@ -0,0 +1,173 @@ + + + + + + + +xtensor: xt::xexpression_assigner_base< xtensor_expression_tag > Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Static Public Member Functions | +List of all members
+
xt::xexpression_assigner_base< xtensor_expression_tag > Class Reference
+
+
+ + + + + +

+Static Public Member Functions

template<class E1, class E2>
static void assign_data (xexpression< E1 > &e1, const xexpression< E2 > &e2, bool trivial)
 
+

Detailed Description

+
+

Definition at line 69 of file xassign.hpp.

+

Member Function Documentation

+ +

◆ assign_data()

+ +
+
+
+template<class E1, class E2>
+ + + + + +
+ + + + + + + + + + + + + + + + +
void xt::xexpression_assigner_base< xtensor_expression_tag >::assign_data (xexpression< E1 > & e1,
const xexpression< E2 > & e2,
bool trivial )
+ 		+inlinestatic
+
+ +

Definition at line 440 of file xassign.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xassign.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xexpression__holder-members.html b/classxt_1_1xexpression__holder-members.html new file mode 100644 index 000000000..5345d8232 --- /dev/null +++ b/classxt_1_1xexpression__holder-members.html @@ -0,0 +1,131 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xexpression_holder Member List
+
+
+ +

This is the complete list of members for xt::xexpression_holder, including all inherited members.

+ + + + + + + + + + + + +
from_json(const nlohmann::json &) (defined in xt::xexpression_holder)xt::xexpression_holderinline
implementation_type typedef (defined in xt::xexpression_holder)xt::xexpression_holder
operator=(const xexpression_holder &) (defined in xt::xexpression_holder)xt::xexpression_holderinline
operator=(xexpression_holder &&) (defined in xt::xexpression_holder)xt::xexpression_holderinline
swap(xexpression_holder &) (defined in xt::xexpression_holder)xt::xexpression_holderinline
to_json(nlohmann::json &) const (defined in xt::xexpression_holder)xt::xexpression_holderinline
xexpression_holder()=default (defined in xt::xexpression_holder)xt::xexpression_holder
xexpression_holder(E &&expr) (defined in xt::xexpression_holder)xt::xexpression_holderinline
xexpression_holder(implementation_type *holder) (defined in xt::xexpression_holder)xt::xexpression_holderinline
xexpression_holder(const xexpression_holder &holder) (defined in xt::xexpression_holder)xt::xexpression_holderinline
xexpression_holder(xexpression_holder &&holder) (defined in xt::xexpression_holder)xt::xexpression_holderinline
+
+ + + + diff --git a/classxt_1_1xexpression__holder.html b/classxt_1_1xexpression__holder.html new file mode 100644 index 000000000..fa54f83a9 --- /dev/null +++ b/classxt_1_1xexpression__holder.html @@ -0,0 +1,420 @@ + + + + + + + +xtensor: xt::xexpression_holder Class Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xexpression_holder Class Reference
+
+
+ + + + +

+Public Types

using implementation_type = detail::xexpression_holder_impl
 
+ + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class E>
 xexpression_holder (E &&expr)
 
 xexpression_holder (implementation_type *holder)
 
 xexpression_holder (const xexpression_holder &holder)
 
 xexpression_holder (xexpression_holder &&holder)
 
xexpression_holder & operator= (const xexpression_holder &)
 
xexpression_holder & operator= (xexpression_holder &&)
 
void swap (xexpression_holder &)
 
void to_json (nlohmann::json &) const
 
void from_json (const nlohmann::json &)
 
+

Detailed Description

+
+

Definition at line 32 of file xexpression_holder.hpp.

+

Member Typedef Documentation

+ +

◆ implementation_type

+ +
+
+ + + + +
using xt::xexpression_holder::implementation_type = detail::xexpression_holder_impl
+
+ +

Definition at line 36 of file xexpression_holder.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xexpression_holder() [1/4]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
xt::xexpression_holder::xexpression_holder (E && expr)
+ 		+inline
+
+ +

Definition at line 121 of file xexpression_holder.hpp.

+ +
+
+ +

◆ xexpression_holder() [2/4]

+ +
+
+ + + + + +
+ + + + + + + +
xt::xexpression_holder::xexpression_holder (implementation_type * holder)
+ 		+inline
+
+ +

Definition at line 126 of file xexpression_holder.hpp.

+ +
+
+ +

◆ xexpression_holder() [3/4]

+ +
+
+ + + + + +
+ + + + + + + +
xt::xexpression_holder::xexpression_holder (const xexpression_holder & holder)
+ 		+inline
+
+ +

Definition at line 131 of file xexpression_holder.hpp.

+ +
+
+ +

◆ xexpression_holder() [4/4]

+ +
+
+ + + + + +
+ + + + + + + +
xt::xexpression_holder::xexpression_holder (xexpression_holder && holder)
+ 		+inline
+
+ +

Definition at line 136 of file xexpression_holder.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ from_json()

+ +
+
+ + + + + +
+ + + + + + + +
void xt::xexpression_holder::from_json (const nlohmann::json & j)
+ 		+inline
+
+ +

Definition at line 168 of file xexpression_holder.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+ + + + + +
+ + + + + + + +
xexpression_holder & xt::xexpression_holder::operator= (const xexpression_holder & holder)
+ 		+inline
+
+ +

Definition at line 141 of file xexpression_holder.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+ + + + + +
+ + + + + + + +
xexpression_holder & xt::xexpression_holder::operator= (xexpression_holder && holder)
+ 		+inline
+
+ +

Definition at line 148 of file xexpression_holder.hpp.

+ +
+
+ +

◆ swap()

+ +
+
+ + + + + +
+ + + + + + + +
void xt::xexpression_holder::swap (xexpression_holder & holder)
+ 		+inline
+
+ +

Definition at line 154 of file xexpression_holder.hpp.

+ +
+
+ +

◆ to_json()

+ +
+
+ + + + + +
+ + + + + + + +
void xt::xexpression_holder::to_json (nlohmann::json & j) const
+ 		+inline
+
+ +

Definition at line 159 of file xexpression_holder.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xfiltration-members.html b/classxt_1_1xfiltration-members.html new file mode 100644 index 000000000..33788642b --- /dev/null +++ b/classxt_1_1xfiltration-members.html @@ -0,0 +1,137 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfiltration< ECT, CCT > Member List
+
+
+ +

This is the complete list of members for xt::xfiltration< ECT, CCT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
apply(F &&func) -> self_type & (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >inline
const_reference typedef (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
operator%=(const E &) (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
operator%=(const E &e) -> disable_xexpression< E, self_type & >xt::xfiltration< ECT, CCT >inline
operator*=(const E &) (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
operator*=(const E &e) -> disable_xexpression< E, self_type & >xt::xfiltration< ECT, CCT >inline
operator+=(const E &) (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
operator+=(const E &e) -> disable_xexpression< E, self_type & >xt::xfiltration< ECT, CCT >inline
operator-=(const E &) (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
operator-=(const E &e) -> disable_xexpression< E, self_type & >xt::xfiltration< ECT, CCT >inline
operator/=(const E &) (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
operator/=(const E &e) -> disable_xexpression< E, self_type & >xt::xfiltration< ECT, CCT >inline
operator=(const E &) (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
operator=(const E &e) -> disable_xexpression< E, self_type & >xt::xfiltration< ECT, CCT >inline
self_type typedef (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
xexpression_type typedef (defined in xt::xfiltration< ECT, CCT >)xt::xfiltration< ECT, CCT >
xfiltration(ECTA &&e, CCTA &&condition)xt::xfiltration< ECT, CCT >inline
+
+ + + + diff --git a/classxt_1_1xfiltration.html b/classxt_1_1xfiltration.html new file mode 100644 index 000000000..96f331a17 --- /dev/null +++ b/classxt_1_1xfiltration.html @@ -0,0 +1,595 @@ + + + + + + + +xtensor: xt::xfiltration< ECT, CCT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xfiltration< ECT, CCT > Class Template Reference
+
+
+ +

Filter of a xexpression for fast scalar assign. + More...

+ +

#include <xindex_view.hpp>

+ + + + + + + + +

+Public Types

using self_type = xfiltration<ECT, CCT>
 
using xexpression_type = std::decay_t<ECT>
 
using const_reference = typename xexpression_type::const_reference
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
disable_xexpression< E, self_type & > operator= (const E &)
 
+template<class E>
disable_xexpression< E, self_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, self_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, self_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, self_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, self_type & > operator%= (const E &)
 
Constructor
template<class ECTA, class CCTA>
 xfiltration (ECTA &&e, CCTA &&condition)
 Constructs a xfiltration on the given expression e, selecting the elements matching the specified condition.
 
Extended copy semantic
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type & >
 Assigns the scalar e to *this.
 
Computed assignement
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, self_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, self_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, self_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, self_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, self_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class F>
auto apply (F &&func) -> self_type &
 
+

Detailed Description

+
template<class ECT, class CCT>
+class xt::xfiltration< ECT, CCT >

Filter of a xexpression for fast scalar assign.

+

The xfiltration class implements a lazy filtration of a multidimentional xexpression, optimized for scalar and computed scalar assignments. Actually, the xfiltration class IS NOT an xexpression and the scalar and computed scalar assignments are the only method it provides. The filtering condition is not evaluated until the filtration is assigned.

+

xfiltration is not meant to be used directly, but only with the filtration helper function.

+
Template Parameters
+ + + +
ECTthe closure type of the xexpression type underlying this filtration
CCRthe closure type of the filtering xexpression type
+
+
+
See also
filtration
+ +

Definition at line 232 of file xindex_view.hpp.

+

Member Typedef Documentation

+ +

◆ const_reference

+ +
+
+
+template<class ECT, class CCT>
+ + + + +
using xt::xfiltration< ECT, CCT >::const_reference = typename xexpression_type::const_reference
+
+ +

Definition at line 238 of file xindex_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class ECT, class CCT>
+ + + + +
using xt::xfiltration< ECT, CCT >::self_type = xfiltration<ECT, CCT>
+
+ +

Definition at line 236 of file xindex_view.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class ECT, class CCT>
+ + + + +
using xt::xfiltration< ECT, CCT >::xexpression_type = std::decay_t<ECT>
+
+ +

Definition at line 237 of file xindex_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfiltration()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class ECTA, class CCTA>
+ + + + + +
+ + + + + + + + + + + +
xt::xfiltration< ECT, CCT >::xfiltration (ECTA && e,
CCTA && condition )
+ 		+inline
+
+ +

Constructs a xfiltration on the given expression e, selecting the elements matching the specified condition.

+
Parameters
+ + + +
ethe xexpression to filter.
conditionthe filtering xexpression to apply.
+
+
+ +

Definition at line 641 of file xindex_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ apply()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class F>
+ + + + + +
+ + + + + + + +
auto xt::xfiltration< ECT, CCT >::apply (F && func) -> self_type& +
+ 		+inline
+
+ +

Definition at line 763 of file xindex_view.hpp.

+ +
+
+ +

◆ operator%=()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfiltration< ECT, CCT >::operator%= (const E & e) -> disable_xexpression<E, self_type&> +
+ 		+inline
+
+ +

Computes the remainder of *this after division by the scalar e.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 751 of file xindex_view.hpp.

+ +
+
+ +

◆ operator*=()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfiltration< ECT, CCT >::operator*= (const E & e) -> disable_xexpression<E, self_type&> +
+ 		+inline
+
+ +

Multiplies *this with the scalar e.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 717 of file xindex_view.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfiltration< ECT, CCT >::operator+= (const E & e) -> disable_xexpression<E, self_type&> +
+ 		+inline
+
+ +

Adds the scalar e to *this.

+
Parameters
+ + +
ethe scalar to add.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 683 of file xindex_view.hpp.

+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfiltration< ECT, CCT >::operator-= (const E & e) -> disable_xexpression<E, self_type&> +
+ 		+inline
+
+ +

Subtracts the scalar e from *this.

+
Parameters
+ + +
ethe scalar to subtract.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 700 of file xindex_view.hpp.

+ +
+
+ +

◆ operator/=()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfiltration< ECT, CCT >::operator/= (const E & e) -> disable_xexpression<E, self_type&> +
+ 		+inline
+
+ +

Divides *this by the scalar e.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 734 of file xindex_view.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<class ECT, class CCT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfiltration< ECT, CCT >::operator= (const E & e) -> disable_xexpression<E, self_type&> +
+ 		+inline
+
+ +

Assigns the scalar e to *this.

+
Parameters
+ + +
ethe scalar to assign.
+
+
+
Returns
a reference to \ *this.
+ +

Definition at line 660 of file xindex_view.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xindex_view.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xfiltration.js b/classxt_1_1xfiltration.js new file mode 100644 index 000000000..79872c570 --- /dev/null +++ b/classxt_1_1xfiltration.js @@ -0,0 +1,10 @@ +var classxt_1_1xfiltration = +[ + [ "xfiltration", "classxt_1_1xfiltration.html#a70544dbbc899cd02b70dc5c473bffd02", null ], + [ "operator%=", "classxt_1_1xfiltration.html#a75cb70a24a3740144a49ca60edfa6b65", null ], + [ "operator*=", "classxt_1_1xfiltration.html#a5911e1b618eb8b240f8f93accccda5d7", null ], + [ "operator+=", "classxt_1_1xfiltration.html#a2fae2b71a4134ec799668a13cdc60d9a", null ], + [ "operator-=", "classxt_1_1xfiltration.html#acfb314430c89b71133595cb83f84a75e", null ], + [ "operator/=", "classxt_1_1xfiltration.html#a2bc58cd24579e8d62efd55fdb750ed40", null ], + [ "operator=", "classxt_1_1xfiltration.html#a13d467d1d2a39fb0b3cdee0b60d2db68", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xfixed__adaptor-members.html b/classxt_1_1xfixed__adaptor-members.html new file mode 100644 index 000000000..bbe000d79 --- /dev/null +++ b/classxt_1_1xfixed__adaptor-members.html @@ -0,0 +1,283 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfixed_adaptor< EC, S, L, SH, Tag > Member List
+
+
+ +

This is the complete list of members for xt::xfixed_adaptor< EC, S, L, SH, Tag >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xfixed_adaptor< EC, S, L, SH, Tag > >inline
back()xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
back()xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
backstrides() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
backstrides_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
base_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
broadcast_shape(ST &s, bool reuse_cache=false) const (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >::broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
container_closure_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
data() noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
data() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
data_offset() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
dimension() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
expression_tag typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
fill(const T &value)xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
flat(size_type i)xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
flat(size_type i) constxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
front()xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
front()xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
inner_backstrides_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
inner_shape_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
inner_strides_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
is_contiguous() const noexcept (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
layout() const noexcept (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
N (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >static
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator=(const xfixed_adaptor &) (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
operator=(xfixed_adaptor &&) (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
operator=(temporary_type &&) (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
operator=(const xexpression< E > &e) (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
operator=(const xexpression< E > &e) -> self_type &xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >inline
reshape(ST &&shape, layout_type layout=L) constxt::xfixed_adaptor< EC, S, L, SH, Tag >inline
resize(ST &&shape, bool force=false) constxt::xfixed_adaptor< EC, S, L, SH, Tag >inline
resize(ST &&shape, layout_type l) constxt::xfixed_adaptor< EC, S, L, SH, Tag >inline
resize(ST &&shape, const strides_type &strides) constxt::xfixed_adaptor< EC, S, L, SH, Tag >inline
self_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
semantic_base typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
shape() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
shape_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
size() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
storage() noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
storage() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
storage_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
strides() const noexceptxt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
strides_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
temporary_type typedef (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
unchecked(Args... args) -> referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
unchecked(Args... args) -> referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >inline
xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > > (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >friend
xfixed_adaptor(storage_type &&data)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
xfixed_adaptor(const storage_type &data)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
xfixed_adaptor(D &&data)xt::xfixed_adaptor< EC, S, L, SH, Tag >inline
xfixed_adaptor(const xfixed_adaptor &)=default (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
xfixed_adaptor(xfixed_adaptor &&)=default (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
~xfixed_adaptor()=default (defined in xt::xfixed_adaptor< EC, S, L, SH, Tag >)xt::xfixed_adaptor< EC, S, L, SH, Tag >
+
+ + + + diff --git a/classxt_1_1xfixed__adaptor.html b/classxt_1_1xfixed__adaptor.html new file mode 100644 index 000000000..aa1a0a6e8 --- /dev/null +++ b/classxt_1_1xfixed__adaptor.html @@ -0,0 +1,1918 @@ + + + + + + + +xtensor: xt::xfixed_adaptor< EC, S, L, SH, Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xfixed_adaptor< EC, S, L, SH, Tag > Class Template Reference
+
+
+ +

Dense multidimensional container adaptor with tensor semantic and fixed dimension. + More...

+ +

#include <xfixed.hpp>

+
+Inheritance diagram for xt::xfixed_adaptor< EC, S, L, SH, Tag >:
+
+
+ + +xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > > +xt::xcontainer_semantic< xfixed_adaptor< EC, S, L, SH, Tag > > +xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > > +xt::xaccessible< xfixed_adaptor< EC, S, L, SH, Tag > > +xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > > +xt::xiterable< xfixed_adaptor< EC, S, L, SH, Tag > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using container_closure_type = EC
 
using self_type = xfixed_adaptor<EC, S, L, SH, Tag>
 
using base_type = xcontainer<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using storage_type = typename base_type::storage_type
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using inner_shape_type = typename base_type::inner_shape_type
 
using inner_strides_type = typename base_type::inner_strides_type
 
using inner_backstrides_type = typename base_type::inner_backstrides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using expression_tag = Tag
 
- Public Types inherited from xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
using derived_type
 
using inner_types
 
using storage_type
 
using allocator_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using accessible_base
 
using data_alignment
 
using simd_type
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using simd_return_type
 
using container_iterator
 
using const_container_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >
using derived_type
 
using inner_types
 
using iterable_base
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_traits
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using select_iterator_impl
 
using select_iterator
 
using select_const_iterator
 
using select_reverse_iterator
 
using select_const_reverse_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xfixed_adaptor< EC, S, L, SH, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xfixed_adaptor (const xfixed_adaptor &)=default
 
+ xfixed_adaptor (xfixed_adaptor &&)=default
 
+template<class E>
xfixed_adaptor & operator= (const xexpression< E > &e)
 
Constructors
 xfixed_adaptor (storage_type &&data)
 Constructs an xfixed_adaptor of the given stl-like container.
 
 xfixed_adaptor (const storage_type &data)
 Constructs an xfixed_adaptor of the given stl-like container.
 
template<class D>
 xfixed_adaptor (D &&data)
 Constructs an xfixed_adaptor of the given stl-like container, with the specified shape and layout_type.
 
xfixed_adaptor & operator= (const xfixed_adaptor &)
 
xfixed_adaptor & operator= (xfixed_adaptor &&)
 
xfixed_adaptor & operator= (temporary_type &&)
 
- Public Member Functions inherited from xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
void fill (const T &value)
 Fills the container with the given value.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
void store_simd (size_type i, const simd &e)
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
- Public Member Functions inherited from xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >
+select_iterator< L > begin () noexcept
 
+select_const_iterator< L > begin () const noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+select_iterator< L > end () noexcept
 
+select_const_iterator< L > end () const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+select_const_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+select_const_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+select_reverse_iterator< L > rbegin () noexcept
 
+select_const_reverse_iterator< L > rbegin () const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+select_reverse_iterator< L > rend () noexcept
 
+select_const_reverse_iterator< L > rend () const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xfixed_adaptor< EC, S, L, SH, Tag > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + + + +

+Static Public Attributes

static constexpr std::size_t N = S::size()
 
- Static Public Attributes inherited from xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< xfixed_adaptor< EC, S, L, SH, Tag > >
static constexpr layout_type static_layout
 
+ + + +

+Friends

class xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Extended copy semantic

template<class ST = std::array<std::size_t, N>>
void resize (ST &&shape, bool force=false) const
 Note that the xfixed_adaptor cannot be resized.
 
template<class ST = shape_type>
void resize (ST &&shape, layout_type l) const
 Note that the xfixed_adaptor cannot be resized.
 
template<class ST = shape_type>
void resize (ST &&shape, const strides_type &strides) const
 Note that the xfixed_adaptor cannot be resized.
 
template<class ST = std::array<std::size_t, N>>
const auto & reshape (ST &&shape, layout_type layout=L) const
 Note that the xfixed_container cannot be reshaped to a shape different from S.
 
template<class ST>
bool broadcast_shape (ST &s, bool reuse_cache=false) const
 
constexpr layout_type layout () const noexcept
 
bool is_contiguous () const noexcept
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
+ xcontainer (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xfixed_adaptor< EC, S, L, SH, Tag > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xfixed_adaptor< EC, S, L, SH, Tag > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class EC, class S, layout_type L, bool SH, class Tag>
+class xt::xfixed_adaptor< EC, S, L, SH, Tag >

Dense multidimensional container adaptor with tensor semantic and fixed dimension.

+

The xfixed_adaptor class implements a dense multidimensional container adaptor with tensor semantic and fixed dimension. It is used to provide a multidimensional container semantic and a tensor semantic to stl-like containers.

+
Template Parameters
+ + + + + + +
ECThe closure for the container type to adapt.
SThe xshape template parameter for the fixed shape of the adaptor
LThe layout_type of the adaptor.
SHWether the adaptor can be used as a shared expression.
TagThe expression tag.
+
+
+ +

Definition at line 430 of file xfixed.hpp.

+

Member Typedef Documentation

+ +

◆ backstrides_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 443 of file xfixed.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::base_type = xcontainer<self_type>
+
+ +

Definition at line 438 of file xfixed.hpp.

+ +
+
+ +

◆ container_closure_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::container_closure_type = EC
+
+ +

Definition at line 435 of file xfixed.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::expression_tag = Tag
+
+ +

Definition at line 448 of file xfixed.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::inner_backstrides_type = typename base_type::inner_backstrides_type
+
+ +

Definition at line 446 of file xfixed.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::inner_shape_type = typename base_type::inner_shape_type
+
+ +

Definition at line 444 of file xfixed.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::inner_strides_type = typename base_type::inner_strides_type
+
+ +

Definition at line 445 of file xfixed.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::self_type = xfixed_adaptor<EC, S, L, SH, Tag>
+
+ +

Definition at line 437 of file xfixed.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 439 of file xfixed.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 441 of file xfixed.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 440 of file xfixed.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 442 of file xfixed.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_adaptor< EC, S, L, SH, Tag >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 447 of file xfixed.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfixed_adaptor() [1/3]

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
xt::xfixed_adaptor< EC, S, L, SH, Tag >::xfixed_adaptor (storage_type && data)
+ 		+inline
+
+ +

Constructs an xfixed_adaptor of the given stl-like container.

+
Parameters
+ + +
datathe container to adapt
+
+
+ +

Definition at line 776 of file xfixed.hpp.

+ +
+
+ +

◆ xfixed_adaptor() [2/3]

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
xt::xfixed_adaptor< EC, S, L, SH, Tag >::xfixed_adaptor (const storage_type & data)
+ 		+inline
+
+ +

Constructs an xfixed_adaptor of the given stl-like container.

+
Parameters
+ + +
datathe container to adapt
+
+
+ +

Definition at line 787 of file xfixed.hpp.

+ +
+
+ +

◆ xfixed_adaptor() [3/3]

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+
+template<class D>
+ + + + + +
+ + + + + + + +
xt::xfixed_adaptor< EC, S, L, SH, Tag >::xfixed_adaptor (D && data)
+ 		+inline
+
+ +

Constructs an xfixed_adaptor of the given stl-like container, with the specified shape and layout_type.

+
Parameters
+ + +
datathe container to adapt
+
+
+ +

Definition at line 800 of file xfixed.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ broadcast_shape()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xfixed_adaptor< ET, S, L, SH, Tag >::broadcast_shape (ST & s,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Definition at line 908 of file xfixed.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
bool xt::xfixed_adaptor< EC, S, L, SH, Tag >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 932 of file xfixed.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
layout_type xt::xfixed_adaptor< EC, S, L, SH, Tag >::layout () const
+ 		+constexprnoexcept
+
+ +

Definition at line 926 of file xfixed.hpp.

+ +
+
+ +

◆ operator=() [1/4]

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfixed_adaptor< EC, S, L, SH, Tag >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 841 of file xfixed.hpp.

+ +
+
+ +

◆ operator=() [2/4]

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xfixed_adaptor< EC, S, L, SH, Tag >::operator= (const xfixed_adaptor< EC, S, L, SH, Tag > & rhs)
+ 		+inline
+
+ +

Definition at line 809 of file xfixed.hpp.

+ +
+
+ +

◆ operator=() [3/4]

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xfixed_adaptor< EC, S, L, SH, Tag >::operator= (temporary_type && rhs)
+ 		+inline
+
+ +

Definition at line 825 of file xfixed.hpp.

+ +
+
+ +

◆ operator=() [4/4]

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xfixed_adaptor< EC, S, L, SH, Tag >::operator= (xfixed_adaptor< EC, S, L, SH, Tag > && rhs)
+ 		+inline
+
+ +

Definition at line 817 of file xfixed.hpp.

+ +
+
+ +

◆ reshape()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
const auto & xt::xfixed_adaptor< ET, S, L, SH, Tag >::reshape (ST && shape,
layout_type layout = L ) const
+ 		+inline
+
+ +

Note that the xfixed_container cannot be reshaped to a shape different from S.

+ +

Definition at line 896 of file xfixed.hpp.

+ +
+
+ +

◆ resize() [1/3]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfixed_adaptor< ET, S, L, SH, Tag >::resize (ST && shape,
bool force = false ) const
+ 		+inline
+
+ +

Note that the xfixed_adaptor cannot be resized.

+

Attempting to resize with a different size throws an assert in debug mode.

+ +

Definition at line 854 of file xfixed.hpp.

+ +
+
+ +

◆ resize() [2/3]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfixed_adaptor< ET, S, L, SH, Tag >::resize (ST && shape,
const strides_type & strides ) const
+ 		+inline
+
+ +

Note that the xfixed_adaptor cannot be resized.

+

Attempting to resize with a different size throws an assert in debug mode.

+ +

Definition at line 881 of file xfixed.hpp.

+ +
+
+ +

◆ resize() [3/3]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfixed_adaptor< ET, S, L, SH, Tag >::resize (ST && shape,
layout_type l ) const
+ 		+inline
+
+ +

Note that the xfixed_adaptor cannot be resized.

+

Attempting to resize with a different size throws an assert in debug mode.

+ +

Definition at line 866 of file xfixed.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + +
friend class xcontainer< xfixed_adaptor< EC, S, L, SH, Tag > >
+ 		+friend
+
+ +

Definition at line 500 of file xfixed.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ N

+ +
+
+
+template<class EC, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + +
std::size_t xt::xfixed_adaptor< EC, S, L, SH, Tag >::N = S::size()
+ 		+staticconstexpr
+
+ +

Definition at line 450 of file xfixed.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xfixed.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xfixed__adaptor.js b/classxt_1_1xfixed__adaptor.js new file mode 100644 index 000000000..d209cec45 --- /dev/null +++ b/classxt_1_1xfixed__adaptor.js @@ -0,0 +1,11 @@ +var classxt_1_1xfixed__adaptor = +[ + [ "xfixed_adaptor", "classxt_1_1xfixed__adaptor.html#a4d68ba3b03788fbe1b70a7d6dce4040c", null ], + [ "xfixed_adaptor", "classxt_1_1xfixed__adaptor.html#adb3ce51eb417f3407c5b95d271c3f39c", null ], + [ "xfixed_adaptor", "classxt_1_1xfixed__adaptor.html#ab8855d521c67f4885638ab9d9108b36b", null ], + [ "operator=", "classxt_1_1xfixed__adaptor.html#a5eba04b65afb8377a248f1253605f7d2", null ], + [ "reshape", "classxt_1_1xfixed__adaptor.html#a5fe78e6500ce0bddc63c8b7de09b8031", null ], + [ "resize", "classxt_1_1xfixed__adaptor.html#a75fb0edc455232657d609bd9d79d6544", null ], + [ "resize", "classxt_1_1xfixed__adaptor.html#a656b75b805c1645d3c562a5797d7adb9", null ], + [ "resize", "classxt_1_1xfixed__adaptor.html#a10c880b192785a2108d5ab7047c1bed6", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xfixed__adaptor.png b/classxt_1_1xfixed__adaptor.png new file mode 100644 index 000000000..878f50f97 Binary files /dev/null and b/classxt_1_1xfixed__adaptor.png differ diff --git a/classxt_1_1xfixed__container-members.html b/classxt_1_1xfixed__container-members.html new file mode 100644 index 000000000..c6781f464 --- /dev/null +++ b/classxt_1_1xfixed__container-members.html @@ -0,0 +1,292 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfixed_container< ET, S, L, SH, Tag > Member List
+
+
+ +

This is the complete list of members for xt::xfixed_container< ET, S, L, SH, Tag >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xfixed_container< ET, S, L, SH, Tag > >inline
back()xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
back()xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
backstrides() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
backstrides_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
base_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
broadcast_shape(ST &s, bool reuse_cache=false) const (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >inline
xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >::broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
const_pointer typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
const_reference typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
data() noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
data() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
data_offset() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
dimension() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
expression_tag typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
fill(const T &value)xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
flat(size_type i)xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
flat(size_type i) constxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
from_shape(ST &&) (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >static
from_shape(ST &&shape) (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >inline
front()xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
front()xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
inner_backstrides_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
inner_shape_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
inner_strides_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
is_contiguous() const noexcept (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >inline
layout() const noexcept (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
N (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >static
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator=(const xfixed_container &)=default (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
operator=(xfixed_container &&)=default (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
operator=(const xexpression< E > &e) (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
operator=(const xexpression< E > &e) -> self_type &xt::xfixed_container< ET, S, L, SH, Tag >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >inline
pointer typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
rank (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >static
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
reference typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >inline
reshape(ST &&shape, layout_type layout=L) constxt::xfixed_container< ET, S, L, SH, Tag >inline
resize(ST &&shape, bool force=false) constxt::xfixed_container< ET, S, L, SH, Tag >inline
resize(ST &&shape, layout_type l) constxt::xfixed_container< ET, S, L, SH, Tag >inline
resize(ST &&shape, const strides_type &strides) constxt::xfixed_container< ET, S, L, SH, Tag >inline
self_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
semantic_base typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
shape() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
shape_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
size() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
storage() noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
storage() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
storage_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
strides() const noexceptxt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
strides_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
temporary_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
unchecked(Args... args) -> referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
unchecked(Args... args) -> referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xfixed_container< ET, S, L, SH, Tag > >inline
value_type typedef (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
xcontainer< xfixed_container< ET, S, L, SH, Tag > > (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >friend
xfixed_container()=default (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
xfixed_container(const value_type &v) (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >inline
xfixed_container(const inner_shape_type &shape, layout_type l=L)xt::xfixed_container< ET, S, L, SH, Tag >inlineexplicit
xfixed_container(const inner_shape_type &shape, value_type v, layout_type l=L)xt::xfixed_container< ET, S, L, SH, Tag >inlineexplicit
xfixed_container(nested_initializer_list_t< value_type, N > t)xt::xfixed_container< ET, S, L, SH, Tag >inline
xfixed_container(const xfixed_container &)=default (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
xfixed_container(xfixed_container &&)=default (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
xfixed_container(const xexpression< E > &e)xt::xfixed_container< ET, S, L, SH, Tag >inline
~xfixed_container()=default (defined in xt::xfixed_container< ET, S, L, SH, Tag >)xt::xfixed_container< ET, S, L, SH, Tag >
+
+ + + + diff --git a/classxt_1_1xfixed__container.html b/classxt_1_1xfixed__container.html new file mode 100644 index 000000000..fb873f8bd --- /dev/null +++ b/classxt_1_1xfixed__container.html @@ -0,0 +1,2066 @@ + + + + + + + +xtensor: xt::xfixed_container< ET, S, L, SH, Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xfixed_container< ET, S, L, SH, Tag > Class Template Reference
+
+
+ +

Dense multidimensional container with tensor semantic and fixed dimension. + More...

+ +

#include <xfixed.hpp>

+
+Inheritance diagram for xt::xfixed_container< ET, S, L, SH, Tag >:
+
+
+ + +xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > > +xt::xcontainer_semantic< xfixed_container< ET, S, L, SH, Tag > > +xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > > +xt::xaccessible< xfixed_container< ET, S, L, SH, Tag > > +xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > > +xt::xiterable< xfixed_container< ET, S, L, SH, Tag > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xfixed_container<ET, S, L, SH, Tag>
 
using base_type = xcontainer<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using storage_type = typename base_type::storage_type
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using shape_type = typename base_type::shape_type
 
using inner_shape_type = typename base_type::inner_shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using inner_backstrides_type = typename base_type::inner_backstrides_type
 
using inner_strides_type = typename base_type::inner_strides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using expression_tag = Tag
 
- Public Types inherited from xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
using derived_type
 
using inner_types
 
using storage_type
 
using allocator_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using accessible_base
 
using data_alignment
 
using simd_type
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using simd_return_type
 
using container_iterator
 
using const_container_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >
using derived_type
 
using inner_types
 
using iterable_base
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_traits
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using select_iterator_impl
 
using select_iterator
 
using select_const_iterator
 
using select_reverse_iterator
 
using select_const_reverse_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xfixed_container< ET, S, L, SH, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xfixed_container (const xfixed_container &)=default
 
+xfixed_container & operator= (const xfixed_container &)=default
 
+ xfixed_container (xfixed_container &&)=default
 
+xfixed_container & operator= (xfixed_container &&)=default
 
+template<class E>
xfixed_container & operator= (const xexpression< E > &e)
 
Constructors
 xfixed_container (const value_type &v)
 
 xfixed_container (const inner_shape_type &shape, layout_type l=L)
 Create an uninitialized xfixed_container.
 
 xfixed_container (const inner_shape_type &shape, value_type v, layout_type l=L)
 Create an xfixed_container, and initialize with the value of v.
 
template<class IX = std::integral_constant<std::size_t, N>>
+requires (IX::value != 0)
 xfixed_container (nested_initializer_list_t< value_type, N > t)
 Allocates an xfixed_container with shape S with values from a C array.
 
template<class ST>
xfixed_container< ET, S, L, SH, Tag > from_shape (ST &&shape)
 
- Public Member Functions inherited from xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
void fill (const T &value)
 Fills the container with the given value.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
void store_simd (size_type i, const simd &e)
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
- Public Member Functions inherited from xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >
+select_iterator< L > begin () noexcept
 
+select_const_iterator< L > begin () const noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+select_iterator< L > end () noexcept
 
+select_const_iterator< L > end () const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+select_const_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+select_const_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+select_reverse_iterator< L > rbegin () noexcept
 
+select_const_reverse_iterator< L > rbegin () const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+select_reverse_iterator< L > rend () noexcept
 
+select_const_reverse_iterator< L > rend () const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xfixed_container< ET, S, L, SH, Tag > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + +

+Static Public Member Functions

+template<class ST = std::array<std::size_t, N>>
static xfixed_container from_shape (ST &&)
 
+ + + + + + + + + + + + + +

+Static Public Attributes

static constexpr std::size_t N = std::tuple_size<shape_type>::value
 
static constexpr std::size_t rank = N
 
- Static Public Attributes inherited from xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< xfixed_container< ET, S, L, SH, Tag > >
static constexpr layout_type static_layout
 
+ + + +

+Friends

class xcontainer< xfixed_container< ET, S, L, SH, Tag > >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Extended copy semantic

template<class E>
 xfixed_container (const xexpression< E > &e)
 The extended copy constructor.
 
template<class ST = std::array<std::size_t, N>>
void resize (ST &&shape, bool force=false) const
 Note that the xfixed_container cannot be resized.
 
template<class ST = shape_type>
void resize (ST &&shape, layout_type l) const
 Note that the xfixed_container cannot be resized.
 
template<class ST = shape_type>
void resize (ST &&shape, const strides_type &strides) const
 Note that the xfixed_container cannot be resized.
 
template<class ST = std::array<std::size_t, N>>
const auto & reshape (ST &&shape, layout_type layout=L) const
 Note that the xfixed_container cannot be reshaped to a shape different from S.
 
template<class ST>
bool broadcast_shape (ST &s, bool reuse_cache=false) const
 
constexpr layout_type layout () const noexcept
 
bool is_contiguous () const noexcept
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xcontainer< xfixed_container< ET, S, L, SH, Tag > >
+ xcontainer (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xfixed_container< ET, S, L, SH, Tag > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xfixed_container< ET, S, L, SH, Tag > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class ET, class S, layout_type L, bool SH, class Tag>
+class xt::xfixed_container< ET, S, L, SH, Tag >

Dense multidimensional container with tensor semantic and fixed dimension.

+

The xfixed_container class implements a dense multidimensional container with tensor semantic and fixed dimension

+
Template Parameters
+ + + + + + +
ETThe type of the elements.
SThe xshape template paramter of the container.
LThe layout_type of the tensor.
SHWether the tensor can be used as a shared expression.
TagThe expression tag.
+
+
+
See also
xtensor_fixed
+ +

Definition at line 295 of file xfixed.hpp.

+

Member Typedef Documentation

+ +

◆ backstrides_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 313 of file xfixed.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::base_type = xcontainer<self_type>
+
+ +

Definition at line 301 of file xfixed.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 309 of file xfixed.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 307 of file xfixed.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::expression_tag = Tag
+
+ +

Definition at line 317 of file xfixed.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::inner_backstrides_type = typename base_type::inner_backstrides_type
+
+ +

Definition at line 314 of file xfixed.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::inner_shape_type = typename base_type::inner_shape_type
+
+ +

Definition at line 311 of file xfixed.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::inner_strides_type = typename base_type::inner_strides_type
+
+ +

Definition at line 315 of file xfixed.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::pointer = typename base_type::pointer
+
+ +

Definition at line 308 of file xfixed.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::reference = typename base_type::reference
+
+ +

Definition at line 306 of file xfixed.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::self_type = xfixed_container<ET, S, L, SH, Tag>
+
+ +

Definition at line 300 of file xfixed.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 302 of file xfixed.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 310 of file xfixed.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 304 of file xfixed.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 312 of file xfixed.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 316 of file xfixed.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + +
using xt::xfixed_container< ET, S, L, SH, Tag >::value_type = typename base_type::value_type
+
+ +

Definition at line 305 of file xfixed.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfixed_container() [1/5]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
xt::xfixed_container< ET, S, L, SH, Tag >::xfixed_container (const value_type & v)
+ 		+inline
+
+ +

Definition at line 532 of file xfixed.hpp.

+ +
+
+ +

◆ xfixed_container() [2/5]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + + + + + +
xt::xfixed_container< ET, S, L, SH, Tag >::xfixed_container (const inner_shape_type & shape,
layout_type l = L )
+ 		+inlineexplicit
+
+ +

Create an uninitialized xfixed_container.

+

Note this function is only provided for homogeneity, and the shape & layout argument is disregarded (the template shape is always used).

+
Parameters
+ + + +
shapethe shape of the xfixed_container (unused!)
lthe layout_type of the xfixed_container (unused!)
+
+
+ +

Definition at line 523 of file xfixed.hpp.

+ +
+
+ +

◆ xfixed_container() [3/5]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xfixed_container< ET, S, L, SH, Tag >::xfixed_container (const inner_shape_type & shape,
value_type v,
layout_type l = L )
+ 		+inlineexplicit
+
+ +

Create an xfixed_container, and initialize with the value of v.

+

Note, the shape argument to this function is only provided for homogeneity, and the shape argument is disregarded (the template shape is always used).

+
Parameters
+ + + + +
shapethe shape of the xfixed_container (unused!)
vthe fill value
lthe layout_type of the xfixed_container (unused!)
+
+
+ +

Definition at line 551 of file xfixed.hpp.

+ +
+
+ +

◆ xfixed_container() [4/5]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+requires (IX::value != 0)
+
+template<class IX>
+requires (IX::value != 0)
+ + + + + +
+ + + + + + + +
xt::xfixed_container< ET, S, L, SH, Tag >::xfixed_container (nested_initializer_list_t< value_type, N > t)
+ 		+inline
+
+ +

Allocates an xfixed_container with shape S with values from a C array.

+

The type returned by get_init_type_t is raw C array value_type[X][Y][Z] for xt::xshape<X, Y, Z>. C arrays can be initialized with the initializer list syntax, but the size is checked at compile time to prevent errors. Note: for clang < 3.8 this is an initializer_list and the size is not checked at compile-or runtime.

+ +

Definition at line 612 of file xfixed.hpp.

+ +
+
+ +

◆ xfixed_container() [5/5]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
xt::xfixed_container< ET, S, L, SH, Tag >::xfixed_container (const xexpression< E > & e)
+ 		+inline
+
+ +

The extended copy constructor.

+ +

Definition at line 634 of file xfixed.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ broadcast_shape()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xfixed_container< ET, S, L, SH, Tag >::broadcast_shape (ST & s,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Definition at line 711 of file xfixed.hpp.

+ +
+
+ +

◆ from_shape()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
xfixed_container< ET, S, L, SH, Tag > xt::xfixed_container< ET, S, L, SH, Tag >::from_shape (ST && shape)
+ 		+inline
+
+ +

Definition at line 595 of file xfixed.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
bool xt::xfixed_container< ET, S, L, SH, Tag >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 723 of file xfixed.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + + + + +
layout_type xt::xfixed_container< ET, S, L, SH, Tag >::layout () const
+ 		+constexprnoexcept
+
+ +

Definition at line 717 of file xfixed.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfixed_container< ET, S, L, SH, Tag >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 644 of file xfixed.hpp.

+ +
+
+ +

◆ reshape()

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
const auto & xt::xfixed_container< ET, S, L, SH, Tag >::reshape (ST && shape,
layout_type layout = L ) const
+ 		+inline
+
+ +

Note that the xfixed_container cannot be reshaped to a shape different from S.

+ +

Definition at line 699 of file xfixed.hpp.

+ +
+
+ +

◆ resize() [1/3]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfixed_container< ET, S, L, SH, Tag >::resize (ST && shape,
bool force = false ) const
+ 		+inline
+
+ +

Note that the xfixed_container cannot be resized.

+

Attempting to resize with a different size throws an assert in debug mode.

+ +

Definition at line 657 of file xfixed.hpp.

+ +
+
+ +

◆ resize() [2/3]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfixed_container< ET, S, L, SH, Tag >::resize (ST && shape,
const strides_type & strides ) const
+ 		+inline
+
+ +

Note that the xfixed_container cannot be resized.

+

Attempting to resize with a different size throws an assert in debug mode.

+ +

Definition at line 684 of file xfixed.hpp.

+ +
+
+ +

◆ resize() [3/3]

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfixed_container< ET, S, L, SH, Tag >::resize (ST && shape,
layout_type l ) const
+ 		+inline
+
+ +

Note that the xfixed_container cannot be resized.

+

Attempting to resize with a different size throws an assert in debug mode.

+ +

Definition at line 669 of file xfixed.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xcontainer< xfixed_container< ET, S, L, SH, Tag > >

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + +
friend class xcontainer< xfixed_container< ET, S, L, SH, Tag > >
+ 		+friend
+
+ +

Definition at line 378 of file xfixed.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ N

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + +
std::size_t xt::xfixed_container< ET, S, L, SH, Tag >::N = std::tuple_size<shape_type>::value
+ 		+staticconstexpr
+
+ +

Definition at line 319 of file xfixed.hpp.

+ +
+
+ +

◆ rank

+ +
+
+
+template<class ET, class S, layout_type L, bool SH, class Tag>
+ + + + + +
+ + + + +
std::size_t xt::xfixed_container< ET, S, L, SH, Tag >::rank = N
+ 		+staticconstexpr
+
+ +

Definition at line 320 of file xfixed.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xfixed.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xfixed__container.js b/classxt_1_1xfixed__container.js new file mode 100644 index 000000000..cd01e32d1 --- /dev/null +++ b/classxt_1_1xfixed__container.js @@ -0,0 +1,12 @@ +var classxt_1_1xfixed__container = +[ + [ "xfixed_container", "classxt_1_1xfixed__container.html#a004eaea5e4f5ef36e227b2673c11b4cd", null ], + [ "xfixed_container", "classxt_1_1xfixed__container.html#a41af8b86cc7d6df8d5713c29e404d4ab", null ], + [ "xfixed_container", "classxt_1_1xfixed__container.html#a5b08206bb93d07dc573823993aba8c67", null ], + [ "xfixed_container", "classxt_1_1xfixed__container.html#a0ddc275300f31caf95233120272df975", null ], + [ "operator=", "classxt_1_1xfixed__container.html#a02686e37949d2c9076cd7b5656e7db3b", null ], + [ "reshape", "classxt_1_1xfixed__container.html#ab5b58143fbfe4d0b7c0ea353526b286f", null ], + [ "resize", "classxt_1_1xfixed__container.html#a1c6d4565311f46f74edd7bfbbf6a2616", null ], + [ "resize", "classxt_1_1xfixed__container.html#a311dfc919ead913eb8c6f27b241619fb", null ], + [ "resize", "classxt_1_1xfixed__container.html#a591c135ebc74e8067d19a7503c635280", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xfixed__container.png b/classxt_1_1xfixed__container.png new file mode 100644 index 000000000..cd68caba7 Binary files /dev/null and b/classxt_1_1xfixed__container.png differ diff --git a/classxt_1_1xfunction-members.html b/classxt_1_1xfunction-members.html new file mode 100644 index 000000000..5594c8e9b --- /dev/null +++ b/classxt_1_1xfunction-members.html @@ -0,0 +1,234 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunction< F, CT > Member List
+
+
+ +

This is the complete list of members for xt::xfunction< F, CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
arguments() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
at(Args... args) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
back() constxt::xfunction< F, CT >
begin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
begin(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
bool_load_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
broadcast_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xfunction< F, CT >inline
build_stepper(Func &&f, std::index_sequence< I... >) const noexcept -> const_stepper (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
cbegin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
cbegin(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
cend() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
cend(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_broadcast_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_layout_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_linear_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_pointer typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_reference typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_reverse_broadcast_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_reverse_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_reverse_layout_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_reverse_linear_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
const_stepper typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
contiguous_layout (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >static
crbegin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
crbegin(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
crend() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
crend(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
data_element(size_type i) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
xt::derived_cast() &noexceptxt::xexpression< xfunction< F, CT... > >inline
xt::xsharable_expression< xfunction< F, CT... > >::derived_cast() const &noexceptxt::xexpression< xfunction< F, CT... > >inline
xt::xsharable_expression< xfunction< F, CT... > >::derived_cast() &&noexceptxt::xexpression< xfunction< F, CT... > >inline
difference_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
dimension() const noexceptxt::xfunction< F, CT >inline
element(It first, It last) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
element(It first, It last) const -> const_referencext::xfunction< F, CT >inline
end() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
end(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
expression_tag typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
extension_base typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
flat(size_type i) constxt::xfunction< F, CT >inline
front() constxt::xfunction< F, CT >
functor() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
functor_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
has_linear_assign(const S &strides) const noexceptxt::xfunction< F, CT >inline
in_bounds(Args... args) constxt::xfunction< F, CT >
inner_shape_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
inner_types typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
is_contiguous() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
iterable_base typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
layout() const noexceptxt::xfunction< F, CT >inline
layout_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
linear_begin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
linear_cbegin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
linear_cend() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
linear_crbegin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
linear_crend() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
linear_end() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
linear_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
linear_rbegin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
linear_rend() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
load_simd(size_type i) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
load_simd(size_type i) const -> simd_return_type< requested_type > (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
only_scalar typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
operator value_type() const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
operator()(Args... args) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
operator()(Args... args) const -> const_referencext::xfunction< F, CT >inline
operator=(const xfunction &)=default (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
operator=(xfunction &&)=default (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
operator[](const S &index) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
operator[](std::initializer_list< I > index) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
operator[](size_type i) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
periodic(Args... args) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
pointer typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
rbegin() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
rbegin(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
reference typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
rend() const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
rend(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
reverse_broadcast_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
reverse_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
reverse_layout_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
reverse_linear_iterator typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
self_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
shape() constxt::xfunction< F, CT >inline
shape(size_type index) constxt::xfunction< F, CT >
xt::xconst_accessible< xfunction< F, CT... > >::shape(size_type index) constxt::xconst_accessible< xfunction< F, CT... > >inlineprivate
shape_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
simd_return_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
simd_value_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
size() const noexcept(noexcept(derived_cast().shape()))xt::xfunction< F, CT >
size_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
static_layout (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >static
stepper typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
stepper_begin(const S &shape) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >inline
tuple_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
unchecked(Args... args) const (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
unchecked(Args... args) const -> const_referencext::xfunction< F, CT >inline
value_type typedef (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
xconst_accessible< self_type > (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >friend
xconst_iterable< self_type > (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >friend
xfunction(Func &&f, CTA &&... e) noexceptxt::xfunction< F, CT >inline
xfunction(xfunction< FA, CTA... > xf) noexceptxt::xfunction< F, CT >inline
xfunction(const xfunction &)=default (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
xfunction(xfunction &&)=default (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
xfunction_iterator< F, CT... > (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >friend
xfunction_stepper< F, CT... > (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >friend
~xfunction()=default (defined in xt::xfunction< F, CT >)xt::xfunction< F, CT >
+
+ + + + diff --git a/classxt_1_1xfunction.html b/classxt_1_1xfunction.html new file mode 100644 index 000000000..d1ecb655d --- /dev/null +++ b/classxt_1_1xfunction.html @@ -0,0 +1,2363 @@ + + + + + + + +xtensor: xt::xfunction< F, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xfunction< F, CT > Class Template Reference
+
+
+ +

Multidimensional function operating on xtensor expressions. + More...

+ +

#include <xfunction.hpp>

+
+Inheritance diagram for xt::xfunction< F, CT >:
+
+
+ + +xt::xconst_iterable< xfunction< F, CT... > > +xt::xsharable_expression< xfunction< F, CT... > > +xt::xconst_accessible< xfunction< F, CT... > > +xt::xexpression< xfunction< F, CT... > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xfunction<F, CT...>
 
using accessible_base = xconst_accessible<self_type>
 
using extension_base = extension::xfunction_base_t<F, CT...>
 
using expression_tag = typename extension_base::expression_tag
 
using only_scalar = all_xscalar<CT...>
 
using functor_type = typename std::remove_reference<F>::type
 
using tuple_type = std::tuple<CT...>
 
using inner_types = xcontainer_inner_types<self_type>
 
using value_type = typename inner_types::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = value_type*
 
using const_pointer = const value_type*
 
using size_type = typename inner_types::size_type
 
using difference_type = common_difference_type_t<std::decay_t<CT>...>
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = detail::xfunction_bool_load_type_t<CT...>
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
using iterable_base = xconst_iterable<xfunction<F, CT...>>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using shape_type = inner_shape_type
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
template<layout_type L>
using layout_iterator = typename iterable_base::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
 
using const_linear_iterator = xfunction_iterator<F, CT...>
 
using linear_iterator = const_linear_iterator
 
using const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>
 
using reverse_linear_iterator = std::reverse_iterator<linear_iterator>
 
using iterator = typename iterable_base::iterator
 
using const_iterator = typename iterable_base::const_iterator
 
using reverse_iterator = typename iterable_base::reverse_iterator
 
using const_reverse_iterator = typename iterable_base::const_reverse_iterator
 
- Public Types inherited from xt::xexpression< xfunction< F, CT... > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xfunction (const xfunction &)=default
 
+xfunction & operator= (const xfunction &)=default
 
+ xfunction (xfunction &&)=default
 
+xfunction & operator= (xfunction &&)=default
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+template<class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
simd_return_type< requested_type > load_simd (size_type i) const
 
+size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
+size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+const_reference operator[] (size_type i) const
 
+const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+const_reference front () const
 Returns a constant reference to first the element of the expression.
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
+const_reference periodic (Args... args) const
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_layout_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
Constructor
template<class Func, class... CTA, class U = std::enable_if_t<!std::is_base_of<std::decay_t<Func>, self_type>::value>>
 xfunction (Func &&f, CTA &&... e) noexcept
 Constructs an xfunction applying the specified function to the given arguments.
 
template<class FA, class... CTA>
 xfunction (xfunction< FA, CTA... > xf) noexcept
 Constructs an xfunction applying the specified function given by another xfunction with its arguments.
 
Data
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position of the underlying contiguous storage of the function.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the function.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the function.
 
- Public Member Functions inherited from xt::xexpression< xfunction< F, CT... > >
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = compute_layout(std::decay_t<CT>::static_layout...)
 
static constexpr bool contiguous_layout = static_layout != layout_type::dynamic
 
+ + + + + + + + + +

+Friends

class xfunction_iterator< F, CT... >
 
class xfunction_stepper< F, CT... >
 
class xconst_iterable< self_type >
 
class xconst_accessible< self_type >
 
+ + + + + + + + + + + + +

Size and shape

size_type dimension () const noexcept
 Returns the number of dimensions of the function.
 
const inner_shape_type & shape () const
 Returns the shape of the xfunction.
 
layout_type layout () const noexcept
 Returns the layout_type of the xfunction.
 
bool is_contiguous () const noexcept
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the function to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xfunction can be linearly assigned to an expression with the specified strides.
 
const_linear_iterator linear_begin () const noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
const_reference data_element (size_type i) const
 
template<class UT = self_type, class = typename std::enable_if<UT::only_scalar::value>::type>
 operator value_type () const
 
const tuple_type & arguments () const noexcept
 
const functor_type & functor () const noexcept
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
template<class align, class requested_type, std::size_t N>
auto load_simd (size_type i) const -> simd_return_type< requested_type >
 
template<class Func, std::size_t... I>
auto build_stepper (Func &&f, std::index_sequence< I... >) const noexcept -> const_stepper
 
+ + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xsharable_expression< xfunction< F, CT... > >
+ xsharable_expression (const xsharable_expression &)=default
 
+ xsharable_expression (xsharable_expression &&)=default
 
+xsharable_expression & operator= (const xsharable_expression &)=default
 
+xsharable_expression & operator= (xsharable_expression &&)=default
 
- Protected Member Functions inherited from xt::xexpression< xfunction< F, CT... > >
+ xexpression (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (const xexpression &)=default
 
+xexpression & operator= (xexpression &&)=default
 
+

Detailed Description

+
template<class F, class... CT>
+class xt::xfunction< F, CT >

Multidimensional function operating on xtensor expressions.

+

The xfunction class implements a multidimensional function operating on xtensor expressions.

+
Template Parameters
+ + + +
Fthe function type
CTthe closure types for arguments of the function
+
+
+ +

Definition at line 204 of file xfunction.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::accessible_base = xconst_accessible<self_type>
+
+ +

Definition at line 212 of file xfunction.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::bool_load_type = detail::xfunction_bool_load_type_t<CT...>
+
+ +

Definition at line 231 of file xfunction.hpp.

+ +
+
+ +

◆ broadcast_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunction< F, CT >::broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
+
+ +

Definition at line 256 of file xfunction.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunction< F, CT >::const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
+
+ +

Definition at line 258 of file xfunction.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::const_iterator = typename iterable_base::const_iterator
+
+ +

Definition at line 270 of file xfunction.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<layout_type L>
+ + + + +
using xt::xfunction< F, CT >::const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
+
+ +

Definition at line 249 of file xfunction.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::const_linear_iterator = xfunction_iterator<F, CT...>
+
+ +

Definition at line 264 of file xfunction.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::const_pointer = const value_type*
+
+ +

Definition at line 224 of file xfunction.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 222 of file xfunction.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunction< F, CT >::const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 262 of file xfunction.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::const_reverse_iterator = typename iterable_base::const_reverse_iterator
+
+ +

Definition at line 272 of file xfunction.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<layout_type L>
+ + + + +
using xt::xfunction< F, CT >::const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
+
+ +

Definition at line 253 of file xfunction.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>
+
+ +

Definition at line 266 of file xfunction.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 241 of file xfunction.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::difference_type = common_difference_type_t<std::decay_t<CT>...>
+
+ +

Definition at line 226 of file xfunction.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 214 of file xfunction.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::extension_base = extension::xfunction_base_t<F, CT...>
+
+ +

Definition at line 213 of file xfunction.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::functor_type = typename std::remove_reference<F>::type
+
+ +

Definition at line 216 of file xfunction.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 237 of file xfunction.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 219 of file xfunction.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::iterable_base = xconst_iterable<xfunction<F, CT...>>
+
+ +

Definition at line 236 of file xfunction.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::iterator = typename iterable_base::iterator
+
+ +

Definition at line 269 of file xfunction.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<layout_type L>
+ + + + +
using xt::xfunction< F, CT >::layout_iterator = typename iterable_base::template layout_iterator<L>
+
+ +

Definition at line 247 of file xfunction.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::linear_iterator = const_linear_iterator
+
+ +

Definition at line 265 of file xfunction.hpp.

+ +
+
+ +

◆ only_scalar

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::only_scalar = all_xscalar<CT...>
+
+ +

Definition at line 215 of file xfunction.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::pointer = value_type*
+
+ +

Definition at line 223 of file xfunction.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::reference = typename inner_types::reference
+
+ +

Definition at line 221 of file xfunction.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunction< F, CT >::reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 260 of file xfunction.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::reverse_iterator = typename iterable_base::reverse_iterator
+
+ +

Definition at line 271 of file xfunction.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class F, class... CT>
+
+template<layout_type L>
+ + + + +
using xt::xfunction< F, CT >::reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
+
+ +

Definition at line 251 of file xfunction.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::reverse_linear_iterator = std::reverse_iterator<linear_iterator>
+
+ +

Definition at line 267 of file xfunction.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::self_type = xfunction<F, CT...>
+
+ +

Definition at line 211 of file xfunction.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::shape_type = inner_shape_type
+
+ +

Definition at line 238 of file xfunction.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<class F, class... CT>
+
+template<class requested_type>
+ + + + +
using xt::xfunction< F, CT >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 234 of file xfunction.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 228 of file xfunction.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::size_type = typename inner_types::size_type
+
+ +

Definition at line 225 of file xfunction.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 240 of file xfunction.hpp.

+ +
+
+ +

◆ tuple_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::tuple_type = std::tuple<CT...>
+
+ +

Definition at line 217 of file xfunction.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction< F, CT >::value_type = typename inner_types::value_type
+
+ +

Definition at line 220 of file xfunction.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfunction() [1/2]

+ +
+
+
+template<class F, class... CT>
+
+template<class Func, class... CTA, class U>
+ + + + + +
+ + + + + + + + + + + +
xt::xfunction< F, CT >::xfunction (Func && f,
CTA &&... e )
+ 		+inlinenoexcept
+
+ +

Constructs an xfunction applying the specified function to the given arguments.

+
Parameters
+ + + +
fthe function to apply
ethe xexpression arguments
+
+
+ +

Definition at line 501 of file xfunction.hpp.

+ +
+
+ +

◆ xfunction() [2/2]

+ +
+
+
+template<class F, class... CT>
+
+template<class FA, class... CTA>
+ + + + + +
+ + + + + + + +
xt::xfunction< F, CT >::xfunction (xfunction< FA, CTA... > xf)
+ 		+inlinenoexcept
+
+ +

Constructs an xfunction applying the specified function given by another xfunction with its arguments.

+
Parameters
+ + +
xfthe xfunction to apply
+
+
+ +

Definition at line 514 of file xfunction.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ arguments()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::arguments () const
+ 		+inlinenoexcept
+
+ +

Definition at line 858 of file xfunction.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class F, class... CT>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xfunction< F, CT >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the function to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheboolean for reusing a previously computed shape
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 711 of file xfunction.hpp.

+ +
+
+ +

◆ build_stepper()

+ +
+
+
+template<class F, class... CT>
+
+template<class Func, std::size_t... I>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunction< F, CT >::build_stepper (Func && f,
std::index_sequence< I... >  ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 871 of file xfunction.hpp.

+ +
+
+ +

◆ data_element()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::data_element (size_type i) const
+ 		+inline
+
+ +

Definition at line 826 of file xfunction.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::dimension () const
+ 		+inlinenoexcept
+
+ +

Returns the number of dimensions of the function.

+ +

Definition at line 530 of file xfunction.hpp.

+ +
+
+ +

◆ element()

+ +
+
+
+template<class F, class... CT>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunction< F, CT >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the function.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 685 of file xfunction.hpp.

+ +
+
+ +

◆ flat()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::flat (size_type index) const
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position of the underlying contiguous storage of the function.

+
Parameters
+ + +
indexindex to underlying flat storage.
+
+
+ +

Definition at line 631 of file xfunction.hpp.

+ +
+
+ +

◆ functor()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::functor () const
+ 		+inlinenoexcept
+
+ +

Definition at line 864 of file xfunction.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class F, class... CT>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xfunction< F, CT >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xfunction can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 736 of file xfunction.hpp.

+ +
+
+ +

◆ in_bounds()

+ +
+
+
+template<class F, class... CT>
+ + + + + + + +
bool xt::xconst_accessible< self_type >::in_bounds (Args... args) const
+
+ +

Returns true only if the the specified position is a valid entry in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression.
+
+
+
Returns
bool
+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
bool xt::xfunction< F, CT >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 578 of file xfunction.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
layout_type xt::xfunction< F, CT >::layout () const
+ 		+inlinenoexcept
+
+ +

Returns the layout_type of the xfunction.

+ +

Definition at line 566 of file xfunction.hpp.

+ +
+
+ +

◆ linear_begin()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 748 of file xfunction.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 760 of file xfunction.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 770 of file xfunction.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 792 of file xfunction.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 798 of file xfunction.hpp.

+ +
+
+ +

◆ linear_end()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 754 of file xfunction.hpp.

+ +
+
+ +

◆ linear_rbegin()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 780 of file xfunction.hpp.

+ +
+
+ +

◆ linear_rend()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::linear_rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 786 of file xfunction.hpp.

+ +
+
+ +

◆ load_simd()

+ +
+
+
+template<class F, class... CT>
+
+template<class align, class requested_type, std::size_t N>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::load_simd (size_type i) const -> simd_return_type<requested_type> +
+ 		+inline
+
+ +

Definition at line 846 of file xfunction.hpp.

+ +
+
+ +

◆ operator value_type()

+ +
+
+
+template<class F, class... CT>
+
+template<class UT, class>
+ + + + + +
+ + + + + + + +
xt::xfunction< F, CT >::operator value_type () const
+ 		+inline
+
+ +

Definition at line 839 of file xfunction.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class F, class... CT>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the function.

+
Parameters
+ + +
argsa list of indices specifying the position in the function. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the function.
+
+
+ +

Definition at line 605 of file xfunction.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::shape () const
+ 		+inline
+
+ +

Returns the shape of the xfunction.

+ +

Definition at line 550 of file xfunction.hpp.

+ +
+
+ +

◆ stepper_begin()

+ +
+
+
+template<class F, class... CT>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 805 of file xfunction.hpp.

+ +
+
+ +

◆ stepper_end()

+ +
+
+
+template<class F, class... CT>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunction< F, CT >::stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 816 of file xfunction.hpp.

+ +
+
+ +

◆ unchecked()

+ +
+
+
+template<class F, class... CT>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xfunction< F, CT >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the expression, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.unchecked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 663 of file xfunction.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xconst_accessible< self_type >

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + +
friend class xconst_accessible< self_type >
+ 		+friend
+
+ +

Definition at line 369 of file xfunction.hpp.

+ +
+
+ +

◆ xconst_iterable< self_type >

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + +
friend class xconst_iterable< self_type >
+ 		+friend
+
+ +

Definition at line 369 of file xfunction.hpp.

+ +
+
+ +

◆ xfunction_iterator< F, CT... >

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + +
friend class xfunction_iterator< F, CT... >
+ 		+friend
+
+ +

Definition at line 369 of file xfunction.hpp.

+ +
+
+ +

◆ xfunction_stepper< F, CT... >

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + +
friend class xfunction_stepper< F, CT... >
+ 		+friend
+
+ +

Definition at line 369 of file xfunction.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + +
bool xt::xfunction< F, CT >::contiguous_layout = static_layout != layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 244 of file xfunction.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + +
layout_type xt::xfunction< F, CT >::static_layout = compute_layout(std::decay_t<CT>::static_layout...)
+ 		+staticconstexpr
+
+ +

Definition at line 243 of file xfunction.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xfunction.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xfunction.js b/classxt_1_1xfunction.js new file mode 100644 index 000000000..f062d1115 --- /dev/null +++ b/classxt_1_1xfunction.js @@ -0,0 +1,19 @@ +var classxt_1_1xfunction = +[ + [ "xfunction", "classxt_1_1xfunction.html#a63fa0bf1c338ba8ff119d97dc08de3b8", null ], + [ "xfunction", "classxt_1_1xfunction.html#a08a95dc45143b002b300a6634774940d", null ], + [ "back", "classxt_1_1xfunction.html#a02e02645e16da67cf9805d8bb06ec07e", null ], + [ "broadcast_shape", "classxt_1_1xfunction.html#a2ef3340ac01fdce40b012db3ca48d2ef", null ], + [ "dimension", "classxt_1_1xfunction.html#a55ade0ce540d29ce39f0ca051946ff96", null ], + [ "element", "classxt_1_1xfunction.html#a31d1e0136cb9cfd071120e47b10ecaea", null ], + [ "flat", "classxt_1_1xfunction.html#a8313f6caaa7e9229c10e3d221a8ab77b", null ], + [ "front", "classxt_1_1xfunction.html#abd9b67dadb00c0bd094a71fe99ab0dfe", null ], + [ "has_linear_assign", "classxt_1_1xfunction.html#a7007affb74eb4e8e6dfbba267f6de5ba", null ], + [ "in_bounds", "classxt_1_1xfunction.html#a1caad16507368ef12100f68950787c47", null ], + [ "layout", "classxt_1_1xfunction.html#a40bd918815f66f76ad0f05d3e33fbdbb", null ], + [ "operator()", "classxt_1_1xfunction.html#af161015b6c0ce2dc7654f26b6e1a16c2", null ], + [ "shape", "classxt_1_1xfunction.html#a41f3d01620f13c854d163235d03e534d", null ], + [ "shape", "classxt_1_1xfunction.html#ae7b5c2b34c43d49a8f2f82bd80ef30eb", null ], + [ "size", "classxt_1_1xfunction.html#acf990ad65941e747a737622343bb43c2", null ], + [ "unchecked", "classxt_1_1xfunction.html#ab99bdf99fd4e28328b2f4a24d6f763c2", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xfunction.png b/classxt_1_1xfunction.png new file mode 100644 index 000000000..a207cd962 Binary files /dev/null and b/classxt_1_1xfunction.png differ diff --git a/classxt_1_1xfunction__iterator-members.html b/classxt_1_1xfunction__iterator-members.html new file mode 100644 index 000000000..c33233f27 --- /dev/null +++ b/classxt_1_1xfunction__iterator-members.html @@ -0,0 +1,138 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunction_iterator< F, CT > Member List
+
+
+ +

This is the complete list of members for xt::xfunction_iterator< F, CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
equal(const self_type &rhs) const (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
functor_type typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
iterator_category typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
less_than(const self_type &rhs) const (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
operator*() const (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
operator++() (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
operator+=(difference_type n) (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
operator-(const self_type &rhs) const (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
operator--() (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
operator-=(difference_type n) (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
pointer typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
reference typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
self_type typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
tuple_max_diff(std::index_sequence< I... >, const data_type &lhs, const data_type &rhs) const -> difference_type (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
value_type typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
xfunction_iterator(const xfunction_type *func, It &&... it) noexcept (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >inline
xfunction_type typedef (defined in xt::xfunction_iterator< F, CT >)xt::xfunction_iterator< F, CT >
+
+ + + + diff --git a/classxt_1_1xfunction__iterator.html b/classxt_1_1xfunction__iterator.html new file mode 100644 index 000000000..823e74c42 --- /dev/null +++ b/classxt_1_1xfunction__iterator.html @@ -0,0 +1,635 @@ + + + + + + + +xtensor: xt::xfunction_iterator< F, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xfunction_iterator< F, CT > Class Template Reference
+
+
+
+Inheritance diagram for xt::xfunction_iterator< F, CT >:
+
+
+ +
+ + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xfunction_iterator<F, CT...>
 
using functor_type = typename std::remove_reference<F>::type
 
using xfunction_type = xfunction<F, CT...>
 
using value_type = typename xfunction_type::value_type
 
using reference = typename xfunction_type::value_type
 
using pointer = typename xfunction_type::const_pointer
 
using difference_type = typename xfunction_type::difference_type
 
using iterator_category = std::random_access_iterator_tag
 
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Broadcasting
template<class... It>
 xfunction_iterator (const xfunction_type *func, It &&... it) noexcept
 
self_type & operator++ ()
 
self_type & operator-- ()
 
self_type & operator+= (difference_type n)
 
self_type & operator-= (difference_type n)
 
difference_type operator- (const self_type &rhs) const
 
reference operator* () const
 
bool equal (const self_type &rhs) const
 
bool less_than (const self_type &rhs) const
 
template<std::size_t... I>
auto tuple_max_diff (std::index_sequence< I... >, const data_type &lhs, const data_type &rhs) const -> difference_type
 
+

Detailed Description

+
template<class F, class... CT>
+class xt::xfunction_iterator< F, CT >
+

Definition at line 382 of file xfunction.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::difference_type = typename xfunction_type::difference_type
+
+ +

Definition at line 398 of file xfunction.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::functor_type = typename std::remove_reference<F>::type
+
+ +

Definition at line 392 of file xfunction.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::iterator_category = std::random_access_iterator_tag
+
+ +

Definition at line 399 of file xfunction.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::pointer = typename xfunction_type::const_pointer
+
+ +

Definition at line 397 of file xfunction.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::reference = typename xfunction_type::value_type
+
+ +

Definition at line 396 of file xfunction.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::self_type = xfunction_iterator<F, CT...>
+
+ +

Definition at line 391 of file xfunction.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::value_type = typename xfunction_type::value_type
+
+ +

Definition at line 395 of file xfunction.hpp.

+ +
+
+ +

◆ xfunction_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_iterator< F, CT >::xfunction_type = xfunction<F, CT...>
+
+ +

Definition at line 393 of file xfunction.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfunction_iterator()

+ +
+
+
+template<class F, class... CT>
+
+template<class... It>
+ + + + + +
+ + + + + + + + + + + +
xt::xfunction_iterator< F, CT >::xfunction_iterator (const xfunction_type * func,
It &&... it )
+ 		+inlinenoexcept
+
+ +

Definition at line 900 of file xfunction.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ equal()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
bool xt::xfunction_iterator< F, CT >::equal (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 969 of file xfunction.hpp.

+ +
+
+ +

◆ less_than()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
bool xt::xfunction_iterator< F, CT >::less_than (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 979 of file xfunction.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_iterator< F, CT >::operator* () const
+ 		+inline
+
+ +

Definition at line 957 of file xfunction.hpp.

+ +
+
+ +

◆ operator++()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_iterator< F, CT >::operator++ ()
+ 		+inline
+
+ +

Definition at line 907 of file xfunction.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_iterator< F, CT >::operator+= (difference_type n)
+ 		+inline
+
+ +

Definition at line 929 of file xfunction.hpp.

+ +
+
+ +

◆ operator-()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_iterator< F, CT >::operator- (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 951 of file xfunction.hpp.

+ +
+
+ +

◆ operator--()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_iterator< F, CT >::operator-- ()
+ 		+inline
+
+ +

Definition at line 918 of file xfunction.hpp.

+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_iterator< F, CT >::operator-= (difference_type n)
+ 		+inline
+
+ +

Definition at line 940 of file xfunction.hpp.

+ +
+
+ +

◆ tuple_max_diff()

+ +
+
+
+template<class F, class... CT>
+
+template<std::size_t... I>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xfunction_iterator< F, CT >::tuple_max_diff (std::index_sequence< I... > ,
const data_type & lhs,
const data_type & rhs ) const -> difference_type +
+ 		+inline
+
+ +

Definition at line 990 of file xfunction.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xfunction.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xfunction__iterator.png b/classxt_1_1xfunction__iterator.png new file mode 100644 index 000000000..0c7b3f77d Binary files /dev/null and b/classxt_1_1xfunction__iterator.png differ diff --git a/classxt_1_1xfunction__stepper-members.html b/classxt_1_1xfunction__stepper-members.html new file mode 100644 index 000000000..cda5edc5b --- /dev/null +++ b/classxt_1_1xfunction__stepper-members.html @@ -0,0 +1,143 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunction_stepper< F, CT > Member List
+
+
+ +

This is the complete list of members for xt::xfunction_stepper< F, CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
functor_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
operator*() const (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
pointer typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
reference typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
reset(size_type dim) (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
reset_back(size_type dim) (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
self_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
shape_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
simd_return_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
size_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
step(size_type dim) (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
step(size_type dim, size_type n) (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
step_back(size_type dim) (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
step_back(size_type dim, size_type n) (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
step_leading() (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
step_simd() (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
step_simd() -> simd_return_type< T > (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
to_begin() (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
to_end(layout_type l) (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
value_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
xfunction_stepper(const xfunction_type *func, St &&... st) noexcept (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >inline
xfunction_type typedef (defined in xt::xfunction_stepper< F, CT >)xt::xfunction_stepper< F, CT >
+
+ + + + diff --git a/classxt_1_1xfunction__stepper.html b/classxt_1_1xfunction__stepper.html new file mode 100644 index 000000000..c9bf973dd --- /dev/null +++ b/classxt_1_1xfunction__stepper.html @@ -0,0 +1,738 @@ + + + + + + + +xtensor: xt::xfunction_stepper< F, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xfunction_stepper< F, CT > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xfunction_stepper<F, CT...>
 
using functor_type = typename std::remove_reference<F>::type
 
using xfunction_type = xfunction<F, CT...>
 
using value_type = typename xfunction_type::value_type
 
using reference = typename xfunction_type::reference
 
using pointer = typename xfunction_type::const_pointer
 
using size_type = typename xfunction_type::size_type
 
using difference_type = typename xfunction_type::difference_type
 
using shape_type = typename xfunction_type::shape_type
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class T>
simd_return_type< T > step_simd ()
 
Broadcasting
template<class... St>
 xfunction_stepper (const xfunction_type *func, St &&... st) noexcept
 
void step (size_type dim)
 
void step_back (size_type dim)
 
void step (size_type dim, size_type n)
 
void step_back (size_type dim, size_type n)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
reference operator* () const
 
void step_leading ()
 
template<class T>
auto step_simd () -> simd_return_type< T >
 
+

Detailed Description

+
template<class F, class... CT>
+class xt::xfunction_stepper< F, CT >
+

Definition at line 440 of file xfunction.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::difference_type = typename xfunction_type::difference_type
+
+ +

Definition at line 452 of file xfunction.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::functor_type = typename std::remove_reference<F>::type
+
+ +

Definition at line 445 of file xfunction.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::pointer = typename xfunction_type::const_pointer
+
+ +

Definition at line 450 of file xfunction.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::reference = typename xfunction_type::reference
+
+ +

Definition at line 449 of file xfunction.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::self_type = xfunction_stepper<F, CT...>
+
+ +

Definition at line 444 of file xfunction.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::shape_type = typename xfunction_type::shape_type
+
+ +

Definition at line 454 of file xfunction.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<class F, class... CT>
+
+template<class requested_type>
+ + + + +
using xt::xfunction_stepper< F, CT >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 457 of file xfunction.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::size_type = typename xfunction_type::size_type
+
+ +

Definition at line 451 of file xfunction.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::value_type = typename xfunction_type::value_type
+
+ +

Definition at line 448 of file xfunction.hpp.

+ +
+
+ +

◆ xfunction_type

+ +
+
+
+template<class F, class... CT>
+ + + + +
using xt::xfunction_stepper< F, CT >::xfunction_type = xfunction<F, CT...>
+
+ +

Definition at line 446 of file xfunction.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfunction_stepper()

+ +
+
+
+template<class F, class... CT>
+
+template<class... St>
+ + + + + +
+ + + + + + + + + + + +
xt::xfunction_stepper< F, CT >::xfunction_stepper (const xfunction_type * func,
St &&... st )
+ 		+inlinenoexcept
+
+ +

Definition at line 1022 of file xfunction.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_stepper< F, CT >::operator* () const
+ 		+inline
+
+ +

Definition at line 1109 of file xfunction.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
void xt::xfunction_stepper< F, CT >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 1069 of file xfunction.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
void xt::xfunction_stepper< F, CT >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 1079 of file xfunction.hpp.

+ +
+
+ +

◆ step() [1/2]

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
void xt::xfunction_stepper< F, CT >::step (size_type dim)
+ 		+inline
+
+ +

Definition at line 1029 of file xfunction.hpp.

+ +
+
+ +

◆ step() [2/2]

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfunction_stepper< F, CT >::step (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 1049 of file xfunction.hpp.

+ +
+
+ +

◆ step_back() [1/2]

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
void xt::xfunction_stepper< F, CT >::step_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 1039 of file xfunction.hpp.

+ +
+
+ +

◆ step_back() [2/2]

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + + + + + +
void xt::xfunction_stepper< F, CT >::step_back (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 1059 of file xfunction.hpp.

+ +
+
+ +

◆ step_leading()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
void xt::xfunction_stepper< F, CT >::step_leading ()
+ 		+inline
+
+ +

Definition at line 1134 of file xfunction.hpp.

+ +
+
+ +

◆ step_simd()

+ +
+
+
+template<class F, class... CT>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xfunction_stepper< F, CT >::step_simd () -> simd_return_type<T> +
+ 		+inline
+
+ +

Definition at line 1122 of file xfunction.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
void xt::xfunction_stepper< F, CT >::to_begin ()
+ 		+inline
+
+ +

Definition at line 1089 of file xfunction.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class F, class... CT>
+ + + + + +
+ + + + + + + +
void xt::xfunction_stepper< F, CT >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 1099 of file xfunction.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xfunction.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xfunctor__adaptor-members.html b/classxt_1_1xfunctor__adaptor-members.html new file mode 100644 index 000000000..2dc5fea1e --- /dev/null +++ b/classxt_1_1xfunctor__adaptor-members.html @@ -0,0 +1,253 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunctor_adaptor< F, CT > Member List
+
+
+ +

This is the complete list of members for xt::xfunctor_adaptor< F, CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xfunctor_adaptor< F, CT > >inline
back()xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
back() constxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
back()xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
back() constxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
backstrides() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
base_type typedef (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
begin() noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
begin() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
cbegin() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
cend() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
crbegin(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
crbegin() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
crbegin(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
crend() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
element(IT first, IT last) -> referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
element(IT first, IT last) const -> const_referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
element(IT first, IT last) -> referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
element(IT first, IT last) const -> const_referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
end() noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
end() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
expression() noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
expression() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
front()xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
front() constxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
front()xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
front() constxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
has_linear_assign(const S &strides) constxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
layout() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator()(Args... args) -> referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
operator()(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
operator()(Args... args) -> referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
operator()(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator=(const xexpression< E > &e) (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
operator=(const E &e) (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
operator=(const xexpression< E > &e) -> self_type &xt::xfunctor_adaptor< F, CT >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_adaptor< F, CT > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rbegin() noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rbegin() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rend(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rend() noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rend() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
rend(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
reshape(S &&shape, layout_type layout=base_type::static_layout) & (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
resize(S &&shape, bool force=false) (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
resize(S &&shape, layout_type l) (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
resize(S &&shape, const strides_type &strides) (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
self_type typedef (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
semantic_base typedef (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
shape() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
shape_type typedef (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
size() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
strides() const noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
strides_type typedef (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
unchecked(Args... args) -> referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
unchecked(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
unchecked(Args... args) -> referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
unchecked(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
xaccessible< self_type > (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >friend
xcontainer_semantic< self_type > (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >friend
xexpression_type typedef (defined in xt::xfunctor_adaptor< F, CT >)xt::xfunctor_adaptor< F, CT >
xfunctor_applier_base(undecay_expression) noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inlineexplicit
xfunctor_applier_base(Func &&, E &&) noexceptxt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >inline
+
+ + + + diff --git a/classxt_1_1xfunctor__adaptor.html b/classxt_1_1xfunctor__adaptor.html new file mode 100644 index 000000000..c7f120933 --- /dev/null +++ b/classxt_1_1xfunctor__adaptor.html @@ -0,0 +1,1296 @@ + + + + + + + +xtensor: xt::xfunctor_adaptor< F, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
xt::xfunctor_adaptor< F, CT > Class Template Reference
Functor view
+
+
+ +

Adapt a container with a functor, forwarding methods such as resize / reshape. + More...

+ +

#include <xfunctor_view.hpp>

+
+Inheritance diagram for xt::xfunctor_adaptor< F, CT >:
+
+
+ + +xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > > +xt::xcontainer_semantic< xfunctor_adaptor< F, CT > > +xt::xaccessible< xfunctor_adaptor< F, CT > > +xt::xsemantic_base< xfunctor_adaptor< F, CT > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xfunctor_adaptor<F, CT>
 
using semantic_base = xcontainer_semantic<self_type>
 
using xexpression_type = std::decay_t<CT>
 
using base_type = xfunctor_applier_base<self_type>
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename xexpression_type::strides_type
 
- Public Types inherited from xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
using self_type
 
using inner_types
 
using xexpression_type
 
using undecay_expression
 
using functor_type
 
using accessible_base
 
using extension_base
 
using expression_tag
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using bool_load_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xfunctor_adaptor< F, CT > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xfunctor_adaptor< F, CT > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
Extended copy semantic
template<class S = shape_type>
auto resize (S &&shape, bool force=false)
 
template<class S = shape_type>
auto resize (S &&shape, layout_type l)
 
template<class S = shape_type>
auto resize (S &&shape, const strides_type &strides)
 
template<class S = shape_type>
auto & reshape (S &&shape, layout_type layout=base_type::static_layout) &
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
- Public Member Functions inherited from xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
+reference at (Args... args)
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+const_reference operator[] (size_type i) const
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+reference periodic (Args... args)
 
+const_reference periodic (Args... args) const
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (IT first, IT last)
 
+const_reference element (IT first, IT last) const
 
auto data_element (size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().data_element(i)))
 
auto data_element (size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().data_element(i)))
 
auto flat (size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().flat(i)))
 
auto flat (size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().flat(i)))
 
auto load_simd (size_type i) const -> decltype(std::declval< FCT >().template proxy_simd_load< align, requested_type, N >(std::declval< undecay_expression >(), i))
 
auto store_simd (size_type i, const simd &e) -> decltype(std::declval< FCT >() .template proxy_simd_store< align >(std::declval< undecay_expression >(), i, e))
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+reference at (Args... args)
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
reference back ()
 Returns a reference to the last element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+reference periodic (Args... args)
 
+const_reference periodic (Args... args) const
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
const xexpression_type & expression () const noexcept
 Returns a consttant reference to the underlying expression of the view.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
 xfunctor_applier_base (undecay_expression) noexcept
 Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
 
 xfunctor_applier_base (Func &&, E &&) noexcept
 Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
 
size_type size () const noexcept
 Returns the size of the expression.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the expression.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the expression.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the expression.
 
layout_type layout () const noexcept
 Returns the layout_type of the expression.
 
bool is_contiguous () const noexcept
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the function to the specified parameter.
 
bool has_linear_assign (const S &strides) const
 Checks whether the xfunctor_applier_base can be linearly assigned to an expression with the specified strides.
 
auto begin () noexcept
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xfunctor_adaptor< F, CT > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xfunctor_adaptor< F, CT > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + +

+Friends

class xcontainer_semantic< self_type >
 
class xaccessible< self_type >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Attributes inherited from xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xfunctor_adaptor< F, CT > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xfunctor_adaptor< F, CT > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Attributes inherited from xt::xfunctor_applier_base< xfunctor_adaptor< F, CT > >
undecay_expression m_e
 
functor_type m_functor
 
+

Detailed Description

+
template<class F, class CT>
+class xt::xfunctor_adaptor< F, CT >

Adapt a container with a functor, forwarding methods such as resize / reshape.

+

xt::xfunctor_adaptor has a container semantics and can only be used with containers. For a similar feature with a view semantics, one can use xt::xfunctor_view.

+
Template Parameters
+ + + +
Fthe functor type to be applied to the elements of specified expression.
CTthe closure type of the xt::xexpression type underlying this view
+
+
+
See also
xt::xfunctor_view
+ +

Definition at line 509 of file xfunctor_view.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_adaptor< F, CT >::base_type = xfunctor_applier_base<self_type>
+
+ +

Definition at line 518 of file xfunctor_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_adaptor< F, CT >::self_type = xfunctor_adaptor<F, CT>
+
+ +

Definition at line 515 of file xfunctor_view.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_adaptor< F, CT >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 516 of file xfunctor_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_adaptor< F, CT >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 519 of file xfunctor_view.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_adaptor< F, CT >::strides_type = typename xexpression_type::strides_type
+
+ +

Definition at line 520 of file xfunctor_view.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_adaptor< F, CT >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 517 of file xfunctor_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator=()

+ +
+
+
+template<class F, class CT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_adaptor< F, CT >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 1454 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reshape()

+ +
+
+
+template<class F, class CT>
+
+template<class S>
+ + + + + + + + + + + +
auto & xt::xfunctor_adaptor< F, CT >::reshape (S && shape,
layout_type layout = base_type::static_layout ) &
+
+ +

Definition at line 1497 of file xfunctor_view.hpp.

+ +
+
+ +

◆ resize() [1/3]

+ +
+
+
+template<class F, class CT>
+
+template<class S>
+ + + + + + + + + + + +
auto xt::xfunctor_adaptor< F, CT >::resize (S && shape,
bool force = false )
+
+ +

Definition at line 1476 of file xfunctor_view.hpp.

+ +
+
+ +

◆ resize() [2/3]

+ +
+
+
+template<class F, class CT>
+
+template<class S>
+ + + + + + + + + + + +
auto xt::xfunctor_adaptor< F, CT >::resize (S && shape,
const strides_type & strides )
+
+ +

Definition at line 1490 of file xfunctor_view.hpp.

+ +
+
+ +

◆ resize() [3/3]

+ +
+
+
+template<class F, class CT>
+
+template<class S>
+ + + + + + + + + + + +
auto xt::xfunctor_adaptor< F, CT >::resize (S && shape,
layout_type l )
+
+ +

Definition at line 1483 of file xfunctor_view.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< self_type >

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + +
friend class xaccessible< self_type >
+ 		+friend
+
+ +

Definition at line 545 of file xfunctor_view.hpp.

+ +
+
+ +

◆ xcontainer_semantic< self_type >

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + +
friend class xcontainer_semantic< self_type >
+ 		+friend
+
+ +

Definition at line 545 of file xfunctor_view.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xfunctor__adaptor.js b/classxt_1_1xfunctor__adaptor.js new file mode 100644 index 000000000..9cd5bc9a3 --- /dev/null +++ b/classxt_1_1xfunctor__adaptor.js @@ -0,0 +1,4 @@ +var classxt_1_1xfunctor__adaptor = +[ + [ "operator=", "classxt_1_1xfunctor__adaptor.html#a4eaf31a6089dc47d2e772fa6590514bd", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xfunctor__adaptor.png b/classxt_1_1xfunctor__adaptor.png new file mode 100644 index 000000000..f8733bbca Binary files /dev/null and b/classxt_1_1xfunctor__adaptor.png differ diff --git a/classxt_1_1xfunctor__applier__base-members.html b/classxt_1_1xfunctor__applier__base-members.html new file mode 100644 index 000000000..6b02efd2b --- /dev/null +++ b/classxt_1_1xfunctor__applier__base-members.html @@ -0,0 +1,267 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunctor_applier_base< D > Member List
+
+
+ +

This is the complete list of members for xt::xfunctor_applier_base< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
at(Args... args) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
at(Args... args) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
back()xt::xfunctor_applier_base< D >inline
back() constxt::xfunctor_applier_base< D >inline
backstrides() const noexceptxt::xfunctor_applier_base< D >inline
backstrides_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
begin() noexceptxt::xfunctor_applier_base< D >inline
begin() const noexceptxt::xfunctor_applier_base< D >inline
begin(const S &shape) noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
begin(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
bool_load_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
broadcast_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xfunctor_applier_base< D >inline
cbegin() const noexceptxt::xfunctor_applier_base< D >inline
cbegin(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
cend() const noexceptxt::xfunctor_applier_base< D >inline
cend(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
const_broadcast_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_layout_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_linear_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_pointer typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_reference typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_reverse_broadcast_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_reverse_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_reverse_layout_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_reverse_linear_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
const_stepper typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
contiguous_layout (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >static
crbegin() const noexceptxt::xfunctor_applier_base< D >inline
crbegin(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
crbegin(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
crend() const noexceptxt::xfunctor_applier_base< D >inline
crend(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
data_element(size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().data_element(i))) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
data_element(size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().data_element(i))) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
difference_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
element(IT first, IT last) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
element(IT first, IT last) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
element(IT first, IT last) -> referencext::xfunctor_applier_base< D >inline
element(IT first, IT last) const -> const_referencext::xfunctor_applier_base< D >inline
end() noexceptxt::xfunctor_applier_base< D >inline
end() const noexceptxt::xfunctor_applier_base< D >inline
end(const S &shape) noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
end(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
expression() noexceptxt::xfunctor_applier_base< D >inline
expression() const noexceptxt::xfunctor_applier_base< D >inline
expression_tag typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
extension_base typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
flat(size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().flat(i))) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
flat(size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().flat(i))) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
front()xt::xfunctor_applier_base< D >inline
front() constxt::xfunctor_applier_base< D >inline
functor_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
has_linear_assign(const S &strides) constxt::xfunctor_applier_base< D >inline
inner_backstrides_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
inner_shape_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
inner_strides_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
inner_types typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
is_contiguous() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
layout() const noexceptxt::xfunctor_applier_base< D >inline
layout_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
linear_begin() noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_begin() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_cbegin() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_cend() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_crbegin() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_crend() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_end() noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_end() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
linear_rbegin() noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_rbegin() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_rend() noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
linear_rend() const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
load_simd(size_type i) const -> decltype(std::declval< FCT >().template proxy_simd_load< align, requested_type, N >(std::declval< undecay_expression >(), i)) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
m_e (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >protected
m_functor (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >protected
operator()(Args... args) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
operator()(Args... args) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
operator()(Args... args) -> referencext::xfunctor_applier_base< D >inline
operator()(Args... args) const -> const_referencext::xfunctor_applier_base< D >inline
operator[](const S &index) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
operator[](std::initializer_list< I > index) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
operator[](size_type i) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
operator[](const S &index) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
operator[](std::initializer_list< I > index) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
operator[](size_type i) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
periodic(Args... args) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
periodic(Args... args) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
pointer typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
rbegin() noexceptxt::xfunctor_applier_base< D >inline
rbegin() const noexceptxt::xfunctor_applier_base< D >inline
rbegin(const S &shape) noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
rbegin(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
reference typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
rend() noexceptxt::xfunctor_applier_base< D >inline
rend() const noexceptxt::xfunctor_applier_base< D >inline
rend(const S &shape) noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
rend(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
rend(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< D >inline
reverse_broadcast_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
reverse_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
reverse_layout_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
reverse_linear_iterator typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
self_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
shape() const noexceptxt::xfunctor_applier_base< D >inline
xt::xaccessible::shape(size_type index) constxt::xconst_accessible< D >inlineprivate
shape_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
size() const noexceptxt::xfunctor_applier_base< D >inline
size_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
static_layout (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >static
stepper typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
stepper_begin(const S &shape) noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
stepper_begin(const S &shape) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
stepper_end(const S &shape, layout_type l) noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
stepper_end(const S &shape, layout_type l) noexcept -> stepper (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
store_simd(size_type i, const simd &e) -> decltype(std::declval< FCT >() .template proxy_simd_store< align >(std::declval< undecay_expression >(), i, e)) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >inline
strides() const noexceptxt::xfunctor_applier_base< D >inline
strides_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
unchecked(Args... args) (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
unchecked(Args... args) const (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
unchecked(Args... args) -> referencext::xfunctor_applier_base< D >inline
unchecked(Args... args) const -> const_referencext::xfunctor_applier_base< D >inline
undecay_expression typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
value_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
xaccessible< D > (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >friend
xconst_accessible< D > (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >friend
xexpression_type typedef (defined in xt::xfunctor_applier_base< D >)xt::xfunctor_applier_base< D >
xfunctor_applier_base(undecay_expression) noexceptxt::xfunctor_applier_base< D >inlineexplicit
xfunctor_applier_base(Func &&, E &&) noexceptxt::xfunctor_applier_base< D >inline
+
+ + + + diff --git a/classxt_1_1xfunctor__applier__base.html b/classxt_1_1xfunctor__applier__base.html new file mode 100644 index 000000000..898e2cff5 --- /dev/null +++ b/classxt_1_1xfunctor__applier__base.html @@ -0,0 +1,4123 @@ + + + + + + + +xtensor: xt::xfunctor_applier_base< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Protected Attributes | +Friends | +List of all members
+
xt::xfunctor_applier_base< D > Class Template Reference
+
+
+
+Inheritance diagram for xt::xfunctor_applier_base< D >:
+
+
+ + +xt::xaccessible< D > +xt::xfunctor_view< F, uvt > +xt::xfunctor_view< F, ucvt > +xt::xfunctor_view< F, E > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xfunctor_applier_base<D>
 
using inner_types = xcontainer_inner_types<D>
 
using xexpression_type = typename inner_types::xexpression_type
 
using undecay_expression = typename inner_types::undecay_expression
 
using functor_type = typename inner_types::functor_type
 
using accessible_base = xaccessible<D>
 
using extension_base = extension::xfunctor_view_base_t<functor_type, undecay_expression>
 
using expression_tag = typename extension_base::expression_tag
 
using value_type = typename functor_type::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = typename functor_type::pointer
 
using const_pointer = typename functor_type::const_pointer
 
using size_type = typename inner_types::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using shape_type = typename xexpression_type::shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type = typename xexpression_type::inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using bool_load_type = xt::bool_load_type<value_type>
 
using stepper = xfunctor_stepper<functor_type, typename xexpression_type::stepper>
 
using const_stepper = xfunctor_stepper<const functor_type, typename xexpression_type::const_stepper>
 
template<layout_type L>
using layout_iterator = xfunctor_iterator<functor_type, typename xexpression_type::template layout_iterator<L>>
 
template<layout_type L>
using const_layout_iterator
 
template<layout_type L>
using reverse_layout_iterator
 
template<layout_type L>
using const_reverse_layout_iterator
 
template<class S, layout_type L>
using broadcast_iterator = xfunctor_iterator<functor_type, xiterator<typename xexpression_type::stepper, S, L>>
 
template<class S, layout_type L>
using const_broadcast_iterator
 
template<class S, layout_type L>
using reverse_broadcast_iterator
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator
 
using linear_iterator = xfunctor_iterator<functor_type, typename xexpression_type::linear_iterator>
 
using const_linear_iterator = xfunctor_iterator<const functor_type, typename xexpression_type::const_linear_iterator>
 
using reverse_linear_iterator = xfunctor_iterator<functor_type, typename xexpression_type::reverse_linear_iterator>
 
using const_reverse_linear_iterator
 
using iterator = xfunctor_iterator<functor_type, typename xexpression_type::iterator>
 
using const_iterator = xfunctor_iterator<const functor_type, typename xexpression_type::const_iterator>
 
using reverse_iterator = xfunctor_iterator<functor_type, typename xexpression_type::reverse_iterator>
 
using const_reverse_iterator = xfunctor_iterator<const functor_type, typename xexpression_type::const_reverse_iterator>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class IT>
reference element (IT first, IT last)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class IT>
const_reference element (IT first, IT last) const
 
template<class FCT = functor_type>
auto data_element (size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().data_element(i)))
 
template<class FCT = functor_type>
auto data_element (size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().data_element(i)))
 
template<class FCT = functor_type>
auto flat (size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().flat(i)))
 
template<class FCT = functor_type>
auto flat (size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().flat(i)))
 
template<class align, class requested_type = typename xexpression_type::value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size, class FCT = functor_type>
auto load_simd (size_type i) const -> decltype(std::declval< FCT >().template proxy_simd_load< align, requested_type, N >(std::declval< undecay_expression >(), i))
 
template<class align, class simd, class FCT = functor_type>
auto store_simd (size_type i, const simd &e) -> decltype(std::declval< FCT >() .template proxy_simd_store< align >(std::declval< undecay_expression >(), i, e))
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
+template<class S>
stepper stepper_begin (const S &shape) noexcept
 
+template<class S>
stepper stepper_end (const S &shape, layout_type l) noexcept
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+template<class... Args>
reference at (Args... args)
 
+template<class... Args>
const_reference at (Args... args) const
 
+template<class S>
disable_integral_t< S, reference > operator[] (const S &index)
 
+template<class I>
reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class I>
const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
reference back ()
 Returns a reference to the last element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+template<class... Args>
reference periodic (Args... args)
 
+template<class... Args>
const_reference periodic (Args... args) const
 
Constructors
 xfunctor_applier_base (undecay_expression) noexcept
 Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
 
template<class Func, class E>
 xfunctor_applier_base (Func &&, E &&) noexcept
 Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
 
Size and shape
size_type size () const noexcept
 Returns the size of the expression.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the expression.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the expression.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the expression.
 
layout_type layout () const noexcept
 Returns the layout_type of the expression.
 
bool is_contiguous () const noexcept
 
Data
xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
const xexpression_type & expression () const noexcept
 Returns a consttant reference to the underlying expression of the view.
 
template<class... Args>
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
template<class... Args>
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
template<class IT>
auto element (IT first, IT last) -> reference
 Returns a reference to the element at the specified position in the expression.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class IT>
auto element (IT first, IT last) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
Broadcasting
template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the function to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const
 Checks whether the xfunctor_applier_base can be linearly assigned to an expression with the specified strides.
 
Iterators
template<layout_type L = ::xt::layout_type::row_major>
auto begin () noexcept
 Returns an iterator to the first element of the expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto end () noexcept
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto begin () const noexcept
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto end () const noexcept
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto cbegin () const noexcept
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto cend () const noexcept
 Returns a constant iterator to the element following the last element of the expression.
 
Reverse iterators
template<layout_type L = ::xt::layout_type::row_major>
auto rbegin () noexcept
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto rend () noexcept
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto rbegin () const noexcept
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto rend () const noexcept
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto crbegin () const noexcept
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L = ::xt::layout_type::row_major>
auto crend () const noexcept
 Returns a constant iterator to the element following the last element of the reversed expression.
 
Reverse broadcast iterators
linear_iterator linear_begin () noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
template<class S, layout_type L>
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
template<class S, layout_type L>
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<class S, layout_type L>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<class S, layout_type L>
auto rend (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<class S, layout_type L>
auto crbegin (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<class S, layout_type L>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<class S>
auto stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
Broadcast iterators
template<class S, layout_type L>
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<class S, layout_type L>
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<class S, layout_type L>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<class S, layout_type L>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<class S, layout_type L>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<class S, layout_type L>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = xexpression_type::static_layout
 
static constexpr bool contiguous_layout = xexpression_type::contiguous_layout
 
+ + + + + +

+Protected Attributes

undecay_expression m_e
 
functor_type m_functor
 
+ + + + + +

+Friends

class xaccessible< D >
 
class xconst_accessible< D >
 
+

Detailed Description

+
template<class D>
+class xt::xfunctor_applier_base< D >
+

Definition at line 73 of file xfunctor_view.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::accessible_base = xaccessible<D>
+
+ +

Definition at line 82 of file xfunctor_view.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::backstrides_type
+
+Initial value:
xtl::mpl::eval_if_t<
+
has_strides<xexpression_type>,
+
detail::expr_backstrides_type<xexpression_type>,
+
get_strides_type<shape_type>>
+
xt::get_strides_type
Definition xutils.hpp:961
+
xt::has_strides
Definition xutils.hpp:576
+
+

Definition at line 100 of file xfunctor_view.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::bool_load_type = xt::bool_load_type<value_type>
+
+ +

Definition at line 115 of file xfunctor_view.hpp.

+ +
+
+ +

◆ broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::broadcast_iterator = xfunctor_iterator<functor_type, xiterator<typename xexpression_type::stepper, S, L>>
+
+ +

Definition at line 140 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::const_broadcast_iterator
+
+Initial value:
xfunctor_iterator<
+
functor_type,
+
xiterator<typename xexpression_type::const_stepper, S, L>>
+
xt::xfunctor_iterator
Definition xfunctor_view.hpp:580
+ +
+

Definition at line 142 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::const_iterator = xfunctor_iterator<const functor_type, typename xexpression_type::const_iterator>
+
+ +

Definition at line 163 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::const_layout_iterator
+
+Initial value:
xfunctor_iterator<
+
const functor_type,
+
typename xexpression_type::template const_layout_iterator<L>>
+
+

Definition at line 126 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::const_linear_iterator = xfunctor_iterator<const functor_type, typename xexpression_type::const_linear_iterator>
+
+ +

Definition at line 156 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::const_pointer = typename functor_type::const_pointer
+
+ +

Definition at line 91 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 89 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::const_reverse_broadcast_iterator
+
+Initial value:
xfunctor_iterator<
+
functor_type,
+
typename xexpression_type::template const_reverse_broadcast_iterator<S, L>>
+
+

Definition at line 151 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::const_reverse_iterator = xfunctor_iterator<const functor_type, typename xexpression_type::const_reverse_iterator>
+
+ +

Definition at line 165 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::const_reverse_layout_iterator
+
+Initial value:
xfunctor_iterator<
+
const functor_type,
+
typename xexpression_type::template const_reverse_layout_iterator<L>>
+
+

Definition at line 135 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::const_reverse_linear_iterator
+
+Initial value:
xfunctor_iterator<
+
const functor_type,
+
typename xexpression_type::const_reverse_linear_iterator>
+
+

Definition at line 158 of file xfunctor_view.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::const_stepper = xfunctor_stepper<const functor_type, typename xexpression_type::const_stepper>
+
+ +

Definition at line 121 of file xfunctor_view.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 93 of file xfunctor_view.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 85 of file xfunctor_view.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::extension_base = extension::xfunctor_view_base_t<functor_type, undecay_expression>
+
+ +

Definition at line 84 of file xfunctor_view.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::functor_type = typename inner_types::functor_type
+
+ +

Definition at line 81 of file xfunctor_view.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::inner_backstrides_type
+
+Initial value:
xtl::mpl::eval_if_t<
+
has_strides<xexpression_type>,
+
detail::expr_inner_backstrides_type<xexpression_type>,
+
get_strides_type<shape_type>>
+
+

Definition at line 110 of file xfunctor_view.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::inner_shape_type = typename xexpression_type::inner_shape_type
+
+ +

Definition at line 105 of file xfunctor_view.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::inner_strides_type
+
+Initial value:
xtl::mpl::eval_if_t<
+
has_strides<xexpression_type>,
+
detail::expr_inner_strides_type<xexpression_type>,
+
get_strides_type<shape_type>>
+
+

Definition at line 106 of file xfunctor_view.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::inner_types = xcontainer_inner_types<D>
+
+ +

Definition at line 78 of file xfunctor_view.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::iterator = xfunctor_iterator<functor_type, typename xexpression_type::iterator>
+
+ +

Definition at line 162 of file xfunctor_view.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::layout_iterator = xfunctor_iterator<functor_type, typename xexpression_type::template layout_iterator<L>>
+
+ +

Definition at line 124 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::linear_iterator = xfunctor_iterator<functor_type, typename xexpression_type::linear_iterator>
+
+ +

Definition at line 155 of file xfunctor_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::pointer = typename functor_type::pointer
+
+ +

Definition at line 90 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::reference = typename inner_types::reference
+
+ +

Definition at line 88 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::reverse_broadcast_iterator
+
+Initial value:
xfunctor_iterator<
+
functor_type,
+
typename xexpression_type::template reverse_broadcast_iterator<S, L>>
+
+

Definition at line 147 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::reverse_iterator = xfunctor_iterator<functor_type, typename xexpression_type::reverse_iterator>
+
+ +

Definition at line 164 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xfunctor_applier_base< D >::reverse_layout_iterator
+
+Initial value:
xfunctor_iterator<
+
functor_type,
+
typename xexpression_type::template reverse_layout_iterator<L>>
+
+

Definition at line 131 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::reverse_linear_iterator = xfunctor_iterator<functor_type, typename xexpression_type::reverse_linear_iterator>
+
+ +

Definition at line 157 of file xfunctor_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::self_type = xfunctor_applier_base<D>
+
+ +

Definition at line 77 of file xfunctor_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::shape_type = typename xexpression_type::shape_type
+
+ +

Definition at line 95 of file xfunctor_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::size_type = typename inner_types::size_type
+
+ +

Definition at line 92 of file xfunctor_view.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::stepper = xfunctor_stepper<functor_type, typename xexpression_type::stepper>
+
+ +

Definition at line 120 of file xfunctor_view.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::strides_type
+
+Initial value:
xtl::mpl::eval_if_t<
+
has_strides<xexpression_type>,
+
detail::expr_strides_type<xexpression_type>,
+
get_strides_type<shape_type>>
+
+

Definition at line 96 of file xfunctor_view.hpp.

+ +
+
+ +

◆ undecay_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::undecay_expression = typename inner_types::undecay_expression
+
+ +

Definition at line 80 of file xfunctor_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::value_type = typename functor_type::value_type
+
+ +

Definition at line 87 of file xfunctor_view.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xfunctor_applier_base< D >::xexpression_type = typename inner_types::xexpression_type
+
+ +

Definition at line 79 of file xfunctor_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfunctor_applier_base() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
xt::xfunctor_applier_base< D >::xfunctor_applier_base (undecay_expression e)
+ 		+inlineexplicitnoexcept
+
+ +

Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.

+
Parameters
+ + +
ethe underlying expression
+
+
+ +

Definition at line 679 of file xfunctor_view.hpp.

+ +
+
+ +

◆ xfunctor_applier_base() [2/2]

+ +
+
+
+template<class D>
+
+template<class Func, class E>
+ + + + + +
+ + + + + + + + + + + +
xt::xfunctor_applier_base< D >::xfunctor_applier_base (Func && func,
E && e )
+ 		+inlinenoexcept
+
+ +

Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.

+
Parameters
+ + + +
functhe functor to be applied to the elements of the underlying expression.
ethe underlying expression
+
+
+ +

Definition at line 693 of file xfunctor_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ back() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::back ()
+ 		+inline
+
+ +

Returns a reference to the last element of the expression.

+ +

Definition at line 109 of file xaccessible.hpp.

+ +
+
+ +

◆ back() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::back () const
+ 		+inline
+
+ +

Returns a constant reference to last the element of the expression.

+ +

Definition at line 113 of file xaccessible.hpp.

+ +
+
+ +

◆ backstrides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::backstrides () const
+ 		+inlinenoexcept
+
+ +

Returns the backstrides of the expression.

+ +

Definition at line 736 of file xfunctor_view.hpp.

+ +
+
+ +

◆ begin() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::begin () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 962 of file xfunctor_view.hpp.

+ +
+
+ +

◆ begin() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::begin ()
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 936 of file xfunctor_view.hpp.

+ +
+
+ +

◆ begin() [3/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::begin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1051 of file xfunctor_view.hpp.

+ +
+
+ +

◆ begin() [4/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::begin (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1023 of file xfunctor_view.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xfunctor_applier_base< D >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the function to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheboolean for reusing a previously computed shape
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 906 of file xfunctor_view.hpp.

+ +
+
+ +

◆ cbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::cbegin () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 985 of file xfunctor_view.hpp.

+ +
+
+ +

◆ cbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::cbegin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1080 of file xfunctor_view.hpp.

+ +
+
+ +

◆ cend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::cend () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1000 of file xfunctor_view.hpp.

+ +
+
+ +

◆ cend() [2/2]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::cend (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1095 of file xfunctor_view.hpp.

+ +
+
+ +

◆ crbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::crbegin () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1164 of file xfunctor_view.hpp.

+ +
+
+ +

◆ crbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::crbegin (const S & ) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1260 of file xfunctor_view.hpp.

+ +
+
+ +

◆ crend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::crend () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1179 of file xfunctor_view.hpp.

+ +
+
+ +

◆ crend() [2/2]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::crend (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1275 of file xfunctor_view.hpp.

+ +
+
+ +

◆ data_element() [1/2]

+ +
+
+
+template<class D>
+
+template<class FCT = functor_type>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::data_element (size_type i) -> decltype(std::declval<FCT>()(std::declval<undecay_expression>().data_element(i))) +
+ 		+inline
+
+ +

Definition at line 218 of file xfunctor_view.hpp.

+ +
+
+ +

◆ data_element() [2/2]

+ +
+
+
+template<class D>
+
+template<class FCT = functor_type>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::data_element (size_type i) const -> decltype(std::declval<FCT>()(std::declval<const undecay_expression>().data_element(i))) +
+ 		+inline
+
+ +

Definition at line 225 of file xfunctor_view.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class D>
+
+template<class IT>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunctor_applier_base< D >::element (IT first,
IT last ) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the expression.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the function.
+
+
+ +

Definition at line 812 of file xfunctor_view.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class D>
+
+template<class IT>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunctor_applier_base< D >::element (IT first,
IT last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the function.
+
+
+ +

Definition at line 868 of file xfunctor_view.hpp.

+ +
+
+ +

◆ end() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::end () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 974 of file xfunctor_view.hpp.

+ +
+
+ +

◆ end() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::end ()
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 951 of file xfunctor_view.hpp.

+ +
+
+ +

◆ end() [3/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::end (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1066 of file xfunctor_view.hpp.

+ +
+
+ +

◆ end() [4/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::end (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1037 of file xfunctor_view.hpp.

+ +
+
+ +

◆ expression() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::expression () const
+ 		+inlinenoexcept
+
+ +

Returns a consttant reference to the underlying expression of the view.

+ +

Definition at line 887 of file xfunctor_view.hpp.

+ +
+
+ +

◆ expression() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::expression ()
+ 		+inlinenoexcept
+
+ +

Returns a reference to the underlying expression of the view.

+ +

Definition at line 878 of file xfunctor_view.hpp.

+ +
+
+ +

◆ flat() [1/2]

+ +
+
+
+template<class D>
+
+template<class FCT = functor_type>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::flat (size_type i) -> decltype(std::declval<FCT>()(std::declval<undecay_expression>().flat(i))) +
+ 		+inline
+
+ +

Definition at line 232 of file xfunctor_view.hpp.

+ +
+
+ +

◆ flat() [2/2]

+ +
+
+
+template<class D>
+
+template<class FCT = functor_type>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::flat (size_type i) const -> decltype(std::declval<FCT>()(std::declval<const undecay_expression>().flat(i))) +
+ 		+inline
+
+ +

Definition at line 238 of file xfunctor_view.hpp.

+ +
+
+ +

◆ front() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::front ()
+ 		+inline
+
+ +

Returns a reference to the first element of the expression.

+ +

Definition at line 108 of file xaccessible.hpp.

+ +
+
+ +

◆ front() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::front () const
+ 		+inline
+
+ +

Returns a constant reference to first the element of the expression.

+ +

Definition at line 114 of file xaccessible.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xfunctor_applier_base< D >::has_linear_assign (const S & strides) const
+ 		+inline
+
+ +

Checks whether the xfunctor_applier_base can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 919 of file xfunctor_view.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
bool xt::xfunctor_applier_base< D >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 751 of file xfunctor_view.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
layout_type xt::xfunctor_applier_base< D >::layout () const
+ 		+inlinenoexcept
+
+ +

Returns the layout_type of the expression.

+ +

Definition at line 745 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_begin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1296 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_begin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1284 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1308 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1314 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1344 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1350 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_end() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1302 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_end() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1290 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_rbegin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1332 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_rbegin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_rbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1320 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_rend() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1338 of file xfunctor_view.hpp.

+ +
+
+ +

◆ linear_rend() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::linear_rend ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1326 of file xfunctor_view.hpp.

+ +
+
+ +

◆ load_simd()

+ +
+
+
+template<class D>
+
+template<class align, class requested_type = typename xexpression_type::value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size, class FCT = functor_type>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::load_simd (size_type i) const -> decltype(std::declval<FCT>().template proxy_simd_load<align, requested_type, N>( + std::declval<undecay_expression>(), + i + )) +
+ 		+inline
+
+ +

Definition at line 251 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::operator() (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the function. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the expression.
+
+
+ +

Definition at line 770 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the function. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the expression.
+
+
+ +

Definition at line 826 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xaccessible< D >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 103 of file xaccessible.hpp.

+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xconst_accessible< D >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 112 of file xaccessible.hpp.

+ +
+
+ +

◆ rbegin() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rbegin () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1141 of file xfunctor_view.hpp.

+ +
+
+ +

◆ rbegin() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rbegin ()
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1112 of file xfunctor_view.hpp.

+ +
+
+ +

◆ rbegin() [3/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rbegin (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1230 of file xfunctor_view.hpp.

+ +
+
+ +

◆ rbegin() [4/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rbegin (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1202 of file xfunctor_view.hpp.

+ +
+
+ +

◆ rend() [1/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rend () const
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1153 of file xfunctor_view.hpp.

+ +
+
+ +

◆ rend() [2/4]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rend ()
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1127 of file xfunctor_view.hpp.

+ +
+
+ +

◆ rend() [3/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rend (const S & ) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns a constant iterator to the element following the last element of the reversed expression.

+
Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1245 of file xfunctor_view.hpp.

+ +
+
+ +

◆ rend() [4/4]

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::rend (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 1216 of file xfunctor_view.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the expression.

+ +

Definition at line 718 of file xfunctor_view.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::size () const
+ 		+inlinenoexcept
+
+ +

Returns the size of the expression.

+ +

Definition at line 709 of file xfunctor_view.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 1375 of file xfunctor_view.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::stepper_begin (const S & shape) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 1361 of file xfunctor_view.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunctor_applier_base< D >::stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 1383 of file xfunctor_view.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunctor_applier_base< D >::stepper_end (const S & shape,
layout_type l ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 1368 of file xfunctor_view.hpp.

+ +
+
+ +

◆ store_simd()

+ +
+
+
+template<class D>
+
+template<class align, class simd, class FCT = functor_type>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xfunctor_applier_base< D >::store_simd (size_type i,
const simd & e ) -> decltype(std::declval<FCT>() + .template proxy_simd_store<align>(std::declval<undecay_expression>(), i, e)) +
+ 		+inline
+
+ +

Definition at line 261 of file xfunctor_view.hpp.

+ +
+
+ +

◆ strides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::strides () const
+ 		+inlinenoexcept
+
+ +

Returns the strides of the expression.

+ +

Definition at line 727 of file xfunctor_view.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::unchecked (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the expression, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.unchecked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 798 of file xfunctor_view.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_applier_base< D >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the expression, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
+ +

Definition at line 854 of file xfunctor_view.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xaccessible< D >
+ 		+friend
+
+ +

Definition at line 352 of file xfunctor_view.hpp.

+ +
+
+ +

◆ xconst_accessible< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xconst_accessible< D >
+ 		+friend
+
+ +

Definition at line 352 of file xfunctor_view.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
bool xt::xfunctor_applier_base< D >::contiguous_layout = xexpression_type::contiguous_layout
+ 		+staticconstexpr
+
+ +

Definition at line 118 of file xfunctor_view.hpp.

+ +
+
+ +

◆ m_e

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
undecay_expression xt::xfunctor_applier_base< D >::m_e
+ 		+protected
+
+ +

Definition at line 351 of file xfunctor_view.hpp.

+ +
+
+ +

◆ m_functor

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
functor_type xt::xfunctor_applier_base< D >::m_functor
+ 		+protected
+
+ +

Definition at line 352 of file xfunctor_view.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
layout_type xt::xfunctor_applier_base< D >::static_layout = xexpression_type::static_layout
+ 		+staticconstexpr
+
+ +

Definition at line 117 of file xfunctor_view.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xfunctor__applier__base.js b/classxt_1_1xfunctor__applier__base.js new file mode 100644 index 000000000..41e4e26d3 --- /dev/null +++ b/classxt_1_1xfunctor__applier__base.js @@ -0,0 +1,48 @@ +var classxt_1_1xfunctor__applier__base = +[ + [ "xfunctor_applier_base", "classxt_1_1xfunctor__applier__base.html#a41aab520408c7c729ae637b19d09be2b", null ], + [ "xfunctor_applier_base", "classxt_1_1xfunctor__applier__base.html#ac3b9ef5e95e61582edaff797f2ec7e1b", null ], + [ "back", "classxt_1_1xfunctor__applier__base.html#a905660a4d87f4d3e7b651bcf6bb690d0", null ], + [ "back", "classxt_1_1xfunctor__applier__base.html#ae8c11bf107fb871f054e2194163778fd", null ], + [ "backstrides", "classxt_1_1xfunctor__applier__base.html#a31682644280a7cb1f47f306e2fa832fe", null ], + [ "begin", "classxt_1_1xfunctor__applier__base.html#a20bbfc1e10a26d6754e31ecaca3791db", null ], + [ "begin", "classxt_1_1xfunctor__applier__base.html#acbbbfb5117f8a5cbbf6d884c99209aed", null ], + [ "begin", "classxt_1_1xfunctor__applier__base.html#a20fda1464f7c57d2bedac80130bc1b8a", null ], + [ "begin", "classxt_1_1xfunctor__applier__base.html#a3ab9bf54021db8cea2150113376a271c", null ], + [ "broadcast_shape", "classxt_1_1xfunctor__applier__base.html#ada44e2d571b044340c22c3c16137aa73", null ], + [ "cbegin", "classxt_1_1xfunctor__applier__base.html#a8ff3057fce404b976998dda117b669b4", null ], + [ "cbegin", "classxt_1_1xfunctor__applier__base.html#a358932daa1dd93cc97016f99f24b9be6", null ], + [ "cend", "classxt_1_1xfunctor__applier__base.html#a8f40de3c5e5d01ed40bab3060d1ad8e9", null ], + [ "cend", "classxt_1_1xfunctor__applier__base.html#a3eb421464069330b8305abdb39b43f24", null ], + [ "crbegin", "classxt_1_1xfunctor__applier__base.html#afb3b6d645d6ef28238b50f032f3477f6", null ], + [ "crbegin", "classxt_1_1xfunctor__applier__base.html#a69f77212c23e7a9e20b3774a2e59d3cc", null ], + [ "crend", "classxt_1_1xfunctor__applier__base.html#ae9c21d7315862c7b30de7f21d5d47bf3", null ], + [ "crend", "classxt_1_1xfunctor__applier__base.html#a9424de315b89fd06b19590443bc20629", null ], + [ "element", "classxt_1_1xfunctor__applier__base.html#a94f49676b373d866812ee9a128cdc3e8", null ], + [ "element", "classxt_1_1xfunctor__applier__base.html#a173b3e1e7c31df616b7e978462fece33", null ], + [ "end", "classxt_1_1xfunctor__applier__base.html#ab31ad55714884efed4c525ae1018339e", null ], + [ "end", "classxt_1_1xfunctor__applier__base.html#a1ede7d79cffaf8f76e8b6895a7877759", null ], + [ "end", "classxt_1_1xfunctor__applier__base.html#aba04a5d73546572558aa9bbb6e4eca36", null ], + [ "end", "classxt_1_1xfunctor__applier__base.html#a51190ea53109af3cdceebf66f8d10cbc", null ], + [ "expression", "classxt_1_1xfunctor__applier__base.html#a62a9deb497e7420aed40dcd2bcac02bc", null ], + [ "expression", "classxt_1_1xfunctor__applier__base.html#a5c676f9bf0dcbba9c63d589d2a417abd", null ], + [ "front", "classxt_1_1xfunctor__applier__base.html#ad36ac2c194e7e6f470548dad89e88ca2", null ], + [ "front", "classxt_1_1xfunctor__applier__base.html#a06f3bb2ce9e0c3081ef0ce0ae40d1fe8", null ], + [ "has_linear_assign", "classxt_1_1xfunctor__applier__base.html#a9ded44a42136f6472c91f0d60462d7a5", null ], + [ "layout", "classxt_1_1xfunctor__applier__base.html#a41a690f43f808ba326e0bd3e4ab19f95", null ], + [ "operator()", "classxt_1_1xfunctor__applier__base.html#a5b63f2bdd4620e52cc453fafd78831d3", null ], + [ "operator()", "classxt_1_1xfunctor__applier__base.html#a63939aecf0c7f315aab8119a2790aa69", null ], + [ "rbegin", "classxt_1_1xfunctor__applier__base.html#a683da35bece5497aead059605a406235", null ], + [ "rbegin", "classxt_1_1xfunctor__applier__base.html#abacad02a84f1b459e87948192e2c5d05", null ], + [ "rbegin", "classxt_1_1xfunctor__applier__base.html#a81666e7d863a7679298d37a373cd1395", null ], + [ "rbegin", "classxt_1_1xfunctor__applier__base.html#aff09d88c2dfc4cb00850f42c8f695337", null ], + [ "rend", "classxt_1_1xfunctor__applier__base.html#a20631d9fd8aaa1e5a95393c31537ef81", null ], + [ "rend", "classxt_1_1xfunctor__applier__base.html#a8201e2518627bdc8e1fb6f33653aacbb", null ], + [ "rend", "classxt_1_1xfunctor__applier__base.html#a367facbe0356cf7de42ed9cd1e60a163", null ], + [ "rend", "classxt_1_1xfunctor__applier__base.html#a23da38db60689cea813d3995b7b93de2", null ], + [ "shape", "classxt_1_1xfunctor__applier__base.html#a982e33a6deafe2b8f8048ce8c91956b3", null ], + [ "size", "classxt_1_1xfunctor__applier__base.html#ae971620a3e942d234f19e65a10005e45", null ], + [ "strides", "classxt_1_1xfunctor__applier__base.html#aee81935fb3b87f6e71e49e5410236645", null ], + [ "unchecked", "classxt_1_1xfunctor__applier__base.html#ad86eba7c460e85d7e6bd558091531376", null ], + [ "unchecked", "classxt_1_1xfunctor__applier__base.html#a5b9d6e6df937ed2b534d8a68c0d4ceff", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xfunctor__applier__base.png b/classxt_1_1xfunctor__applier__base.png new file mode 100644 index 000000000..f24f7d280 Binary files /dev/null and b/classxt_1_1xfunctor__applier__base.png differ diff --git a/classxt_1_1xfunctor__iterator-members.html b/classxt_1_1xfunctor__iterator-members.html new file mode 100644 index 000000000..8457b186f --- /dev/null +++ b/classxt_1_1xfunctor__iterator-members.html @@ -0,0 +1,139 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunctor_iterator< F, IT > Member List
+
+
+ +

This is the complete list of members for xt::xfunctor_iterator< F, IT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
equal(const xfunctor_iterator &rhs) const (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
functor_type typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
iterator_category typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
less_than(const xfunctor_iterator &rhs) const (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
operator*() const (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
operator++() (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >inline
operator+=(difference_type n) (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >inline
operator-(xfunctor_iterator rhs) const (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >inline
operator--() (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >inline
operator-=(difference_type n) (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >inline
operator->() const (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
pointer typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
proxy_inner typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
reference typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
self_type typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
subiterator_traits typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
value_type typedef (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
xfunctor_iterator(const IT &, functor_type *) (defined in xt::xfunctor_iterator< F, IT >)xt::xfunctor_iterator< F, IT >
+
+ + + + diff --git a/classxt_1_1xfunctor__iterator.html b/classxt_1_1xfunctor__iterator.html new file mode 100644 index 000000000..caf0fbf7b --- /dev/null +++ b/classxt_1_1xfunctor__iterator.html @@ -0,0 +1,599 @@ + + + + + + + +xtensor: xt::xfunctor_iterator< F, IT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xfunctor_iterator< F, IT > Class Template Reference
+
+
+
+Inheritance diagram for xt::xfunctor_iterator< F, IT >:
+
+
+ +
+ + + + + + + + + + + + + + + + + + + + +

+Public Types

using functor_type = F
 
using subiterator_traits = std::iterator_traits<IT>
 
using proxy_inner = xproxy_inner_types<detail::xfunctor_invoker_t<F, IT>>
 
using value_type = typename functor_type::value_type
 
using reference = typename proxy_inner::reference
 
using pointer = typename proxy_inner::pointer
 
using difference_type = typename subiterator_traits::difference_type
 
using iterator_category = typename subiterator_traits::iterator_category
 
using self_type = xfunctor_iterator<F, IT>
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Extended copy semantic
 xfunctor_iterator (const IT &, functor_type *)
 
self_type & operator++ ()
 
self_type & operator-- ()
 
self_type & operator+= (difference_type n)
 
self_type & operator-= (difference_type n)
 
difference_type operator- (xfunctor_iterator rhs) const
 
reference operator* () const
 
pointer operator-> () const
 
bool equal (const xfunctor_iterator &rhs) const
 
bool less_than (const xfunctor_iterator &rhs) const
 
+

Detailed Description

+
template<class F, class IT>
+class xt::xfunctor_iterator< F, IT >
+

Definition at line 574 of file xfunctor_view.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::difference_type = typename subiterator_traits::difference_type
+
+ +

Definition at line 590 of file xfunctor_view.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::functor_type = F
+
+ +

Definition at line 583 of file xfunctor_view.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::iterator_category = typename subiterator_traits::iterator_category
+
+ +

Definition at line 591 of file xfunctor_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::pointer = typename proxy_inner::pointer
+
+ +

Definition at line 589 of file xfunctor_view.hpp.

+ +
+
+ +

◆ proxy_inner

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::proxy_inner = xproxy_inner_types<detail::xfunctor_invoker_t<F, IT>>
+
+ +

Definition at line 586 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::reference = typename proxy_inner::reference
+
+ +

Definition at line 588 of file xfunctor_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::self_type = xfunctor_iterator<F, IT>
+
+ +

Definition at line 593 of file xfunctor_view.hpp.

+ +
+
+ +

◆ subiterator_traits

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::subiterator_traits = std::iterator_traits<IT>
+
+ +

Definition at line 584 of file xfunctor_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class IT>
+ + + + +
using xt::xfunctor_iterator< F, IT >::value_type = typename functor_type::value_type
+
+ +

Definition at line 587 of file xfunctor_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfunctor_iterator()

+ +
+
+
+template<class F, class IT>
+ + + + + + + + + + + +
xt::xfunctor_iterator< F, IT >::xfunctor_iterator (const IT & it,
functor_type * pf )
+
+ +

Definition at line 1508 of file xfunctor_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ equal()

+ +
+
+
+template<class F, class IT>
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::equal (const xfunctor_iterator< F, IT > & rhs) const
+
+ +

Definition at line 1561 of file xfunctor_view.hpp.

+ +
+
+ +

◆ less_than()

+ +
+
+
+template<class F, class IT>
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::less_than (const xfunctor_iterator< F, IT > & rhs) const
+
+ +

Definition at line 1567 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<class F, class IT>
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::operator* () const
+
+ +

Definition at line 1549 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator++()

+ +
+
+
+template<class F, class IT>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::operator++ ()
+ 		+inline
+
+ +

Definition at line 1515 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<class F, class IT>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::operator+= (difference_type n)
+ 		+inline
+
+ +

Definition at line 1529 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator-()

+ +
+
+
+template<class F, class IT>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::operator- (xfunctor_iterator< F, IT > rhs) const
+ 		+inline
+
+ +

Definition at line 1543 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator--()

+ +
+
+
+template<class F, class IT>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::operator-- ()
+ 		+inline
+
+ +

Definition at line 1522 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<class F, class IT>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::operator-= (difference_type n)
+ 		+inline
+
+ +

Definition at line 1536 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<class F, class IT>
+ + + + + + + +
auto xt::xfunctor_iterator< F, IT >::operator-> () const
+
+ +

Definition at line 1555 of file xfunctor_view.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xfunctor__iterator.png b/classxt_1_1xfunctor__iterator.png new file mode 100644 index 000000000..a518038f6 Binary files /dev/null and b/classxt_1_1xfunctor__iterator.png differ diff --git a/classxt_1_1xfunctor__stepper-members.html b/classxt_1_1xfunctor__stepper-members.html new file mode 100644 index 000000000..10009eee3 --- /dev/null +++ b/classxt_1_1xfunctor__stepper-members.html @@ -0,0 +1,139 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunctor_stepper< F, ST > Member List
+
+
+ +

This is the complete list of members for xt::xfunctor_stepper< F, ST >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
functor_type typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
operator*() const (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
pointer typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
proxy_inner typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
reference typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
reset(size_type dim) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
reset_back(size_type dim) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
shape_type typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
size_type typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
step(size_type dim) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
step(size_type dim, size_type n) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
step_back(size_type dim) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
step_back(size_type dim, size_type n) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
to_begin() (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
to_end(layout_type) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
value_type typedef (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
xfunctor_stepper()=default (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
xfunctor_stepper(const ST &, functor_type *) (defined in xt::xfunctor_stepper< F, ST >)xt::xfunctor_stepper< F, ST >
+
+ + + + diff --git a/classxt_1_1xfunctor__stepper.html b/classxt_1_1xfunctor__stepper.html new file mode 100644 index 000000000..7a05b5502 --- /dev/null +++ b/classxt_1_1xfunctor__stepper.html @@ -0,0 +1,541 @@ + + + + + + + +xtensor: xt::xfunctor_stepper< F, ST > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xfunctor_stepper< F, ST > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + +

+Public Types

using functor_type = F
 
using proxy_inner = xproxy_inner_types<detail::xfunctor_invoker_t<F, ST>>
 
using value_type = typename functor_type::value_type
 
using reference = typename proxy_inner::reference
 
using pointer = std::remove_reference_t<reference>*
 
using size_type = typename ST::size_type
 
using difference_type = typename ST::difference_type
 
using shape_type = typename ST::shape_type
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Extended copy semantic
 xfunctor_stepper (const ST &, functor_type *)
 
reference operator* () const
 
void step (size_type dim)
 
void step_back (size_type dim)
 
void step (size_type dim, size_type n)
 
void step_back (size_type dim, size_type n)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type)
 
+

Detailed Description

+
template<class F, class ST>
+class xt::xfunctor_stepper< F, ST >
+

Definition at line 628 of file xfunctor_view.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::difference_type = typename ST::difference_type
+
+ +

Definition at line 639 of file xfunctor_view.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::functor_type = F
+
+ +

Definition at line 632 of file xfunctor_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::pointer = std::remove_reference_t<reference>*
+
+ +

Definition at line 637 of file xfunctor_view.hpp.

+ +
+
+ +

◆ proxy_inner

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::proxy_inner = xproxy_inner_types<detail::xfunctor_invoker_t<F, ST>>
+
+ +

Definition at line 634 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::reference = typename proxy_inner::reference
+
+ +

Definition at line 636 of file xfunctor_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::shape_type = typename ST::shape_type
+
+ +

Definition at line 641 of file xfunctor_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::size_type = typename ST::size_type
+
+ +

Definition at line 638 of file xfunctor_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class ST>
+ + + + +
using xt::xfunctor_stepper< F, ST >::value_type = typename functor_type::value_type
+
+ +

Definition at line 635 of file xfunctor_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xfunctor_stepper()

+ +
+
+
+template<class F, class ST>
+ + + + + + + + + + + +
xt::xfunctor_stepper< F, ST >::xfunctor_stepper (const ST & stepper,
functor_type * pf )
+
+ +

Definition at line 1589 of file xfunctor_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class F, class ST>
+ + + + + + + +
auto xt::xfunctor_stepper< F, ST >::operator* () const
+
+ +

Definition at line 1596 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class F, class ST>
+ + + + + + + +
void xt::xfunctor_stepper< F, ST >::reset (size_type dim)
+
+ +

Definition at line 1626 of file xfunctor_view.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class F, class ST>
+ + + + + + + +
void xt::xfunctor_stepper< F, ST >::reset_back (size_type dim)
+
+ +

Definition at line 1632 of file xfunctor_view.hpp.

+ +
+
+ +

◆ step() [1/2]

+ +
+
+
+template<class F, class ST>
+ + + + + + + +
void xt::xfunctor_stepper< F, ST >::step (size_type dim)
+
+ +

Definition at line 1602 of file xfunctor_view.hpp.

+ +
+
+ +

◆ step() [2/2]

+ +
+
+
+template<class F, class ST>
+ + + + + + + + + + + +
void xt::xfunctor_stepper< F, ST >::step (size_type dim,
size_type n )
+
+ +

Definition at line 1614 of file xfunctor_view.hpp.

+ +
+
+ +

◆ step_back() [1/2]

+ +
+
+
+template<class F, class ST>
+ + + + + + + +
void xt::xfunctor_stepper< F, ST >::step_back (size_type dim)
+
+ +

Definition at line 1608 of file xfunctor_view.hpp.

+ +
+
+ +

◆ step_back() [2/2]

+ +
+
+
+template<class F, class ST>
+ + + + + + + + + + + +
void xt::xfunctor_stepper< F, ST >::step_back (size_type dim,
size_type n )
+
+ +

Definition at line 1620 of file xfunctor_view.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class F, class ST>
+ + + + + + + +
void xt::xfunctor_stepper< F, ST >::to_begin ()
+
+ +

Definition at line 1638 of file xfunctor_view.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class F, class ST>
+ + + + + + + +
void xt::xfunctor_stepper< F, ST >::to_end (layout_type l)
+
+ +

Definition at line 1644 of file xfunctor_view.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xfunctor__view-members.html b/classxt_1_1xfunctor__view-members.html new file mode 100644 index 000000000..a822954f2 --- /dev/null +++ b/classxt_1_1xfunctor__view-members.html @@ -0,0 +1,249 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xfunctor_view< F, CT > Member List
+
+
+ +

This is the complete list of members for xt::xfunctor_view< F, CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
assign_temporary(temporary_type &&)xt::xview_semantic< xfunctor_view< F, CT > >inline
back()xt::xfunctor_applier_base< xfunctor_view< F, CT > >
back() constxt::xfunctor_applier_base< xfunctor_view< F, CT > >
back()xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
back() constxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
backstrides() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
begin() noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
begin() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
build_functor_view(E &&e) const (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >
build_functor_view(E &&e) const -> rebind_t< E > (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
cbegin() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
cend() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
crbegin(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
crbegin() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
crbegin(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
crend() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
element(IT first, IT last) -> referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
element(IT first, IT last) const -> const_referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
element(IT first, IT last) -> referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
element(IT first, IT last) const -> const_referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
end() noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
end() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
expression() noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
expression() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
front()xt::xfunctor_applier_base< xfunctor_view< F, CT > >
front() constxt::xfunctor_applier_base< xfunctor_view< F, CT > >
front()xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
front() constxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
has_linear_assign(const S &strides) constxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
layout() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator()(Args... args) -> referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
operator()(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
operator()(Args... args) -> referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
operator()(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator=(const xexpression< E > &e) (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >
operator=(const E &e) (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >
operator=(const xexpression< E > &e) -> self_type &xt::xfunctor_view< F, CT >inline
operator=(const E &e) -> disable_xexpression< E, self_type > & (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xfunctor_view< F, CT > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xfunctor_view< F, CT > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rbegin() noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rbegin() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rebind_t typedef (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rend(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rend() noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rend() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
rend(const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
self_type typedef (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >
semantic_base typedef (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >
shape() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
size() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
strides() const noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
unchecked(Args... args) -> referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
unchecked(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
unchecked(Args... args) -> referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
unchecked(Args... args) const -> const_referencext::xfunctor_applier_base< xfunctor_view< F, CT > >inline
xaccessible< self_type > (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >friend
xfunctor_applier_base(undecay_expression) noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inlineexplicit
xfunctor_applier_base(Func &&, E &&) noexceptxt::xfunctor_applier_base< xfunctor_view< F, CT > >inline
xview_semantic< self_type > (defined in xt::xfunctor_view< F, CT >)xt::xfunctor_view< F, CT >friend
+
+ + + + diff --git a/classxt_1_1xfunctor__view.html b/classxt_1_1xfunctor__view.html new file mode 100644 index 000000000..b2db10053 --- /dev/null +++ b/classxt_1_1xfunctor__view.html @@ -0,0 +1,1197 @@ + + + + + + + +xtensor: xt::xfunctor_view< F, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
xt::xfunctor_view< F, CT > Class Template Reference
Functor view
+
+
+ +

View of an xexpression . + More...

+ +

#include <xfunctor_view.hpp>

+
+Inheritance diagram for xt::xfunctor_view< F, CT >:
+
+
+ + +xt::xfunctor_applier_base< xfunctor_view< F, CT > > +xt::xview_semantic< xfunctor_view< F, CT > > +xt::xaccessible< xfunctor_view< F, CT > > +xt::xsemantic_base< xfunctor_view< F, CT > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xfunctor_view<F, CT>
 
using semantic_base = xview_semantic<self_type>
 
template<class E>
using rebind_t = xfunctor_view<F, E>
 
- Public Types inherited from xt::xfunctor_applier_base< xfunctor_view< F, CT > >
using self_type
 
using inner_types
 
using xexpression_type
 
using undecay_expression
 
using functor_type
 
using accessible_base
 
using extension_base
 
using expression_tag
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using bool_load_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xview_semantic< xfunctor_view< F, CT > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xfunctor_view< F, CT > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
+template<class E>
rebind_t< E > build_functor_view (E &&e) const
 
- Public Member Functions inherited from xt::xfunctor_applier_base< xfunctor_view< F, CT > >
+reference at (Args... args)
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+const_reference operator[] (size_type i) const
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+reference periodic (Args... args)
 
+const_reference periodic (Args... args) const
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (IT first, IT last)
 
+const_reference element (IT first, IT last) const
 
auto data_element (size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().data_element(i)))
 
auto data_element (size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().data_element(i)))
 
auto flat (size_type i) -> decltype(std::declval< FCT >()(std::declval< undecay_expression >().flat(i)))
 
auto flat (size_type i) const -> decltype(std::declval< FCT >()(std::declval< const undecay_expression >().flat(i)))
 
auto load_simd (size_type i) const -> decltype(std::declval< FCT >().template proxy_simd_load< align, requested_type, N >(std::declval< undecay_expression >(), i))
 
auto store_simd (size_type i, const simd &e) -> decltype(std::declval< FCT >() .template proxy_simd_store< align >(std::declval< undecay_expression >(), i, e))
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+reference at (Args... args)
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
reference back ()
 Returns a reference to the last element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+reference periodic (Args... args)
 
+const_reference periodic (Args... args) const
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) -> reference
 Returns a reference to the element at the specified position in the expression.
 
auto element (IT first, IT last) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
const xexpression_type & expression () const noexcept
 Returns a consttant reference to the underlying expression of the view.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
 xfunctor_applier_base (undecay_expression) noexcept
 Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
 
 xfunctor_applier_base (Func &&, E &&) noexcept
 Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
 
size_type size () const noexcept
 Returns the size of the expression.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the expression.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the expression.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the expression.
 
layout_type layout () const noexcept
 Returns the layout_type of the expression.
 
bool is_contiguous () const noexcept
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the function to the specified parameter.
 
bool has_linear_assign (const S &strides) const
 Checks whether the xfunctor_applier_base can be linearly assigned to an expression with the specified strides.
 
auto begin () noexcept
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xview_semantic< xfunctor_view< F, CT > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xfunctor_view< F, CT > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + +

+Friends

class xview_semantic< self_type >
 
class xaccessible< self_type >
 
+ + + + + + + + + + + +

Extended copy semantic

template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type > &
 
template<class E>
auto build_functor_view (E &&e) const -> rebind_t< E >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Attributes inherited from xt::xfunctor_applier_base< xfunctor_view< F, CT > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Protected Member Functions inherited from xt::xview_semantic< xfunctor_view< F, CT > >
+ xview_semantic (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xfunctor_view< F, CT > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Attributes inherited from xt::xfunctor_applier_base< xfunctor_view< F, CT > >
undecay_expression m_e
 
functor_type m_functor
 
+

Detailed Description

+
template<class F, class CT>
+class xt::xfunctor_view< F, CT >

View of an xexpression .

+

The xt::xfunctor_view class is an expression addressing its elements by applying a functor to the corresponding element of an underlying expression. Unlike e.g. xgenerator, an xt::xfunctor_view is an lvalue. It is used e.g. to access real and imaginary parts of complex expressions.

+

xt::xfunctor_view has a view semantics and can be used on any expression. For a similar feature with a container semantics, one can use xt::xfunctor_adaptor.

+

xt::xfunctor_view is not meant to be used directly, but through helper functions such as xt::real or xt::imag.

+
Template Parameters
+ + + +
Fthe functor type to be applied to the elements of specified expression.
CTthe closure type of the xt::xexpression type underlying this view
+
+
+
See also
xt::real, xt::imag
+ +

Definition at line 440 of file xfunctor_view.hpp.

+

Member Typedef Documentation

+ +

◆ rebind_t

+ +
+
+
+template<class F, class CT>
+
+template<class E>
+ + + + +
using xt::xfunctor_view< F, CT >::rebind_t = xfunctor_view<F, E>
+
+ +

Definition at line 459 of file xfunctor_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_view< F, CT >::self_type = xfunctor_view<F, CT>
+
+ +

Definition at line 446 of file xfunctor_view.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class F, class CT>
+ + + + +
using xt::xfunctor_view< F, CT >::semantic_base = xview_semantic<self_type>
+
+ +

Definition at line 447 of file xfunctor_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ build_functor_view()

+ +
+
+
+template<class F, class CT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_view< F, CT >::build_functor_view (E && e) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 1436 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class F, class CT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_view< F, CT >::operator= (const E & e) -> disable_xexpression<E, self_type>& +
+ 		+inline
+
+ +

Definition at line 1422 of file xfunctor_view.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class F, class CT>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xfunctor_view< F, CT >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 1403 of file xfunctor_view.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< self_type >

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + +
friend class xaccessible< self_type >
+ 		+friend
+
+ +

Definition at line 467 of file xfunctor_view.hpp.

+ +
+
+ +

◆ xview_semantic< self_type >

+ +
+
+
+template<class F, class CT>
+ + + + + +
+ + + + +
friend class xview_semantic< self_type >
+ 		+friend
+
+ +

Definition at line 467 of file xfunctor_view.hpp.

+ +
+
+
The documentation for this class was generated from the following files:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xmime.hpp
    • +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xfunctor_view.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xfunctor__view.js b/classxt_1_1xfunctor__view.js new file mode 100644 index 000000000..666d4a24b --- /dev/null +++ b/classxt_1_1xfunctor__view.js @@ -0,0 +1,4 @@ +var classxt_1_1xfunctor__view = +[ + [ "operator=", "classxt_1_1xfunctor__view.html#a9e41f726bcd647106ca9f420a045d228", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xfunctor__view.png b/classxt_1_1xfunctor__view.png new file mode 100644 index 000000000..32fcb42c8 Binary files /dev/null and b/classxt_1_1xfunctor__view.png differ diff --git a/classxt_1_1xgenerator-members.html b/classxt_1_1xgenerator-members.html new file mode 100644 index 000000000..8a15a2739 --- /dev/null +++ b/classxt_1_1xgenerator-members.html @@ -0,0 +1,213 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xgenerator< F, R, S > Member List
+
+
+ +

This is the complete list of members for xt::xgenerator< F, R, S >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
assign_to(xexpression< E > &e) const noexcept (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
at(Args... args) const -> const_referencext::xconst_accessible< xgenerator< F, R, S > >inline
at(Args... args) const -> const_referencext::xconst_accessible< xgenerator< F, R, S > >inline
back() constxt::xconst_accessible< xgenerator< F, R, S > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
bool_load_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
broadcast_shape(O &shape, bool reuse_cache=false) constxt::xgenerator< F, R, S >inline
build_generator(OF &&func) const (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
build_generator(OF &&func) const -> rebind_t< OR, OF > (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
const_pointer typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
const_reference typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
const_stepper typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
contiguous_layout (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >static
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
xt::derived_cast() &noexceptxt::xexpression< xgenerator< F, R, S > >inline
xt::derived_cast() const &noexceptxt::xexpression< xgenerator< F, R, S > >inline
xt::derived_cast() &&noexceptxt::xexpression< xgenerator< F, R, S > >inline
difference_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
dimension() const noexceptxt::xconst_accessible< xgenerator< F, R, S > >inline
element(It first, It last) const (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
element(It first, It last) const -> const_referencext::xgenerator< F, R, S >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
expression_tag typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
extension_base typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
front() constxt::xconst_accessible< xgenerator< F, R, S > >inline
functor() const noexcept (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
functor_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
has_linear_assign(const O &) const noexceptxt::xgenerator< F, R, S >inline
in_bounds(Args... args) constxt::xconst_accessible< xgenerator< F, R, S > >inline
inner_shape_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
inner_types typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
is_contiguous() const noexcept (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
iterable_base typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
layout() const noexcept (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
operator()(Args... args) const (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
operator()(Args... args) const -> const_referencext::xgenerator< F, R, S >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xconst_accessible< xgenerator< F, R, S > >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xconst_accessible< xgenerator< F, R, S > >inline
periodic(Args... args) const -> const_referencext::xconst_accessible< xgenerator< F, R, S > >inline
periodic(Args... args) const -> const_referencext::xconst_accessible< xgenerator< F, R, S > >inline
pointer typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
rebind_t typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
reference typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xgenerator< F, R, S > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xgenerator< F, R, S > >inline
reshape(O &&shape) const &xt::xgenerator< F, R, S >inline
reshape(O &&shape) && (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
reshape(std::initializer_list< T > shape) const & (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
reshape(std::initializer_list< T > shape) && (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
self_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
shape() const noexceptxt::xgenerator< F, R, S >inline
shape(size_type index) constxt::xgenerator< F, R, S >
shape_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
size() const noexcept(noexcept(derived_cast().shape()))xt::xconst_accessible< xgenerator< F, R, S > >inline
size_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
static_layout (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >static
stepper typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
stepper_begin(const O &shape) const noexcept (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
stepper_begin(const O &shape) const noexcept -> const_stepper (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
stepper_end(const O &shape, layout_type) const noexcept (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
stepper_end(const O &shape, layout_type) const noexcept -> const_stepper (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >inline
unchecked(Args... args) const (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
unchecked(Args... args) const -> const_referencext::xgenerator< F, R, S >inline
value_type typedef (defined in xt::xgenerator< F, R, S >)xt::xgenerator< F, R, S >
xgenerator(Func &&f, const S &shape) noexceptxt::xgenerator< F, R, S >inline
+
+ + + + diff --git a/classxt_1_1xgenerator.html b/classxt_1_1xgenerator.html new file mode 100644 index 000000000..159aea290 --- /dev/null +++ b/classxt_1_1xgenerator.html @@ -0,0 +1,1699 @@ + + + + + + + +xtensor: xt::xgenerator< F, R, S > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::xgenerator< F, R, S > Class Template Reference
+
+
+ +

Multidimensional function operating on indices. + More...

+ +

#include <xgenerator.hpp>

+
+Inheritance diagram for xt::xgenerator< F, R, S >:
+
+
+ + +xt::xsharable_expression< xgenerator< F, R, S > > +xt::xconst_iterable< xgenerator< F, R, S > > +xt::xconst_accessible< xgenerator< F, R, S > > +xt::xexpression< xgenerator< F, R, S > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xgenerator<F, R, S>
 
using functor_type = typename std::remove_reference<F>::type
 
using accessible_base = xconst_accessible<self_type>
 
using extension_base = extension::xgenerator_base_t<F, R, S>
 
using expression_tag = typename extension_base::expression_tag
 
using inner_types = xcontainer_inner_types<self_type>
 
using value_type = R
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = value_type*
 
using const_pointer = const value_type*
 
using size_type = typename inner_types::size_type
 
using difference_type = std::ptrdiff_t
 
using iterable_base = xconst_iterable<self_type>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using shape_type = inner_shape_type
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using bool_load_type = xt::bool_load_type<R>
 
template<class OR, class OF>
using rebind_t = xgenerator<OF, OR, S>
 
- Public Types inherited from xt::xexpression< xgenerator< F, R, S > >
using derived_type
 
- Public Types inherited from xt::xconst_iterable< xgenerator< F, R, S > >
using derived_type
 
using iterable_types
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xconst_accessible< xgenerator< F, R, S > >
using derived_type
 
using inner_types
 
using reference
 
using const_reference
 
using size_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class O>
const_stepper stepper_begin (const O &shape) const noexcept
 
+template<class O>
const_stepper stepper_end (const O &shape, layout_type) const noexcept
 
+template<class OR, class OF>
rebind_t< OR, OF > build_generator (OF &&func) const
 
+size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
Constructor
template<class Func>
 xgenerator (Func &&f, const S &shape) noexcept
 Constructs an xgenerator applying the specified function over the given shape.
 
Size and shape
const inner_shape_type & shape () const noexcept
 Returns the shape of the xgenerator.
 
layout_type layout () const noexcept
 
bool is_contiguous () const noexcept
 
Data
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns the evaluated element at the specified position in the function.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the function.
 
- Public Member Functions inherited from xt::xexpression< xgenerator< F, R, S > >
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
- Public Member Functions inherited from xt::xconst_iterable< xgenerator< F, R, S > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_layout_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_layout_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xconst_accessible< xgenerator< F, R, S > >
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+const_reference at (Args... args) const
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
+const_reference periodic (Args... args) const
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = layout_type::dynamic
 
static constexpr bool contiguous_layout = false
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class O>
bool broadcast_shape (O &shape, bool reuse_cache=false) const
 Broadcast the shape of the function to the specified parameter.
 
template<class O>
bool has_linear_assign (const O &) const noexcept
 Checks whether the xgenerator can be linearly assigned to an expression with the specified strides.
 
template<class E, class FE = F>
+requires (has_assign_to_v<E, FE>)
void assign_to (xexpression< E > &e) const noexcept
 
const functor_type & functor () const noexcept
 
template<class O = xt::dynamic_shape<typename shape_type::value_type>>
auto reshape (O &&shape) const &
 Reshapes the generator and keeps old elements.
 
template<class O = xt::dynamic_shape<typename shape_type::value_type>>
auto reshape (O &&shape) &&
 
template<class T>
auto reshape (std::initializer_list< T > shape) const &
 
template<class T>
auto reshape (std::initializer_list< T > shape) &&
 
template<class O>
auto stepper_begin (const O &shape) const noexcept -> const_stepper
 
template<class O>
auto stepper_end (const O &shape, layout_type) const noexcept -> const_stepper
 
template<class OR, class OF>
auto build_generator (OF &&func) const -> rebind_t< OR, OF >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xsharable_expression< xgenerator< F, R, S > >
+ xsharable_expression (const xsharable_expression &)=default
 
+ xsharable_expression (xsharable_expression &&)=default
 
+xsharable_expression & operator= (const xsharable_expression &)=default
 
+xsharable_expression & operator= (xsharable_expression &&)=default
 
- Protected Member Functions inherited from xt::xexpression< xgenerator< F, R, S > >
+ xexpression (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (const xexpression &)=default
 
+xexpression & operator= (xexpression &&)=default
 
const inner_shape_type & get_shape () const
 
- Protected Member Functions inherited from xt::xconst_accessible< xgenerator< F, R, S > >
+ xconst_accessible (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
+

Detailed Description

+
template<class F, class R, class S>
+class xt::xgenerator< F, R, S >

Multidimensional function operating on indices.

+

The xgenerator class implements a multidimensional function, generating a value from the supplied indices.

+
Template Parameters
+ + + + +
Fthe function type
Rthe return type of the function
Sthe shape type of the generator
+
+
+ +

Definition at line 106 of file xgenerator.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::accessible_base = xconst_accessible<self_type>
+
+ +

Definition at line 116 of file xgenerator.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::bool_load_type = xt::bool_load_type<R>
+
+ +

Definition at line 136 of file xgenerator.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::const_pointer = const value_type*
+
+ +

Definition at line 125 of file xgenerator.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 123 of file xgenerator.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 134 of file xgenerator.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::difference_type = std::ptrdiff_t
+
+ +

Definition at line 127 of file xgenerator.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 118 of file xgenerator.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::extension_base = extension::xgenerator_base_t<F, R, S>
+
+ +

Definition at line 117 of file xgenerator.hpp.

+ +
+
+ +

◆ functor_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::functor_type = typename std::remove_reference<F>::type
+
+ +

Definition at line 114 of file xgenerator.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 130 of file xgenerator.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 120 of file xgenerator.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::iterable_base = xconst_iterable<self_type>
+
+ +

Definition at line 129 of file xgenerator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::pointer = value_type*
+
+ +

Definition at line 124 of file xgenerator.hpp.

+ +
+
+ +

◆ rebind_t

+ +
+
+
+template<class F, class R, class S>
+
+template<class OR, class OF>
+ + + + +
using xt::xgenerator< F, R, S >::rebind_t = xgenerator<OF, OR, S>
+
+ +

Definition at line 175 of file xgenerator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::reference = typename inner_types::reference
+
+ +

Definition at line 122 of file xgenerator.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::self_type = xgenerator<F, R, S>
+
+ +

Definition at line 113 of file xgenerator.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::shape_type = inner_shape_type
+
+ +

Definition at line 131 of file xgenerator.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::size_type = typename inner_types::size_type
+
+ +

Definition at line 126 of file xgenerator.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 133 of file xgenerator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class R, class S>
+ + + + +
using xt::xgenerator< F, R, S >::value_type = R
+
+ +

Definition at line 121 of file xgenerator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xgenerator()

+ +
+
+
+template<class F, class R, class S>
+
+template<class Func>
+ + + + + +
+ + + + + + + + + + + +
xt::xgenerator< F, R, S >::xgenerator (Func && f,
const S & shape )
+ 		+inlinenoexcept
+
+ +

Constructs an xgenerator applying the specified function over the given shape.

+
Parameters
+ + + +
fthe function to apply
shapethe shape of the xgenerator
+
+
+ +

Definition at line 229 of file xgenerator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign_to()

+ +
+
+
+template<class F, class R, class S>
+requires (has_assign_to_v<E, FE>)
+
+template<class E, class FE>
+requires (has_assign_to_v<E, FE>)
+ + + + + +
+ + + + + + + +
void xt::xgenerator< F, R, S >::assign_to (xexpression< E > & e) const
+ 		+inlinenoexcept
+
+ +

Definition at line 376 of file xgenerator.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class F, class R, class S>
+
+template<class O>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xgenerator< F, R, S >::broadcast_shape (O & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the function to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 339 of file xgenerator.hpp.

+ +
+
+ +

◆ build_generator()

+ +
+
+
+template<class F, class R, class S>
+
+template<class OR, class OF>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::build_generator (OF && func) const -> rebind_t<OR, OF> +
+ 		+inline
+
+ +

Definition at line 391 of file xgenerator.hpp.

+ +
+
+ +

◆ element()

+ +
+
+
+template<class F, class R, class S>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xgenerator< F, R, S >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the function.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 318 of file xgenerator.hpp.

+ +
+
+ +

◆ functor()

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::functor () const
+ 		+inlinenoexcept
+
+ +

Definition at line 384 of file xgenerator.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class F, class R, class S>
+
+template<class O>
+ + + + + +
+ + + + + + + +
bool xt::xgenerator< F, R, S >::has_linear_assign (const O & ) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xgenerator can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 351 of file xgenerator.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + + + + +
bool xt::xgenerator< F, R, S >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 257 of file xgenerator.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + + + + +
layout_type xt::xgenerator< F, R, S >::layout () const
+ 		+inlinenoexcept
+
+ +

Definition at line 251 of file xgenerator.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class F, class R, class S>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns the evaluated element at the specified position in the function.

+
Parameters
+ + +
argsa list of indices specifying the position in the function. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the function.
+
+
+ +

Definition at line 276 of file xgenerator.hpp.

+ +
+
+ +

◆ reshape() [1/4]

+ +
+
+
+template<class F, class R, class S>
+
+template<class O>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::reshape (O && shape) &&
+ 		+inline
+
+ +

Definition at line 415 of file xgenerator.hpp.

+ +
+
+ +

◆ reshape() [2/4]

+ +
+
+
+template<class F, class R, class S>
+
+template<class O>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::reshape (O && shape) const &
+ 		+inline
+
+ +

Reshapes the generator and keeps old elements.

+

The shape argument can have one of its value equal to -1, in this case the value is inferred from the number of elements in the generator and the remaining values in the shape.

auto a = xt::arange<double>(50).reshape({-1, 10});
+
//a.shape() is {5, 10}
+
xt::arange
auto arange(T start, T stop, S step=1) noexcept
Generates numbers evenly spaced within given half-open interval [start, stop).
Definition xbuilder.hpp:432
+
Parameters
+ + +
shapethe new shape (has to have same number of elements as the original generator)
+
+
+ +

Definition at line 408 of file xgenerator.hpp.

+ +
+
+ +

◆ reshape() [3/4]

+ +
+
+
+template<class F, class R, class S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::reshape (std::initializer_list< T > shape) &&
+ 		+inline
+
+ +

Definition at line 432 of file xgenerator.hpp.

+ +
+
+ +

◆ reshape() [4/4]

+ +
+
+
+template<class F, class R, class S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::reshape (std::initializer_list< T > shape) const &
+ 		+inline
+
+ +

Definition at line 425 of file xgenerator.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the xgenerator.

+ +

Definition at line 245 of file xgenerator.hpp.

+ +
+
+ +

◆ stepper_begin()

+ +
+
+
+template<class F, class R, class S>
+
+template<class O>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::stepper_begin (const O & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 360 of file xgenerator.hpp.

+ +
+
+ +

◆ stepper_end()

+ +
+
+
+template<class F, class R, class S>
+
+template<class O>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xgenerator< F, R, S >::stepper_end (const O & shape,
layout_type  ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 368 of file xgenerator.hpp.

+ +
+
+ +

◆ unchecked()

+ +
+
+
+template<class F, class R, class S>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xgenerator< F, R, S >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the expression, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 304 of file xgenerator.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + +
bool xt::xgenerator< F, R, S >::contiguous_layout = false
+ 		+staticconstexpr
+
+ +

Definition at line 139 of file xgenerator.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class F, class R, class S>
+ + + + + +
+ + + + +
layout_type xt::xgenerator< F, R, S >::static_layout = layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 138 of file xgenerator.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/generators/xgenerator.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xgenerator.js b/classxt_1_1xgenerator.js new file mode 100644 index 000000000..f8b0cf804 --- /dev/null +++ b/classxt_1_1xgenerator.js @@ -0,0 +1,12 @@ +var classxt_1_1xgenerator = +[ + [ "xgenerator", "classxt_1_1xgenerator.html#a6f07eda985bc0f0e510a44afa3b8899d", null ], + [ "broadcast_shape", "classxt_1_1xgenerator.html#ae6b7796ce3f5e9aa5333e6c066013b24", null ], + [ "element", "classxt_1_1xgenerator.html#a78b35b4322ef73b541653bc0e009c058", null ], + [ "has_linear_assign", "classxt_1_1xgenerator.html#ab1a2913449b319eede92915d0b410c0d", null ], + [ "operator()", "classxt_1_1xgenerator.html#a5d2e22a7df365f2d238aef28715a46f8", null ], + [ "reshape", "classxt_1_1xgenerator.html#a8d78d70b368a9010ded32ee263299b8b", null ], + [ "shape", "classxt_1_1xgenerator.html#a72035cb01c8e3ead3dedcd013fe59737", null ], + [ "shape", "classxt_1_1xgenerator.html#ae7b5c2b34c43d49a8f2f82bd80ef30eb", null ], + [ "unchecked", "classxt_1_1xgenerator.html#af95208893a8690ab495c3ac4f570d590", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xgenerator.png b/classxt_1_1xgenerator.png new file mode 100644 index 000000000..781e6993d Binary files /dev/null and b/classxt_1_1xgenerator.png differ diff --git a/classxt_1_1xindex__view-members.html b/classxt_1_1xindex__view-members.html new file mode 100644 index 000000000..a4ff9b417 --- /dev/null +++ b/classxt_1_1xindex__view-members.html @@ -0,0 +1,276 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xindex_view< CT, I > Member List
+
+
+ +

This is the complete list of members for xt::xindex_view< CT, I >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
assign_temporary(temporary_type &&)xt::xview_semantic< xindex_view< CT, I > >inline
base_index_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
begin() noexcept -> layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
begin() noexcept -> layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
bool_load_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
broadcast_shape(O &shape, bool reuse_cache=false) constxt::xindex_view< CT, I >inline
build_index_view(E &&e) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
build_index_view(E &&e) const -> rebind_t< E > (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
const_pointer typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
const_reference typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
const_stepper typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
contiguous_layout (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >static
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xindex_view< CT, I > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xindex_view< CT, I > >inline
difference_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
dimension() const noexceptxt::xindex_view< CT, I >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
element(It first, It last) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
element(It first, It last) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
element(It first, It) -> referencext::xindex_view< CT, I >inline
element(It first, It) const -> const_referencext::xindex_view< CT, I >inline
end() noexcept -> layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
end() noexcept -> layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
expression() noexceptxt::xindex_view< CT, I >inline
expression() const noexceptxt::xindex_view< CT, I >inline
expression_tag typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
extension_base typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
fill(const T &value)xt::xindex_view< CT, I >inline
has_linear_assign(const O &) const noexceptxt::xindex_view< CT, I >inline
indices_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
inner_shape_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
is_contiguous() const noexcept (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
iterable_base typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
layout() const noexcept (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator()(size_type idx=size_type(0))xt::xindex_view< CT, I >inline
operator()(size_type idx0, size_type idx1, Args... args) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator()(size_type idx=size_type(0)) constxt::xindex_view< CT, I >inline
operator()(size_type idx0, size_type idx1, Args... args) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator()(size_type, size_type idx1, Args... args) -> reference (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
operator()(size_type, size_type idx1, Args... args) const -> const_reference (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator=(const xexpression< E > &e) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator=(const E &e) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator=(const xexpression< E > &e) -> self_type &xt::xindex_view< CT, I >inline
operator=(const E &e) -> disable_xexpression< E, self_type > & (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
operator[](const S &index) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator[](std::initializer_list< OI > index) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator[](size_type i) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
operator[](const S &index) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator[](std::initializer_list< OI > index) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
operator[](size_type i) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xindex_view< CT, I >inline
operator[](std::initializer_list< OI > index) -> reference (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xindex_view< CT, I >inline
operator[](std::initializer_list< OI > index) const -> const_reference (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xindex_view< CT, I > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xindex_view< CT, I > >inline
pointer typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
rbegin() noexcept -> reverse_layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
rbegin() noexcept -> reverse_layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
rebind_t typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
reference typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
rend() noexcept -> reverse_layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
rend() noexcept -> reverse_layout_iterator< L >xt::xiterable< xindex_view< CT, I > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< xindex_view< CT, I > >inline
self_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
semantic_base typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
shape() const noexceptxt::xindex_view< CT, I >inline
shape(size_type index) constxt::xindex_view< CT, I >inline
shape_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
size() const noexceptxt::xindex_view< CT, I >inline
size_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
static_layout (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >static
stepper typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
stepper_begin(const ST &shape) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
stepper_begin(const ST &shape) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
stepper_begin(const ST &shape) -> stepper (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
stepper_begin(const ST &shape) const -> const_stepper (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
stepper_end(const ST &shape, layout_type) (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
stepper_end(const ST &shape, layout_type) const (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
stepper_end(const ST &shape, layout_type) -> stepper (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
stepper_end(const ST &shape, layout_type) const -> const_stepper (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >inline
temporary_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
unchecked(size_type idx)xt::xindex_view< CT, I >inline
unchecked(size_type idx) constxt::xindex_view< CT, I >inline
value_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
xexpression_type typedef (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >
xindex_view(CTA &&e, I2 &&indices) noexceptxt::xindex_view< CT, I >inline
xview_semantic< xindex_view< CT, I > > (defined in xt::xindex_view< CT, I >)xt::xindex_view< CT, I >friend
+
+ + + + diff --git a/classxt_1_1xindex__view.html b/classxt_1_1xindex__view.html new file mode 100644 index 000000000..696baf565 --- /dev/null +++ b/classxt_1_1xindex__view.html @@ -0,0 +1,2750 @@ + + + + + + + +xtensor: xt::xindex_view< CT, I > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xindex_view< CT, I > Class Template Reference
+
+
+ +

View of an xexpression from vector of indices. + More...

+ +

#include <xindex_view.hpp>

+
+Inheritance diagram for xt::xindex_view< CT, I >:
+
+
+ + +xt::xview_semantic< xindex_view< CT, I > > +xt::xiterable< xindex_view< CT, I > > +xt::xsemantic_base< xindex_view< CT, I > > +xt::xconst_iterable< xindex_view< CT, I > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xindex_view<CT, I>
 
using xexpression_type = std::decay_t<CT>
 
using semantic_base = xview_semantic<self_type>
 
using extension_base = extension::xindex_view_base_t<CT, I>
 
using expression_tag = typename extension_base::expression_tag
 
using value_type = typename xexpression_type::value_type
 
using reference = inner_reference_t<CT>
 
using const_reference = typename xexpression_type::const_reference
 
using pointer = typename xexpression_type::pointer
 
using const_pointer = typename xexpression_type::const_pointer
 
using size_type = typename xexpression_type::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using iterable_base = xiterable<self_type>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using shape_type = inner_shape_type
 
using indices_type = I
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
 
using base_index_type = xindex_type_t<shape_type>
 
using bool_load_type = typename xexpression_type::bool_load_type
 
template<class E>
using rebind_t = xindex_view<E, I>
 
- Public Types inherited from xt::xview_semantic< xindex_view< CT, I > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xindex_view< CT, I > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xiterable< xindex_view< CT, I > >
using derived_type
 
using base_type
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using linear_iterator
 
using reverse_linear_iterator
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xconst_iterable< xindex_view< CT, I > >
using derived_type
 
using iterable_types
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
+template<class... Args>
reference operator() (size_type idx0, size_type idx1, Args... args)
 
+template<class S>
disable_integral_t< S, reference > operator[] (const S &index)
 
+template<class OI>
reference operator[] (std::initializer_list< OI > index)
 
+template<class It>
reference element (It first, It last)
 
+template<class... Args>
const_reference operator() (size_type idx0, size_type idx1, Args... args) const
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class OI>
const_reference operator[] (std::initializer_list< OI > index) const
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class ST>
stepper stepper_begin (const ST &shape)
 
+template<class ST>
stepper stepper_end (const ST &shape, layout_type)
 
+template<class ST>
const_stepper stepper_begin (const ST &shape) const
 
+template<class ST>
const_stepper stepper_end (const ST &shape, layout_type) const
 
+template<class E>
rebind_t< E > build_index_view (E &&e) const
 
Constructor
template<class CTA, class I2>
 xindex_view (CTA &&e, I2 &&indices) noexcept
 Constructs an xindex_view, selecting the indices specified by indices.
 
Size and shape
size_type size () const noexcept
 Returns the size of the xindex_view.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the xindex_view.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the xindex_view.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
layout_type layout () const noexcept
 
bool is_contiguous () const noexcept
 
Data
template<class T>
void fill (const T &value)
 Fills the view with the given value.
 
reference operator() (size_type idx=size_type(0))
 Returns a reference to the element at the specified position in the xindex_view.
 
reference unchecked (size_type idx)
 Returns a reference to the element at the specified position in the xindex_view.
 
reference operator[] (size_type i)
 
const_reference operator() (size_type idx=size_type(0)) const
 Returns a constant reference to the element at the specified position in the xindex_view.
 
const_reference unchecked (size_type idx) const
 Returns a constant reference to the element at the specified position in the xindex_view.
 
const_reference operator[] (size_type i) const
 
xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
const xexpression_type & expression () const noexcept
 Returns a constant reference to the underlying expression of the view.
 
template<class... Args>
auto operator() (size_type, size_type idx1, Args... args) -> reference
 
template<class... Args>
auto operator() (size_type, size_type idx1, Args... args) const -> const_reference
 
template<class S>
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the container.
 
template<class OI>
auto operator[] (std::initializer_list< OI > index) -> reference
 
template<class S>
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the container.
 
template<class OI>
auto operator[] (std::initializer_list< OI > index) const -> const_reference
 
template<class It>
auto element (It first, It) -> reference
 Returns a reference to the element at the specified position in the xindex_view.
 
template<class It>
auto element (It first, It) const -> const_reference
 Returns a reference to the element at the specified position in the xindex_view.
 
Broadcasting
template<class O>
bool broadcast_shape (O &shape, bool reuse_cache=false) const
 Broadcast the shape of the xindex_view to the specified parameter.
 
template<class O>
bool has_linear_assign (const O &) const noexcept
 Checks whether the xindex_view can be linearly assigned to an expression with the specified strides.
 
template<class ST>
auto stepper_begin (const ST &shape) -> stepper
 
template<class ST>
auto stepper_end (const ST &shape, layout_type) -> stepper
 
template<class ST>
auto stepper_begin (const ST &shape) const -> const_stepper
 
template<class ST>
auto stepper_end (const ST &shape, layout_type) const -> const_stepper
 
template<class E>
auto build_index_view (E &&e) const -> rebind_t< E >
 
- Public Member Functions inherited from xt::xview_semantic< xindex_view< CT, I > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xindex_view< CT, I > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xiterable< xindex_view< CT, I > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+layout_iterator< L > begin () noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+layout_iterator< L > end () noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rbegin () noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rend () noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
auto begin () noexcept -> layout_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> layout_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () noexcept -> layout_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> layout_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto get_begin (bool end_index) noexcept -> layout_iterator< L >
 
auto get_end (bool end_index) noexcept -> layout_iterator< L >
 
auto get_begin (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_end (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) noexcept -> stepper
 
auto get_stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto get_begin (bool end_index) noexcept -> layout_iterator< L >
 
auto get_begin (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_end (bool end_index) noexcept -> layout_iterator< L >
 
auto get_end (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) noexcept -> stepper
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xconst_iterable< xindex_view< CT, I > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_layout_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_layout_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = layout_type::dynamic
 
static constexpr bool contiguous_layout = false
 
+ + + +

+Friends

class xview_semantic< xindex_view< CT, I > >
 
+ + + + + + + + +

Extended copy semantic

template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type > &
 
+ + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xview_semantic< xindex_view< CT, I > >
+ xview_semantic (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xindex_view< CT, I > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
const inner_shape_type & get_shape () const
 
+

Detailed Description

+
template<class CT, class I>
+class xt::xindex_view< CT, I >

View of an xexpression from vector of indices.

+

The xindex_view class implements a flat (1D) view into a multidimensional xexpression yielding the values at the indices of the index array. xindex_view is not meant to be used directly, but only with the index_view and filter helper functions.

+
Template Parameters
+ + + +
CTthe closure type of the xexpression type underlying this view
Ithe index array type of the view
+
+
+
See also
index_view, filter
+ +

Definition at line 90 of file xindex_view.hpp.

+

Member Typedef Documentation

+ +

◆ base_index_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::base_index_type = xindex_type_t<shape_type>
+
+ +

Definition at line 121 of file xindex_view.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::bool_load_type = typename xexpression_type::bool_load_type
+
+ +

Definition at line 123 of file xindex_view.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::const_pointer = typename xexpression_type::const_pointer
+
+ +

Definition at line 107 of file xindex_view.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::const_reference = typename xexpression_type::const_reference
+
+ +

Definition at line 105 of file xindex_view.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 118 of file xindex_view.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 109 of file xindex_view.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 101 of file xindex_view.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::extension_base = extension::xindex_view_base_t<CT, I>
+
+ +

Definition at line 100 of file xindex_view.hpp.

+ +
+
+ +

◆ indices_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::indices_type = I
+
+ +

Definition at line 115 of file xindex_view.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 112 of file xindex_view.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::iterable_base = xiterable<self_type>
+
+ +

Definition at line 111 of file xindex_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::pointer = typename xexpression_type::pointer
+
+ +

Definition at line 106 of file xindex_view.hpp.

+ +
+
+ +

◆ rebind_t

+ +
+
+
+template<class CT, class I>
+
+template<class E>
+ + + + +
using xt::xindex_view< CT, I >::rebind_t = xindex_view<E, I>
+
+ +

Definition at line 193 of file xindex_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::reference = inner_reference_t<CT>
+
+ +

Definition at line 104 of file xindex_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::self_type = xindex_view<CT, I>
+
+ +

Definition at line 96 of file xindex_view.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::semantic_base = xview_semantic<self_type>
+
+ +

Definition at line 98 of file xindex_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::shape_type = inner_shape_type
+
+ +

Definition at line 113 of file xindex_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::size_type = typename xexpression_type::size_type
+
+ +

Definition at line 108 of file xindex_view.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 117 of file xindex_view.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
+
+ +

Definition at line 120 of file xindex_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::value_type = typename xexpression_type::value_type
+
+ +

Definition at line 103 of file xindex_view.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT, class I>
+ + + + +
using xt::xindex_view< CT, I >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 97 of file xindex_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xindex_view()

+ +
+
+
+template<class CT, class I>
+
+template<class CTA, class I2>
+ + + + + +
+ + + + + + + + + + + +
xt::xindex_view< CT, I >::xindex_view (CTA && e,
I2 && indices )
+ 		+inlinenoexcept
+
+ +

Constructs an xindex_view, selecting the indices specified by indices.

+

The resulting xexpression has a 1D shape with a length of n for n indices.

+
Parameters
+ + + +
ethe underlying xexpression for this view
indicesthe indices to select
+
+
+ +

Definition at line 287 of file xindex_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ broadcast_shape()

+ +
+
+
+template<class CT, class I>
+
+template<class O>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xindex_view< CT, I >::broadcast_shape (O & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the xindex_view to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 562 of file xindex_view.hpp.

+ +
+
+ +

◆ build_index_view()

+ +
+
+
+template<class CT, class I>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::build_index_view (E && e) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 619 of file xindex_view.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::dimension () const
+ 		+inlinenoexcept
+
+ +

Returns the number of dimensions of the xindex_view.

+ +

Definition at line 343 of file xindex_view.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class CT, class I>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xindex_view< CT, I >::element (It first,
It  ) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the xindex_view.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices (not used, only for compatibility with xexpression operator()) The number of indices in the sequence should be equal to or greater 1.
+
+
+ +

Definition at line 512 of file xindex_view.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class CT, class I>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xindex_view< CT, I >::element (It first,
It  ) const -> const_reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the xindex_view.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices (not used, only for compatibility with xexpression operator()) The number of indices in the sequence should be equal to or greater 1.
+
+
+ +

Definition at line 525 of file xindex_view.hpp.

+ +
+
+ +

◆ expression() [1/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::expression () const
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the underlying expression of the view.

+ +

Definition at line 543 of file xindex_view.hpp.

+ +
+
+ +

◆ expression() [2/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::expression ()
+ 		+inlinenoexcept
+
+ +

Returns a reference to the underlying expression of the view.

+ +

Definition at line 534 of file xindex_view.hpp.

+ +
+
+ +

◆ fill()

+ +
+
+
+template<class CT, class I>
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xindex_view< CT, I >::fill (const T & value)
+ 		+inline
+
+ +

Fills the view with the given value.

+
Parameters
+ + +
valuethe value to fill the view with.
+
+
+ +

Definition at line 391 of file xindex_view.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CT, class I>
+
+template<class O>
+ + + + + +
+ + + + + + + +
bool xt::xindex_view< CT, I >::has_linear_assign (const O & ) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xindex_view can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 574 of file xindex_view.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
bool xt::xindex_view< CT, I >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 373 of file xindex_view.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
layout_type xt::xindex_view< CT, I >::layout () const
+ 		+inlinenoexcept
+
+ +

Definition at line 367 of file xindex_view.hpp.

+ +
+
+ +

◆ operator()() [1/4]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator() (size_type idx = size_type(0))
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the xindex_view.

+
Parameters
+ + +
idxindex specifying the position in the index_view. More indices may be provided, only the last one will be used.
+
+
+ +

Definition at line 402 of file xindex_view.hpp.

+ +
+
+ +

◆ operator()() [2/4]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator() (size_type idx = size_type(0)) const
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the xindex_view.

+
Parameters
+ + +
idxindex specifying the position in the index_view. More indices may be provided, only the last one will be used.
+
+
+ +

Definition at line 430 of file xindex_view.hpp.

+ +
+
+ +

◆ operator()() [3/4]

+ +
+
+
+template<class CT, class I>
+
+template<class... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xindex_view< CT, I >::operator() (size_type ,
size_type idx1,
Args... args ) -> reference +
+ 		+inline
+
+ +

Definition at line 409 of file xindex_view.hpp.

+ +
+
+ +

◆ operator()() [4/4]

+ +
+
+
+template<class CT, class I>
+
+template<class... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xindex_view< CT, I >::operator() (size_type ,
size_type idx1,
Args... args ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 437 of file xindex_view.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class CT, class I>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator= (const E & e) -> disable_xexpression<E, self_type>& +
+ 		+inline
+
+ +

Definition at line 314 of file xindex_view.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class CT, class I>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 305 of file xindex_view.hpp.

+ +
+
+ +

◆ operator[]() [1/6]

+ +
+
+
+template<class CT, class I>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator[] (const S & index) -> disable_integral_t<S, reference> +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the container.

+
Parameters
+ + +
indexa sequence of indices specifying the position in the container. Indices must be unsigned integers, the number of indices in the list should be equal or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 460 of file xindex_view.hpp.

+ +
+
+ +

◆ operator[]() [2/6]

+ +
+
+
+template<class CT, class I>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator[] (const S & index) const -> disable_integral_t<S, const_reference> +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the container.

+
Parameters
+ + +
indexa sequence of indices specifying the position in the container. Indices must be unsigned integers, the number of indices in the list should be equal or greater than the number of dimensions of the container.
+
+
+ +

Definition at line 486 of file xindex_view.hpp.

+ +
+
+ +

◆ operator[]() [3/6]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 473 of file xindex_view.hpp.

+ +
+
+ +

◆ operator[]() [4/6]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 499 of file xindex_view.hpp.

+ +
+
+ +

◆ operator[]() [5/6]

+ +
+
+
+template<class CT, class I>
+
+template<class OI>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator[] (std::initializer_list< OI > index) -> reference +
+ 		+inline
+
+ +

Definition at line 467 of file xindex_view.hpp.

+ +
+
+ +

◆ operator[]() [6/6]

+ +
+
+
+template<class CT, class I>
+
+template<class OI>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::operator[] (std::initializer_list< OI > index) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 493 of file xindex_view.hpp.

+ +
+
+ +

◆ shape() [1/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the xindex_view.

+ +

Definition at line 352 of file xindex_view.hpp.

+ +
+
+ +

◆ shape() [2/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::shape (size_type index) const
+ 		+inline
+
+ +

Returns the i-th dimension of the expression.

+ +

Definition at line 361 of file xindex_view.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::size () const
+ 		+inlinenoexcept
+
+ +

Returns the size of the xindex_view.

+ +

Definition at line 334 of file xindex_view.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class CT, class I>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::stepper_begin (const ST & shape) -> stepper +
+ 		+inline
+
+ +

Definition at line 587 of file xindex_view.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class CT, class I>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::stepper_begin (const ST & shape) const -> const_stepper +
+ 		+inline
+
+ +

Definition at line 603 of file xindex_view.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class CT, class I>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xindex_view< CT, I >::stepper_end (const ST & shape,
layout_type  ) -> stepper +
+ 		+inline
+
+ +

Definition at line 595 of file xindex_view.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class CT, class I>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xindex_view< CT, I >::stepper_end (const ST & shape,
layout_type  ) const -> const_stepper +
+ 		+inline
+
+ +

Definition at line 611 of file xindex_view.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::unchecked (size_type idx)
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the xindex_view.

+
Parameters
+ + +
idxindex specifying the position in the index_view.
+
+
+ +

Definition at line 419 of file xindex_view.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + + + + +
auto xt::xindex_view< CT, I >::unchecked (size_type idx) const
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the xindex_view.

+
Parameters
+ + +
idxindex specifying the position in the index_view.
+
+
+ +

Definition at line 447 of file xindex_view.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xview_semantic< xindex_view< CT, I > >

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + +
friend class xview_semantic< xindex_view< CT, I > >
+ 		+friend
+
+ +

Definition at line 204 of file xindex_view.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + +
bool xt::xindex_view< CT, I >::contiguous_layout = false
+ 		+staticconstexpr
+
+ +

Definition at line 126 of file xindex_view.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CT, class I>
+ + + + + +
+ + + + +
layout_type xt::xindex_view< CT, I >::static_layout = layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 125 of file xindex_view.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xindex_view.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xindex__view.js b/classxt_1_1xindex__view.js new file mode 100644 index 000000000..187aa9dae --- /dev/null +++ b/classxt_1_1xindex__view.js @@ -0,0 +1,22 @@ +var classxt_1_1xindex__view = +[ + [ "xindex_view", "classxt_1_1xindex__view.html#a0306275ff45341e84fe63836010c7ad5", null ], + [ "broadcast_shape", "classxt_1_1xindex__view.html#ac341559ffeb015df5070beec5596d2a9", null ], + [ "dimension", "classxt_1_1xindex__view.html#afeaa3f6f6c150f659935d1a625497203", null ], + [ "element", "classxt_1_1xindex__view.html#a4bdd94010df7af626590d532b2febefb", null ], + [ "element", "classxt_1_1xindex__view.html#a49787050a31b9c40a75f6644c6ee4c10", null ], + [ "expression", "classxt_1_1xindex__view.html#abad555c9ed25f834763760c88a236325", null ], + [ "expression", "classxt_1_1xindex__view.html#ab19a3dd1a9b7f67c557ee57bc189d319", null ], + [ "fill", "classxt_1_1xindex__view.html#aeecb2ec9572eac54def9d4f9934a86fd", null ], + [ "has_linear_assign", "classxt_1_1xindex__view.html#a436dfb313bdf3ce42a16cfa2a5c9f98f", null ], + [ "operator()", "classxt_1_1xindex__view.html#ab0eefdf0f3dedf19a78763643718e353", null ], + [ "operator()", "classxt_1_1xindex__view.html#aab9b1fd3d2f19db29b52cd9cad772a2d", null ], + [ "operator=", "classxt_1_1xindex__view.html#aac159eb55755735609a3095f1e73bf3a", null ], + [ "operator[]", "classxt_1_1xindex__view.html#a5f26e28734c1db46865b6eeb39009a2a", null ], + [ "operator[]", "classxt_1_1xindex__view.html#a2a2211fb97b8bbb0b6a8ea3e4ac6c0b5", null ], + [ "shape", "classxt_1_1xindex__view.html#ad124eaa3959093d86deab646c4a2fb18", null ], + [ "shape", "classxt_1_1xindex__view.html#a47f560d67ba251afd96c617e6c6e2a0e", null ], + [ "size", "classxt_1_1xindex__view.html#a9c3f7c72cb0e1172b75bb256e92e6b94", null ], + [ "unchecked", "classxt_1_1xindex__view.html#aa6c15d2a26e0a3a993332606bb3d8ddc", null ], + [ "unchecked", "classxt_1_1xindex__view.html#a9ff5247ea89e3a5ed114685960edd042", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xindex__view.png b/classxt_1_1xindex__view.png new file mode 100644 index 000000000..c50207472 Binary files /dev/null and b/classxt_1_1xindex__view.png differ diff --git a/classxt_1_1xindexed__stepper-members.html b/classxt_1_1xindexed__stepper-members.html new file mode 100644 index 000000000..7462ba8e8 --- /dev/null +++ b/classxt_1_1xindexed__stepper-members.html @@ -0,0 +1,138 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xindexed_stepper< E, is_const > Member List
+
+
+ +

This is the complete list of members for xt::xindexed_stepper< E, is_const >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
index_type typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
operator*() const (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
pointer typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
reference typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
reset(size_type dim) (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
reset_back(size_type dim) (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
self_type typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
shape_type typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
size_type typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
step(size_type dim, size_type n=1) (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
step_back(size_type dim, size_type n=1) (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
to_begin() (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
to_end(layout_type l) (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
value_type typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
xexpression_type typedef (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
xindexed_stepper()=default (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >
xindexed_stepper(xexpression_type *e, size_type offset, bool end=false) noexcept (defined in xt::xindexed_stepper< E, is_const >)xt::xindexed_stepper< E, is_const >inline
+
+ + + + diff --git a/classxt_1_1xindexed__stepper.html b/classxt_1_1xindexed__stepper.html new file mode 100644 index 000000000..3455eff56 --- /dev/null +++ b/classxt_1_1xindexed__stepper.html @@ -0,0 +1,588 @@ + + + + + + + +xtensor: xt::xindexed_stepper< E, is_const > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xindexed_stepper< E, is_const > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xindexed_stepper<E, is_const>
 
using xexpression_type = std::conditional_t<is_const, const E, E>
 
using value_type = typename xexpression_type::value_type
 
using reference
 
using pointer
 
using size_type = typename xexpression_type::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using shape_type = typename xexpression_type::shape_type
 
using index_type = xindex_type_t<shape_type>
 
+ + + + + + + + + + + + + + + + + +

+Public Member Functions

 xindexed_stepper (xexpression_type *e, size_type offset, bool end=false) noexcept
 
reference operator* () const
 
void step (size_type dim, size_type n=1)
 
void step_back (size_type dim, size_type n=1)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
+

Detailed Description

+
template<class E, bool is_const>
+class xt::xindexed_stepper< E, is_const >
+

Definition at line 176 of file xiterator.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 189 of file xiterator.hpp.

+ +
+
+ +

◆ index_type

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::index_type = xindex_type_t<shape_type>
+
+ +

Definition at line 192 of file xiterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::pointer
+
+Initial value:
std::
+
conditional_t<is_const, typename xexpression_type::const_pointer, typename xexpression_type::pointer>
+
+

Definition at line 186 of file xiterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::reference
+
+Initial value:
std::
+
conditional_t<is_const, typename xexpression_type::const_reference, typename xexpression_type::reference>
+
+

Definition at line 184 of file xiterator.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::self_type = xindexed_stepper<E, is_const>
+
+ +

Definition at line 180 of file xiterator.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::shape_type = typename xexpression_type::shape_type
+
+ +

Definition at line 191 of file xiterator.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::size_type = typename xexpression_type::size_type
+
+ +

Definition at line 188 of file xiterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::value_type = typename xexpression_type::value_type
+
+ +

Definition at line 183 of file xiterator.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class E, bool is_const>
+ + + + +
using xt::xindexed_stepper< E, is_const >::xexpression_type = std::conditional_t<is_const, const E, E>
+
+ +

Definition at line 181 of file xiterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xindexed_stepper()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xindexed_stepper< C, is_const >::xindexed_stepper (xexpression_type * e,
size_type offset,
bool end = false )
+ 		+inlinenoexcept
+
+ +

Definition at line 962 of file xiterator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + +
auto xt::xindexed_stepper< C, is_const >::operator* () const
+ 		+inline
+
+ +

Definition at line 975 of file xiterator.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + +
void xt::xindexed_stepper< C, is_const >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 999 of file xiterator.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + +
void xt::xindexed_stepper< C, is_const >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 1008 of file xiterator.hpp.

+ +
+
+ +

◆ step()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + + + + + +
void xt::xindexed_stepper< C, is_const >::step (size_type dim,
size_type n = 1 )
+ 		+inline
+
+ +

Definition at line 981 of file xiterator.hpp.

+ +
+
+ +

◆ step_back()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + + + + + +
void xt::xindexed_stepper< C, is_const >::step_back (size_type dim,
size_type n = 1 )
+ 		+inline
+
+ +

Definition at line 990 of file xiterator.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + +
void xt::xindexed_stepper< C, is_const >::to_begin ()
+ 		+inline
+
+ +

Definition at line 1017 of file xiterator.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class C, bool is_const>
+ + + + + +
+ + + + + + + +
void xt::xindexed_stepper< C, is_const >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 1023 of file xiterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xiterator.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xiterable-members.html b/classxt_1_1xiterable-members.html new file mode 100644 index 000000000..8ec9f099c --- /dev/null +++ b/classxt_1_1xiterable-members.html @@ -0,0 +1,195 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xiterable< D > Member List
+
+
+ +

This is the complete list of members for xt::xiterable< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
base_type typedef (defined in xt::xiterable< D >)xt::xiterable< D >
begin() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
begin(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
begin() noexcept -> layout_iterator< L >xt::xiterable< D >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< D >inline
begin() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
begin(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
cbegin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cbegin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
cend() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cend(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< D >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
const_broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_reverse_broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_reverse_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_reverse_layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
const_reverse_linear_iterator typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
const_stepper typedef (defined in xt::xiterable< D >)xt::xiterable< D >
crbegin() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crbegin(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
crend() const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crend(const S &shape) const noexcept (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< D >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< D >inline
derived_type typedef (defined in xt::xiterable< D >)xt::xiterable< D >
end() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
end(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
end() noexcept -> layout_iterator< L >xt::xiterable< D >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xiterable< D >inline
end() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
end(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
get_begin(bool end_index) noexcept -> layout_iterator< L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_begin(const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_cbegin(bool end_index) const noexcept -> const_layout_iterator< L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cbegin(const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cend(bool end_index) const noexcept -> const_layout_iterator< L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_cend(const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inline
get_end(bool end_index) noexcept -> layout_iterator< L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_end(const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L > (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_shape() const (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >inlineprotected
get_stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_stepper_end(const S &shape, layout_type l) noexcept -> stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
get_stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xiterable< D >)xt::xiterable< D >inline
inner_shape_type typedef (defined in xt::xiterable< D >)xt::xiterable< D >
iterable_types typedef (defined in xt::xconst_iterable< D >)xt::xconst_iterable< D >
iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
linear_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
rbegin() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rbegin(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rbegin() noexcept -> reverse_layout_iterator< L >xt::xiterable< D >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< D >inline
rbegin() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rbegin(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rend() noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rend(const S &shape) noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rend() noexcept -> reverse_layout_iterator< L >xt::xiterable< D >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xiterable< D >inline
rend() const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
rend(const S &shape) const noexcept (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_broadcast_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_layout_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
reverse_linear_iterator typedef (defined in xt::xiterable< D >)xt::xiterable< D >
stepper typedef (defined in xt::xiterable< D >)xt::xiterable< D >
+
+ + + + diff --git a/classxt_1_1xiterable.html b/classxt_1_1xiterable.html new file mode 100644 index 000000000..e6b32f286 --- /dev/null +++ b/classxt_1_1xiterable.html @@ -0,0 +1,1534 @@ + + + + + + + +xtensor: xt::xiterable< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xiterable< D > Class Template Reference
+
+
+ +

Base class for multidimensional iterable expressions. + More...

+ +

#include <xiterable.hpp>

+
+Inheritance diagram for xt::xiterable< D >:
+
+
+ + +xt::xconst_iterable< D > +xt::xdynamic_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xdynamic_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xdynamic_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xdynamic_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xdynamic_view< CT, S, L, FST > +xt::xdynamic_view< E, S, L, typename FST::template rebind_t< E > > +xt::xindex_view< uvt, I > +xt::xindex_view< uft, I > +xt::xindex_view< ucvt, I > +xt::xindex_view< ucft, I > +xt::xindex_view< E, I > +xt::xscalar< xtl::closure_type_t< E > > +xt::xscalar< xtl::const_closure_type_t< E > > +xt::xscalar< T > +xt::xscalar< bool > +xt::xscalar< std::conditional_t< is_const, const_value_closure, value_closure > > +xt::xscalar< std::conditional_t< is_const, const_flag_closure, flag_closure > > +xt::xscalar< const_value_closure > +xt::xscalar< const_flag_closure > +xt::xcontiguous_iterable< D > +xt::xdynamic_view< CT, S, L, FST > +xt::xoptional_assembly_base< D > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using derived_type = D
 
using base_type = xconst_iterable<D>
 
using inner_shape_type = typename base_type::inner_shape_type
 
using stepper = typename base_type::stepper
 
using const_stepper = typename base_type::const_stepper
 
using linear_iterator = typename base_type::linear_iterator
 
using reverse_linear_iterator = typename base_type::reverse_linear_iterator
 
template<layout_type L>
using layout_iterator = typename base_type::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename base_type::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename base_type::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename base_type::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename base_type::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename base_type::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename base_type::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename base_type::template const_reverse_broadcast_iterator<S, L>
 
using iterator = typename base_type::iterator
 
using const_iterator = typename base_type::const_iterator
 
using reverse_iterator = typename base_type::reverse_iterator
 
using const_reverse_iterator = typename base_type::const_reverse_iterator
 
- Public Types inherited from xt::xconst_iterable< D >
using derived_type = D
 
using iterable_types = xiterable_inner_types<D>
 
using inner_shape_type = typename iterable_types::inner_shape_type
 
using stepper = typename iterable_types::stepper
 
using const_stepper = typename iterable_types::const_stepper
 
template<layout_type L>
using layout_iterator = xiterator<stepper, inner_shape_type*, L>
 
template<layout_type L>
using const_layout_iterator = xiterator<const_stepper, inner_shape_type*, L>
 
template<layout_type L>
using reverse_layout_iterator = std::reverse_iterator<layout_iterator<L>>
 
template<layout_type L>
using const_reverse_layout_iterator = std::reverse_iterator<const_layout_iterator<L>>
 
using linear_iterator = layout_iterator< ::xt::layout_type::row_major >
 
using const_linear_iterator = const_layout_iterator< ::xt::layout_type::row_major >
 
using reverse_linear_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
 
using const_reverse_linear_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
 
template<class S, layout_type L>
using broadcast_iterator = xiterator<stepper, S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = xiterator<const_stepper, S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = std::reverse_iterator<broadcast_iterator<S, L>>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = std::reverse_iterator<const_broadcast_iterator<S, L>>
 
using iterator = layout_iterator< ::xt::layout_type::row_major >
 
using const_iterator = const_layout_iterator< ::xt::layout_type::row_major >
 
using reverse_iterator = reverse_layout_iterator< ::xt::layout_type::row_major >
 
using const_reverse_iterator = const_reverse_layout_iterator< ::xt::layout_type::row_major >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<layout_type L = ::xt::layout_type::row_major>
layout_iterator< L > begin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
layout_iterator< L > end () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_layout_iterator< L > rbegin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_layout_iterator< L > rend () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
Iterators
template<layout_type L>
auto begin () noexcept -> layout_iterator< L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L>
auto end () noexcept -> layout_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
Reverse iterators
template<layout_type L>
auto rbegin () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () noexcept -> reverse_layout_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
Broadcast iterators
template<layout_type L, class S>
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
- Public Member Functions inherited from xt::xconst_iterable< D >
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > cbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > cend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > crbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > crend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
template<layout_type L>
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
template<layout_type L>
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
template<layout_type L, class S>
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
template<layout_type L, class S>
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
template<class S>
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Reverse broadcast iterators

template<layout_type L, class S>
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto get_begin (bool end_index) noexcept -> layout_iterator< L >
 
template<layout_type L>
auto get_end (bool end_index) noexcept -> layout_iterator< L >
 
template<layout_type L, class S>
auto get_begin (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
template<layout_type L, class S>
auto get_end (const S &shape, bool end_index) noexcept -> broadcast_iterator< S, L >
 
template<class S>
auto get_stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto get_stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
template<class S>
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
+ + + +

+Additional Inherited Members

const inner_shape_type & get_shape () const
 
+

Detailed Description

+
template<class D>
+class xt::xiterable< D >

Base class for multidimensional iterable expressions.

+

The xiterable class defines the interface for multidimensional expressions that can be iterated.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xiterable provides the interface.
+
+
+ +

Definition at line 151 of file xiterable.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::base_type = xconst_iterable<D>
+
+ +

Definition at line 157 of file xiterable.hpp.

+ +
+
+ +

◆ broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xiterable< D >::broadcast_iterator = typename base_type::template broadcast_iterator<S, L>
+
+ +

Definition at line 176 of file xiterable.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xiterable< D >::const_broadcast_iterator = typename base_type::template const_broadcast_iterator<S, L>
+
+ +

Definition at line 178 of file xiterable.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::const_iterator = typename base_type::const_iterator
+
+ +

Definition at line 185 of file xiterable.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xiterable< D >::const_layout_iterator = typename base_type::template const_layout_iterator<L>
+
+ +

Definition at line 169 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xiterable< D >::const_reverse_broadcast_iterator = typename base_type::template const_reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 182 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::const_reverse_iterator = typename base_type::const_reverse_iterator
+
+ +

Definition at line 187 of file xiterable.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xiterable< D >::const_reverse_layout_iterator = typename base_type::template const_reverse_layout_iterator<L>
+
+ +

Definition at line 173 of file xiterable.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::const_stepper = typename base_type::const_stepper
+
+ +

Definition at line 161 of file xiterable.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::derived_type = D
+
+ +

Definition at line 155 of file xiterable.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::inner_shape_type = typename base_type::inner_shape_type
+
+ +

Definition at line 158 of file xiterable.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::iterator = typename base_type::iterator
+
+ +

Definition at line 184 of file xiterable.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xiterable< D >::layout_iterator = typename base_type::template layout_iterator<L>
+
+ +

Definition at line 167 of file xiterable.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::linear_iterator = typename base_type::linear_iterator
+
+ +

Definition at line 163 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xiterable< D >::reverse_broadcast_iterator = typename base_type::template reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 180 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::reverse_iterator = typename base_type::reverse_iterator
+
+ +

Definition at line 186 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xiterable< D >::reverse_layout_iterator = typename base_type::template reverse_layout_iterator<L>
+
+ +

Definition at line 171 of file xiterable.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::reverse_linear_iterator = typename base_type::reverse_linear_iterator
+
+ +

Definition at line 164 of file xiterable.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xiterable< D >::stepper = typename base_type::stepper
+
+ +

Definition at line 160 of file xiterable.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::begin () -> layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 757 of file xiterable.hpp.

+ +
+
+ +

◆ begin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::begin (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 818 of file xiterable.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::end () -> layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 769 of file xiterable.hpp.

+ +
+
+ +

◆ end() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::end (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 832 of file xiterable.hpp.

+ +
+
+ +

◆ get_begin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::get_begin (bool end_index) -> layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 875 of file xiterable.hpp.

+ +
+
+ +

◆ get_begin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xiterable< D >::get_begin (const S & shape,
bool end_index ) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 889 of file xiterable.hpp.

+ +
+
+ +

◆ get_end() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::get_end (bool end_index) -> layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 882 of file xiterable.hpp.

+ +
+
+ +

◆ get_end() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xiterable< D >::get_end (const S & shape,
bool end_index ) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 896 of file xiterable.hpp.

+ +
+
+ +

◆ get_stepper_begin() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::get_stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 917 of file xiterable.hpp.

+ +
+
+ +

◆ get_stepper_begin() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::get_stepper_begin (const S & shape) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 903 of file xiterable.hpp.

+ +
+
+ +

◆ get_stepper_end() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xiterable< D >::get_stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 924 of file xiterable.hpp.

+ +
+
+ +

◆ get_stepper_end() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xiterable< D >::get_stepper_end (const S & shape,
layout_type l ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 910 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::rbegin () -> reverse_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 786 of file xiterable.hpp.

+ +
+
+ +

◆ rbegin() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::rbegin (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the first element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 852 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [1/2]

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::rend () -> reverse_layout_iterator<L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the reversed expression.

+
Template Parameters
+ + +
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 798 of file xiterable.hpp.

+ +
+
+ +

◆ rend() [2/2]

+ +
+
+
+template<class D>
+
+template<layout_type L, class S>
+ + + + + +
+ + + + + + + +
auto xt::xiterable< D >::rend (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Returns an iterator to the element following the last element of the reversed expression.

+

The iteration is broadcasted to the specified shape.

Parameters
+ + +
shapethe shape used for broadcasting
+
+
+
Template Parameters
+ + + +
Stype of the shape parameter.
Lorder used for the traversal. Default value is XTENSOR_DEFAULT_TRAVERSAL.
+
+
+ +

Definition at line 866 of file xiterable.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xiterable.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xiterable.js b/classxt_1_1xiterable.js new file mode 100644 index 000000000..072be20fb --- /dev/null +++ b/classxt_1_1xiterable.js @@ -0,0 +1,11 @@ +var classxt_1_1xiterable = +[ + [ "begin", "classxt_1_1xiterable.html#aa92f6e2edb798a381d131475e463bf31", null ], + [ "begin", "classxt_1_1xiterable.html#a4123b26a873b7ed680b13ef557cd3c3c", null ], + [ "end", "classxt_1_1xiterable.html#a76c73882716f9e9915dab847639db2da", null ], + [ "end", "classxt_1_1xiterable.html#a9b56f37894a5055ffe49a46c857b7111", null ], + [ "rbegin", "classxt_1_1xiterable.html#a7bc86e4fb6f2f55c74e33836a32739eb", null ], + [ "rbegin", "classxt_1_1xiterable.html#a66bef4e8cff9bf584e71f0ac7ba828ad", null ], + [ "rend", "classxt_1_1xiterable.html#af04d43d598e8933225287e044c12d4c6", null ], + [ "rend", "classxt_1_1xiterable.html#a92e4a1b212968fcc8a8240be122fe8e4", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xiterable.png b/classxt_1_1xiterable.png new file mode 100644 index 000000000..8518663e2 Binary files /dev/null and b/classxt_1_1xiterable.png differ diff --git a/classxt_1_1xiterator-members.html b/classxt_1_1xiterator-members.html new file mode 100644 index 000000000..e9a6f2da6 --- /dev/null +++ b/classxt_1_1xiterator-members.html @@ -0,0 +1,143 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xiterator< St, S, L > Member List
+
+
+ +

This is the complete list of members for xt::xiterator< St, S, L >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
equal(const xiterator &rhs) const (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
index_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
iterator_category typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
less_than(const xiterator &rhs) const (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
operator*() const (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
operator++() (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
operator+=(difference_type n) (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
operator-(const self_type &rhs) const (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
operator--() (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
operator-=(difference_type n) (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
operator->() const (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
pointer typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
private_base typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
reference typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
self_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
shape_param_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
shape_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
size_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
stepper_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
value_type typedef (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
xiterator()=default (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >
xiterator(St st, shape_param_type shape, bool end_index) (defined in xt::xiterator< St, S, L >)xt::xiterator< St, S, L >inline
+
+ + + + diff --git a/classxt_1_1xiterator.html b/classxt_1_1xiterator.html new file mode 100644 index 000000000..b2ec8be58 --- /dev/null +++ b/classxt_1_1xiterator.html @@ -0,0 +1,704 @@ + + + + + + + +xtensor: xt::xiterator< St, S, L > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xiterator< St, S, L > Class Template Reference
+
+
+
+Inheritance diagram for xt::xiterator< St, S, L >:
+
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xiterator<St, S, L>
 
using stepper_type = St
 
using value_type = typename stepper_type::value_type
 
using reference = typename stepper_type::reference
 
using pointer = typename stepper_type::pointer
 
using difference_type = typename stepper_type::difference_type
 
using size_type = typename stepper_type::size_type
 
using iterator_category = std::random_access_iterator_tag
 
using private_base = detail::shape_storage<S>
 
using shape_type = typename private_base::shape_type
 
using shape_param_type = typename private_base::param_type
 
using index_type = xindex_type_t<shape_type>
 
+ + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xiterator (St st, shape_param_type shape, bool end_index)
 
self_type & operator++ ()
 
self_type & operator-- ()
 
self_type & operator+= (difference_type n)
 
self_type & operator-= (difference_type n)
 
difference_type operator- (const self_type &rhs) const
 
reference operator* () const
 
pointer operator-> () const
 
bool equal (const xiterator &rhs) const
 
bool less_than (const xiterator &rhs) const
 
+

Detailed Description

+
template<class St, class S, layout_type L>
+class xt::xiterator< St, S, L >
+

Definition at line 286 of file xiterator.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::difference_type = typename stepper_type::difference_type
+
+ +

Definition at line 302 of file xiterator.hpp.

+ +
+
+ +

◆ index_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::index_type = xindex_type_t<shape_type>
+
+ +

Definition at line 309 of file xiterator.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::iterator_category = std::random_access_iterator_tag
+
+ +

Definition at line 304 of file xiterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::pointer = typename stepper_type::pointer
+
+ +

Definition at line 301 of file xiterator.hpp.

+ +
+
+ +

◆ private_base

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::private_base = detail::shape_storage<S>
+
+ +

Definition at line 306 of file xiterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::reference = typename stepper_type::reference
+
+ +

Definition at line 300 of file xiterator.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::self_type = xiterator<St, S, L>
+
+ +

Definition at line 296 of file xiterator.hpp.

+ +
+
+ +

◆ shape_param_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::shape_param_type = typename private_base::param_type
+
+ +

Definition at line 308 of file xiterator.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::shape_type = typename private_base::shape_type
+
+ +

Definition at line 307 of file xiterator.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::size_type = typename stepper_type::size_type
+
+ +

Definition at line 303 of file xiterator.hpp.

+ +
+
+ +

◆ stepper_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::stepper_type = St
+
+ +

Definition at line 298 of file xiterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + +
using xt::xiterator< St, S, L >::value_type = typename stepper_type::value_type
+
+ +

Definition at line 299 of file xiterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xiterator()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xiterator< St, S, L >::xiterator (St st,
shape_param_type shape,
bool end_index )
+ 		+inline
+
+ +

Definition at line 1084 of file xiterator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ equal()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
bool xt::xiterator< St, S, L >::equal (const xiterator< St, S, L > & rhs) const
+ 		+inline
+
+ +

Definition at line 1184 of file xiterator.hpp.

+ +
+
+ +

◆ less_than()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
bool xt::xiterator< St, S, L >::less_than (const xiterator< St, S, L > & rhs) const
+ 		+inline
+
+ +

Definition at line 1191 of file xiterator.hpp.

+ +
+
+ +

◆ operator*()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterator< St, S, L >::operator* () const
+ 		+inline
+
+ +

Definition at line 1172 of file xiterator.hpp.

+ +
+
+ +

◆ operator++()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterator< St, S, L >::operator++ ()
+ 		+inline
+
+ +

Definition at line 1120 of file xiterator.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterator< St, S, L >::operator+= (difference_type n)
+ 		+inline
+
+ +

Definition at line 1136 of file xiterator.hpp.

+ +
+
+ +

◆ operator-()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterator< St, S, L >::operator- (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 1166 of file xiterator.hpp.

+ +
+
+ +

◆ operator--()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterator< St, S, L >::operator-- ()
+ 		+inline
+
+ +

Definition at line 1128 of file xiterator.hpp.

+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterator< St, S, L >::operator-= (difference_type n)
+ 		+inline
+
+ +

Definition at line 1151 of file xiterator.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<class St, class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xiterator< St, S, L >::operator-> () const
+ 		+inline
+
+ +

Definition at line 1178 of file xiterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xiterator.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xiterator.png b/classxt_1_1xiterator.png new file mode 100644 index 000000000..12ef35477 Binary files /dev/null and b/classxt_1_1xiterator.png differ diff --git a/classxt_1_1xiterator__adaptor-members.html b/classxt_1_1xiterator__adaptor-members.html new file mode 100644 index 000000000..06a534605 --- /dev/null +++ b/classxt_1_1xiterator__adaptor-members.html @@ -0,0 +1,142 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xiterator_adaptor< I, CI > Member List
+
+
+ +

This is the complete list of members for xt::xiterator_adaptor< I, CI >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
base_type typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
const_iterator typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
data() noexcept (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
data() const noexcept (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
iterator typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
operator=(const self_type &)=default (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
operator=(self_type &&)=default (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
operator=(const temporary_type &rhs) (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
operator=(temporary_type &&rhs) (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
resize(size_type size) (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
self_type typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
size() const noexcept (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
size_type typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
swap(self_type &rhs) noexcept (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
temporary_type typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
value_type typedef (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
xiterator_adaptor()=default (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
xiterator_adaptor(I it, CI cit, size_type size) (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >inline
xiterator_adaptor(const self_type &)=default (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
xiterator_adaptor(self_type &&)=default (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
~xiterator_adaptor()=default (defined in xt::xiterator_adaptor< I, CI >)xt::xiterator_adaptor< I, CI >
+
+ + + + diff --git a/classxt_1_1xiterator__adaptor.html b/classxt_1_1xiterator__adaptor.html new file mode 100644 index 000000000..053c1ddbd --- /dev/null +++ b/classxt_1_1xiterator__adaptor.html @@ -0,0 +1,667 @@ + + + + + + + +xtensor: xt::xiterator_adaptor< I, CI > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xiterator_adaptor< I, CI > Class Template Reference
+
+
+
+Inheritance diagram for xt::xiterator_adaptor< I, CI >:
+
+
+ + +xt::xbuffer_adaptor_base< xiterator_adaptor< I, CI > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xiterator_adaptor<I, CI>
 
using base_type = xbuffer_adaptor_base<self_type>
 
using value_type = typename base_type::value_type
 
using allocator_type = std::allocator<value_type>
 
using size_type = typename base_type::size_type
 
using iterator = typename base_type::iterator
 
using const_iterator = typename base_type::const_iterator
 
using temporary_type = uvector<value_type, allocator_type>
 
- Public Types inherited from xt::xbuffer_adaptor_base< xiterator_adaptor< I, CI > >
using self_type
 
using derived_type
 
using inner_types
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
using index_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xiterator_adaptor (I it, CI cit, size_type size)
 
+ xiterator_adaptor (const self_type &)=default
 
+xiterator_adaptor & operator= (const self_type &)=default
 
+ xiterator_adaptor (self_type &&)=default
 
+xiterator_adaptor & operator= (self_type &&)=default
 
xiterator_adaptor & operator= (const temporary_type &rhs)
 
xiterator_adaptor & operator= (temporary_type &&rhs)
 
size_type size () const noexcept
 
void resize (size_type size)
 
iterator data () noexcept
 
const_iterator data () const noexcept
 
void swap (self_type &rhs) noexcept
 
- Public Member Functions inherited from xt::xbuffer_adaptor_base< xiterator_adaptor< I, CI > >
bool empty () const noexcept
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rend () noexcept
 
const_reverse_iterator rend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xbuffer_adaptor_base< xiterator_adaptor< I, CI > >
+ xbuffer_adaptor_base (const self_type &)=default
 
+ xbuffer_adaptor_base (self_type &&)=default
 
+self_type & operator= (const self_type &)=default
 
+self_type & operator= (self_type &&)=default
 
+

Detailed Description

+
template<class I, class CI>
+class xt::xiterator_adaptor< I, CI >
+

Definition at line 441 of file xbuffer_adaptor.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::allocator_type = std::allocator<value_type>
+
+ +

Definition at line 448 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::base_type = xbuffer_adaptor_base<self_type>
+
+ +

Definition at line 446 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::const_iterator = typename base_type::const_iterator
+
+ +

Definition at line 451 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::iterator = typename base_type::iterator
+
+ +

Definition at line 450 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::self_type = xiterator_adaptor<I, CI>
+
+ +

Definition at line 445 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::size_type = typename base_type::size_type
+
+ +

Definition at line 449 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::temporary_type = uvector<value_type, allocator_type>
+
+ +

Definition at line 452 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class I, class CI>
+ + + + +
using xt::xiterator_adaptor< I, CI >::value_type = typename base_type::value_type
+
+ +

Definition at line 447 of file xbuffer_adaptor.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xiterator_adaptor()

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xiterator_adaptor< I, CI >::xiterator_adaptor (I it,
CI cit,
size_type size )
+ 		+inline
+
+ +

Definition at line 1077 of file xbuffer_adaptor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ data() [1/2]

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_adaptor< I, CI >::data () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1120 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_adaptor< I, CI >::data ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1114 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_adaptor< I, CI >::operator= (const temporary_type & rhs)
+ 		+inline
+
+ +

Definition at line 1085 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_adaptor< I, CI >::operator= (temporary_type && rhs)
+ 		+inline
+
+ +

Definition at line 1093 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ resize()

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + +
void xt::xiterator_adaptor< I, CI >::resize (size_type size)
+ 		+inline
+
+ +

Definition at line 1105 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_adaptor< I, CI >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1099 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ swap()

+ +
+
+
+template<class I, class CI>
+ + + + + +
+ + + + + + + +
void xt::xiterator_adaptor< I, CI >::swap (self_type & rhs)
+ 		+inlinenoexcept
+
+ +

Definition at line 1126 of file xbuffer_adaptor.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xiterator__adaptor.png b/classxt_1_1xiterator__adaptor.png new file mode 100644 index 000000000..fcb1628ed Binary files /dev/null and b/classxt_1_1xiterator__adaptor.png differ diff --git a/classxt_1_1xiterator__owner__adaptor-members.html b/classxt_1_1xiterator__owner__adaptor-members.html new file mode 100644 index 000000000..2d676cd4b --- /dev/null +++ b/classxt_1_1xiterator__owner__adaptor-members.html @@ -0,0 +1,141 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xiterator_owner_adaptor< C, IG > Member List
+
+
+ +

This is the complete list of members for xt::xiterator_owner_adaptor< C, IG >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
base_type typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
const_iterator typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
data() noexcept (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
data() const noexcept (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
iterator typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
operator=(const self_type &) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
operator=(self_type &&) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
operator=(const temporary_type &rhs) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
operator=(temporary_type &&rhs) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
resize(size_type size) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
self_type typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
size() const noexcept (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
size_type typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
swap(self_type &rhs) noexcept (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
temporary_type typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
value_type typedef (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
xiterator_owner_adaptor(C &&c) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
xiterator_owner_adaptor(const self_type &) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
xiterator_owner_adaptor(self_type &&) (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >inline
~xiterator_owner_adaptor()=default (defined in xt::xiterator_owner_adaptor< C, IG >)xt::xiterator_owner_adaptor< C, IG >
+
+ + + + diff --git a/classxt_1_1xiterator__owner__adaptor.html b/classxt_1_1xiterator__owner__adaptor.html new file mode 100644 index 000000000..1c71c7d42 --- /dev/null +++ b/classxt_1_1xiterator__owner__adaptor.html @@ -0,0 +1,770 @@ + + + + + + + +xtensor: xt::xiterator_owner_adaptor< C, IG > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xiterator_owner_adaptor< C, IG > Class Template Reference
+
+
+
+Inheritance diagram for xt::xiterator_owner_adaptor< C, IG >:
+
+
+ + +xt::xbuffer_adaptor_base< xiterator_owner_adaptor< C, IG > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xiterator_owner_adaptor<C, IG>
 
using base_type = xbuffer_adaptor_base<self_type>
 
using value_type = typename base_type::value_type
 
using allocator_type = std::allocator<value_type>
 
using size_type = typename base_type::size_type
 
using iterator = typename base_type::iterator
 
using const_iterator = typename base_type::const_iterator
 
using temporary_type = uvector<value_type, allocator_type>
 
- Public Types inherited from xt::xbuffer_adaptor_base< xiterator_owner_adaptor< C, IG > >
using self_type
 
using derived_type
 
using inner_types
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
using index_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xiterator_owner_adaptor (C &&c)
 
 xiterator_owner_adaptor (const self_type &)
 
xiterator_owner_adaptor & operator= (const self_type &)
 
 xiterator_owner_adaptor (self_type &&)
 
xiterator_owner_adaptor & operator= (self_type &&)
 
xiterator_owner_adaptor & operator= (const temporary_type &rhs)
 
xiterator_owner_adaptor & operator= (temporary_type &&rhs)
 
size_type size () const noexcept
 
void resize (size_type size)
 
iterator data () noexcept
 
const_iterator data () const noexcept
 
void swap (self_type &rhs) noexcept
 
- Public Member Functions inherited from xt::xbuffer_adaptor_base< xiterator_owner_adaptor< C, IG > >
bool empty () const noexcept
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rend () noexcept
 
const_reverse_iterator rend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xbuffer_adaptor_base< xiterator_owner_adaptor< C, IG > >
+ xbuffer_adaptor_base (const self_type &)=default
 
+ xbuffer_adaptor_base (self_type &&)=default
 
+self_type & operator= (const self_type &)=default
 
+self_type & operator= (self_type &&)=default
 
+

Detailed Description

+
template<class C, class IG>
+class xt::xiterator_owner_adaptor< C, IG >
+

Definition at line 520 of file xbuffer_adaptor.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::allocator_type = std::allocator<value_type>
+
+ +

Definition at line 527 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::base_type = xbuffer_adaptor_base<self_type>
+
+ +

Definition at line 525 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::const_iterator = typename base_type::const_iterator
+
+ +

Definition at line 530 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::iterator = typename base_type::iterator
+
+ +

Definition at line 529 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::self_type = xiterator_owner_adaptor<C, IG>
+
+ +

Definition at line 524 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::size_type = typename base_type::size_type
+
+ +

Definition at line 528 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::temporary_type = uvector<value_type, allocator_type>
+
+ +

Definition at line 531 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class C, class IG>
+ + + + +
using xt::xiterator_owner_adaptor< C, IG >::value_type = typename base_type::value_type
+
+ +

Definition at line 526 of file xbuffer_adaptor.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xiterator_owner_adaptor() [1/3]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
xt::xiterator_owner_adaptor< C, IG >::xiterator_owner_adaptor (C && c)
+ 		+inline
+
+ +

Definition at line 1145 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ xiterator_owner_adaptor() [2/3]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
xt::xiterator_owner_adaptor< C, IG >::xiterator_owner_adaptor (const self_type & rhs)
+ 		+inline
+
+ +

Definition at line 1152 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ xiterator_owner_adaptor() [3/3]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
xt::xiterator_owner_adaptor< C, IG >::xiterator_owner_adaptor (self_type && rhs)
+ 		+inline
+
+ +

Definition at line 1166 of file xbuffer_adaptor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ data() [1/2]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_owner_adaptor< C, IG >::data () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1215 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_owner_adaptor< C, IG >::data ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1209 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator=() [1/4]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
xiterator_owner_adaptor< C, IG > & xt::xiterator_owner_adaptor< C, IG >::operator= (const self_type & rhs)
+ 		+inline
+
+ +

Definition at line 1159 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator=() [2/4]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
xiterator_owner_adaptor< C, IG > & xt::xiterator_owner_adaptor< C, IG >::operator= (const temporary_type & rhs)
+ 		+inline
+
+ +

Definition at line 1180 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator=() [3/4]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
xiterator_owner_adaptor< C, IG > & xt::xiterator_owner_adaptor< C, IG >::operator= (self_type && rhs)
+ 		+inline
+
+ +

Definition at line 1173 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ operator=() [4/4]

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
xiterator_owner_adaptor< C, IG > & xt::xiterator_owner_adaptor< C, IG >::operator= (temporary_type && rhs)
+ 		+inline
+
+ +

Definition at line 1188 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ resize()

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
void xt::xiterator_owner_adaptor< C, IG >::resize (size_type size)
+ 		+inline
+
+ +

Definition at line 1200 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
auto xt::xiterator_owner_adaptor< C, IG >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1194 of file xbuffer_adaptor.hpp.

+ +
+
+ +

◆ swap()

+ +
+
+
+template<class C, class IG>
+ + + + + +
+ + + + + + + +
void xt::xiterator_owner_adaptor< C, IG >::swap (self_type & rhs)
+ 		+inlinenoexcept
+
+ +

Definition at line 1221 of file xbuffer_adaptor.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xiterator__owner__adaptor.png b/classxt_1_1xiterator__owner__adaptor.png new file mode 100644 index 000000000..3ff84ddb4 Binary files /dev/null and b/classxt_1_1xiterator__owner__adaptor.png differ diff --git a/classxt_1_1xkeep__slice-members.html b/classxt_1_1xkeep__slice-members.html new file mode 100644 index 000000000..64f7bb077 --- /dev/null +++ b/classxt_1_1xkeep__slice-members.html @@ -0,0 +1,137 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xkeep_slice< T > Member List
+
+
+ +

This is the complete list of members for xt::xkeep_slice< T >, including all inherited members.

+ + + + + + + + + + + + + + + + + + +
container_type typedef (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >
contains(size_type i) const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
convert() const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
normalize(std::size_t s) (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
operator xkeep_slice< S >() const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
operator!=(const self_type &rhs) const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
operator()(size_type i) const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
operator==(const self_type &rhs) const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
revert_index(std::size_t i) const (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
self_type typedef (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >
size() const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
size_type typedef (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >
step_size(std::size_t i, std::size_t n=1) const noexcept (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
xkeep_slice (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >friend
xkeep_slice(C &cont) (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inlineexplicit
xkeep_slice(container_type &&cont) (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inlineexplicit
xkeep_slice(std::initializer_list< S > t) (defined in xt::xkeep_slice< T >)xt::xkeep_slice< T >inline
+
+ + + + diff --git a/classxt_1_1xkeep__slice.html b/classxt_1_1xkeep__slice.html new file mode 100644 index 000000000..946b1adc3 --- /dev/null +++ b/classxt_1_1xkeep__slice.html @@ -0,0 +1,683 @@ + + + + + + + +xtensor: xt::xkeep_slice< T > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xkeep_slice< T > Class Template Reference
+
+
+
+Inheritance diagram for xt::xkeep_slice< T >:
+
+
+ + +xt::xslice< xkeep_slice< T > > + +
+ + + + + + + + + + + +

+Public Types

using container_type = svector<T>
 
using size_type = typename container_type::value_type
 
using self_type = xkeep_slice<T>
 
- Public Types inherited from xt::xslice< xkeep_slice< T > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class C>
+requires (!detail::is_xkeep_slice<std::decay_t<C>>::value)
 xkeep_slice (C &cont)
 
 xkeep_slice (container_type &&cont)
 
template<class S>
 xkeep_slice (std::initializer_list< S > t)
 
template<std::convertible_to< T > S>
 operator xkeep_slice< S > () const noexcept
 
template<std::convertible_to< T > S>
xkeep_slice< S > convert () const noexcept
 
size_type operator() (size_type i) const noexcept
 
size_type size () const noexcept
 
void normalize (std::size_t s)
 
size_type step_size (std::size_t i, std::size_t n=1) const noexcept
 
size_type revert_index (std::size_t i) const
 
bool contains (size_type i) const noexcept
 
bool operator== (const self_type &rhs) const noexcept
 
bool operator!= (const self_type &rhs) const noexcept
 
- Public Member Functions inherited from xt::xslice< xkeep_slice< T > >
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xslice< xkeep_slice< T > >
+ xslice (const xslice &)=default
 
+ xslice (xslice &&)=default
 
+xslice & operator= (const xslice &)=default
 
+xslice & operator= (xslice &&)=default
 
+

Detailed Description

+
template<class T>
+class xt::xkeep_slice< T >
+

Definition at line 323 of file xslice.hpp.

+

Member Typedef Documentation

+ +

◆ container_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xkeep_slice< T >::container_type = svector<T>
+
+ +

Definition at line 327 of file xslice.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xkeep_slice< T >::self_type = xkeep_slice<T>
+
+ +

Definition at line 329 of file xslice.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xkeep_slice< T >::size_type = typename container_type::value_type
+
+ +

Definition at line 328 of file xslice.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xkeep_slice() [1/3]

+ +
+
+
+template<class T>
+requires (!detail::is_xkeep_slice<std::decay_t<C>>::value)
+
+template<class C>
+requires (!detail::is_xkeep_slice<std::decay_t<C>>::value)
+ + + + + +
+ + + + + + + +
xt::xkeep_slice< T >::xkeep_slice (C & cont)
+ 		+inlineexplicit
+
+ +

Definition at line 1285 of file xslice.hpp.

+ +
+
+ +

◆ xkeep_slice() [2/3]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
xt::xkeep_slice< T >::xkeep_slice (container_type && cont)
+ 		+inlineexplicit
+
+ +

Definition at line 1292 of file xslice.hpp.

+ +
+
+ +

◆ xkeep_slice() [3/3]

+ +
+
+
+template<class T>
+
+template<class S>
+ + + + + +
+ + + + + + + +
xt::xkeep_slice< T >::xkeep_slice (std::initializer_list< S > t)
+ 		+inline
+
+ +

Definition at line 1299 of file xslice.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ contains()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xkeep_slice< T >::contains (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1406 of file xslice.hpp.

+ +
+
+ +

◆ convert()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xkeep_slice< S > xt::xkeep_slice< T >::convert () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1345 of file xslice.hpp.

+ +
+
+ +

◆ normalize()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xkeep_slice< T >::normalize (std::size_t s)
+ 		+inline
+
+ +

Definition at line 1351 of file xslice.hpp.

+ +
+
+ +

◆ operator xkeep_slice< S >()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xt::xkeep_slice< T >::operator xkeep_slice< S > () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1315 of file xslice.hpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xkeep_slice< T >::operator!= (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1418 of file xslice.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xkeep_slice< T >::operator() (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1363 of file xslice.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xkeep_slice< T >::operator== (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1412 of file xslice.hpp.

+ +
+
+ +

◆ revert_index()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xkeep_slice< T >::revert_index (std::size_t i) const
+ 		+inline
+
+ +

Definition at line 1392 of file xslice.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xkeep_slice< T >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1369 of file xslice.hpp.

+ +
+
+ +

◆ step_size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xkeep_slice< T >::step_size (std::size_t i,
std::size_t n = 1 ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1375 of file xslice.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xkeep_slice

+ +
+
+
+template<class T>
+
+template<class S>
+ + + + + +
+ + + + +
friend class xkeep_slice
+ 		+friend
+
+ +

Definition at line 368 of file xslice.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xslice.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xkeep__slice.png b/classxt_1_1xkeep__slice.png new file mode 100644 index 000000000..993db7ec5 Binary files /dev/null and b/classxt_1_1xkeep__slice.png differ diff --git a/classxt_1_1xmasked__value.html b/classxt_1_1xmasked__value.html new file mode 100644 index 000000000..d3084459c --- /dev/null +++ b/classxt_1_1xmasked__value.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xt::xmasked_value< T, B > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xmasked_value< T, B > Class Template Reference
+
+
+

Detailed Description

+
template<class T, class B>
+class xt::xmasked_value< T, B >
+

Definition at line 418 of file xmime.hpp.

+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xmime.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xmasked__view-members.html b/classxt_1_1xmasked__view-members.html new file mode 100644 index 000000000..1c323f9c8 --- /dev/null +++ b/classxt_1_1xmasked__view-members.html @@ -0,0 +1,302 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xmasked_view< CTD, CTM > Member List
+
+
+ +

This is the complete list of members for xt::xmasked_view< CTD, CTM >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
assign_temporary(temporary_type &&)xt::xview_semantic< xmasked_view< CTD, CTM > >
assign_temporary(temporary_type &&)xt::xview_semantic< xmasked_view< CTD, CTM > >inline
at(Args... args) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
at(Args... args) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
back()xt::xmasked_view< CTD, CTM >
back() constxt::xmasked_view< CTD, CTM >
backstrides() const noexceptxt::xmasked_view< CTD, CTM >inline
base_const_reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
base_reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
base_value_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
begin() noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
begin(const S &shape) noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
begin() const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
begin(const S &shape) const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
bit_and_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_or_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_xor_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bool_load_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
broadcast_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_broadcast_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_layout_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_pointer typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_reverse_broadcast_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_reverse_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_reverse_layout_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
const_stepper typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
contiguous_layout (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >static
data_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
difference_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
divides_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
element(It first, It last) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
element(It first, It last) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
element(It first, It last) -> referencext::xmasked_view< CTD, CTM >inline
element(It first, It last) const -> const_referencext::xmasked_view< CTD, CTM >inline
end() noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
end(const S &shape) noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
end() const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
end(const S &shape) const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
expression_tag typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
fill(const T &value)xt::xmasked_view< CTD, CTM >inline
flag_const_reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
flag_reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
flag_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
front()xt::xmasked_view< CTD, CTM >
front() constxt::xmasked_view< CTD, CTM >
has_linear_assign(const S &strides) const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
inner_backstrides_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
inner_shape_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
inner_strides_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
inner_types typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
is_contiguous() const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
is_data_const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >static
iterable_base typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
layout() const noexceptxt::xmasked_view< CTD, CTM >inline
layout_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
mask_expression typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
mask_reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
mask_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
minus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
modulus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
multiplies_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator%=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator&=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator()(Args... args) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator()(Args... args) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator()(Args... args) -> referencext::xmasked_view< CTD, CTM >inline
operator()(Args... args) const -> const_referencext::xmasked_view< CTD, CTM >inline
operator*=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator+=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator-=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator/=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator=(const self_type &rhs) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
operator=(const xexpression< E > &e) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator=(const E &e) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator=(const xexpression< E > &e) -> self_type & (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
operator=(const E &e) -> disable_xexpression< E, self_type > & (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
operator=(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator[](const S &index) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator[](std::initializer_list< I > index) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator[](size_type i) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator[](const S &index) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator[](std::initializer_list< I > index) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator[](size_type i) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
operator^=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator|=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
periodic(Args... args) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
periodic(Args... args) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
plus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
pointer typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rbegin() noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rbegin(const S &shape) noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rbegin() const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rbegin(const S &shape) const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rend() noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rend(const S &shape) noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rend() const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
rend(const S &shape) const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
reverse_broadcast_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
reverse_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
reverse_layout_iterator typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
self_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
semantic_base typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
shape() const noexceptxt::xmasked_view< CTD, CTM >inline
xt::xaccessible< xmasked_view< CTD, CTM > >::shape(size_type index) constxt::xconst_accessible< xmasked_view< CTD, CTM > >inlineprivate
shape_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
size() const noexceptxt::xmasked_view< CTD, CTM >inline
size_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
static_layout (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >static
stepper typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
stepper_begin(const S &shape) noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
stepper_begin(const S &shape) const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
stepper_end(const S &shape, layout_type l) noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
stepper_end(const S &shape, layout_type l) noexcept -> stepper (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >inline
strides() const noexceptxt::xmasked_view< CTD, CTM >inline
strides_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
temporary_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
unchecked(Args... args) (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
unchecked(Args... args) const (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
unchecked(Args... args) -> referencext::xmasked_view< CTD, CTM >inline
unchecked(Args... args) const -> const_referencext::xmasked_view< CTD, CTM >inline
val_reference typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
value() noexceptxt::xmasked_view< CTD, CTM >inline
value() const noexceptxt::xmasked_view< CTD, CTM >inline
value_expression typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
value_type typedef (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
visible() noexceptxt::xmasked_view< CTD, CTM >inline
visible() const noexceptxt::xmasked_view< CTD, CTM >inline
xaccessible< self_type > (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >friend
xconst_accessible< self_type > (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >friend
xconst_iterable< self_type > (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >friend
xiterable< self_type > (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >friend
xmasked_view(D &&data, M &&mask)xt::xmasked_view< CTD, CTM >inline
xmasked_view(const xmasked_view &)=default (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >
xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xview_semantic< self_type > (defined in xt::xmasked_view< CTD, CTM >)xt::xmasked_view< CTD, CTM >friend
~xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
+
+ + + + diff --git a/classxt_1_1xmasked__view.html b/classxt_1_1xmasked__view.html new file mode 100644 index 000000000..93c732de0 --- /dev/null +++ b/classxt_1_1xmasked__view.html @@ -0,0 +1,2804 @@ + + + + + + + +xtensor: xt::xmasked_view< CTD, CTM > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xmasked_view< CTD, CTM > Class Template Reference
+
+
+ +

View on an xoptional_assembly or xoptional_assembly_adaptor hiding values depending on a given mask. + More...

+ +

#include <xmasked_view.hpp>

+
+Inheritance diagram for xt::xmasked_view< CTD, CTM >:
+
+
+ + +xt::xview_semantic< xmasked_view< CTD, CTM > > +xt::xaccessible< xmasked_view< CTD, CTM > > +xt::xiterable< xmasked_view< CTD, CTM > > +xt::xsemantic_base< D > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xmasked_view<CTD, CTM>
 
using semantic_base = xview_semantic<xmasked_view<CTD, CTM>>
 
using accessible_base = xaccessible<self_type>
 
using inner_types = xcontainer_inner_types<self_type>
 
using temporary_type = typename inner_types::temporary_type
 
using data_type = typename inner_types::data_type
 
using mask_type = typename inner_types::mask_type
 
using value_expression = CTD
 
using mask_expression = CTM
 
using base_value_type = typename inner_types::base_value_type
 
using base_reference = typename data_type::reference
 
using base_const_reference = typename data_type::const_reference
 
using flag_type = typename inner_types::flag_type
 
using flag_reference = typename mask_type::reference
 
using flag_const_reference = typename mask_type::const_reference
 
using val_reference = typename inner_types::val_reference
 
using mask_reference = typename inner_types::mask_reference
 
using value_type = typename inner_types::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = xtl::xclosure_pointer<reference>
 
using const_pointer = xtl::xclosure_pointer<const_reference>
 
using size_type = typename inner_types::size_type
 
using difference_type = typename data_type::difference_type
 
using bool_load_type = xtl::xmasked_value<typename data_type::bool_load_type, mask_type>
 
using shape_type = typename data_type::shape_type
 
using strides_type = typename data_type::strides_type
 
using inner_shape_type = typename data_type::inner_shape_type
 
using inner_strides_type = typename data_type::inner_strides_type
 
using inner_backstrides_type = typename data_type::inner_backstrides_type
 
using expression_tag = xtensor_expression_tag
 
using iterable_base = xiterable<xmasked_view<CTD, CTM>>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
template<layout_type L>
using layout_iterator = typename iterable_base::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
 
using iterator = typename iterable_base::iterator
 
using const_iterator = typename iterable_base::const_iterator
 
using reverse_iterator = typename iterable_base::reverse_iterator
 
using const_reverse_iterator = typename iterable_base::const_reverse_iterator
 
- Public Types inherited from xt::xview_semantic< xmasked_view< CTD, CTM > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< D >
using base_type = select_expression_base_t<D>
 
using derived_type = typename base_type::derived_type
 
using temporary_type = typename xcontainer_inner_types<D>::temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xmasked_view (const xmasked_view &)=default
 
+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
reference element (It first, It last)
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class S>
stepper stepper_begin (const S &shape) noexcept
 
+template<class S>
stepper stepper_end (const S &shape, layout_type l) noexcept
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
+reference at (Args... args)
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+const_reference operator[] (size_type i) const
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+reference periodic (Args... args)
 
+const_reference periodic (Args... args) const
 
+layout_iterator< L > begin () noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+layout_iterator< L > end () noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rbegin () noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rend () noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
Constructors
template<class D, class M>
 xmasked_view (D &&data, M &&mask)
 Creates an xmasked_view, given the xoptional_assembly or xoptional_assembly_adaptor and the mask.
 
Size and shape
size_type size () const noexcept
 Returns the number of elements in the xmasked_view.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the xmasked_view.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the xmasked_view.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the xmasked_view.
 
layout_type layout () const noexcept
 Return the layout_type of the xmasked_view.
 
bool is_contiguous () const noexcept
 
template<class T>
void fill (const T &value)
 Fills the data with the given value.
 
- Public Member Functions inherited from xt::xview_semantic< xmasked_view< CTD, CTM > >
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< D >
+template<class E>
disable_xexpression< E, derived_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator^= (const E &)
 
+template<class E>
derived_type & operator+= (const xexpression< E > &)
 
+template<class E>
derived_type & operator-= (const xexpression< E > &)
 
+template<class E>
derived_type & operator*= (const xexpression< E > &)
 
+template<class E>
derived_type & operator/= (const xexpression< E > &)
 
+template<class E>
derived_type & operator%= (const xexpression< E > &)
 
+template<class E>
derived_type & operator&= (const xexpression< E > &)
 
+template<class E>
derived_type & operator|= (const xexpression< E > &)
 
+template<class E>
derived_type & operator^= (const xexpression< E > &)
 
+template<class E>
derived_type & assign (const xexpression< E > &)
 
+template<class E>
derived_type & plus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & minus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & multiplies_assign (const xexpression< E > &)
 
+template<class E>
derived_type & divides_assign (const xexpression< E > &)
 
+template<class E>
derived_type & modulus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_and_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_or_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_xor_assign (const xexpression< E > &)
 
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
template<class E>
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
template<class E>
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
template<class E>
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
template<class E>
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
template<class E>
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + +

+Static Public Attributes

static constexpr bool is_data_const = std::is_const<std::remove_reference_t<value_expression>>::value
 
static constexpr layout_type static_layout = data_type::static_layout
 
static constexpr bool contiguous_layout = false
 
+ + + + + + + + + + + +

+Friends

class xiterable< self_type >
 
class xconst_iterable< self_type >
 
class xview_semantic< self_type >
 
class xaccessible< self_type >
 
class xconst_accessible< self_type >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Data

template<class S>
bool has_linear_assign (const S &strides) const noexcept
 
data_type & value () noexcept
 Return an expression for the values of the xmasked_view.
 
const data_type & value () const noexcept
 Return a constant expression for the values of the xmasked_view.
 
mask_type & visible () noexcept
 Return an expression for the mask of the xmasked_view.
 
const mask_type & visible () const noexcept
 Return a constant expression for the mask of the xmasked_view.
 
self_type & operator= (const self_type &rhs)
 
template<class... Args>
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the xmasked_view.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the xmasked_view.
 
template<class... Args>
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the xmasked_view.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the xmasked_view.
 
template<class It>
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the xmasked_view.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the xmasked_view.
 
template<class S>
auto stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type > &
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xview_semantic< xmasked_view< CTD, CTM > >
+ xview_semantic (const xview_semantic &)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+ xview_semantic (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< D >
+ xsemantic_base (const xsemantic_base &)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class CTD, class CTM>
+class xt::xmasked_view< CTD, CTM >

View on an xoptional_assembly or xoptional_assembly_adaptor hiding values depending on a given mask.

+

The xmasked_view class implements a view on an xoptional_assembly or xoptional_assembly_adaptor, it takes this xoptional_assembly and a mask as input. The mask is an xexpression containing boolean values, whenever the value of the mask is false, the optional value of xmasked_view is considered missing, otherwise it depends on the underlying xoptional_assembly.

+
Template Parameters
+ + + +
CTDThe type of expression holding the values.
CTMThe type of expression holding the mask.
+
+
+ +

Definition at line 78 of file xmasked_view.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::accessible_base = xaccessible<self_type>
+
+ +

Definition at line 86 of file xmasked_view.hpp.

+ +
+
+ +

◆ base_const_reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::base_const_reference = typename data_type::const_reference
+
+ +

Definition at line 99 of file xmasked_view.hpp.

+ +
+
+ +

◆ base_reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::base_reference = typename data_type::reference
+
+ +

Definition at line 98 of file xmasked_view.hpp.

+ +
+
+ +

◆ base_value_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::base_value_type = typename inner_types::base_value_type
+
+ +

Definition at line 97 of file xmasked_view.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::bool_load_type = xtl::xmasked_value<typename data_type::bool_load_type, mask_type>
+
+ +

Definition at line 118 of file xmasked_view.hpp.

+ +
+
+ +

◆ broadcast_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S, layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
+
+ +

Definition at line 146 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S, layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
+
+ +

Definition at line 148 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_iterator = typename iterable_base::const_iterator
+
+ +

Definition at line 155 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
+
+ +

Definition at line 139 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_pointer = xtl::xclosure_pointer<const_reference>
+
+ +

Definition at line 113 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 110 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S, layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 152 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_reverse_iterator = typename iterable_base::const_reverse_iterator
+
+ +

Definition at line 157 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
+
+ +

Definition at line 143 of file xmasked_view.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 134 of file xmasked_view.hpp.

+ +
+
+ +

◆ data_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::data_type = typename inner_types::data_type
+
+ +

Definition at line 90 of file xmasked_view.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::difference_type = typename data_type::difference_type
+
+ +

Definition at line 116 of file xmasked_view.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::expression_tag = xtensor_expression_tag
+
+ +

Definition at line 130 of file xmasked_view.hpp.

+ +
+
+ +

◆ flag_const_reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::flag_const_reference = typename mask_type::const_reference
+
+ +

Definition at line 103 of file xmasked_view.hpp.

+ +
+
+ +

◆ flag_reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::flag_reference = typename mask_type::reference
+
+ +

Definition at line 102 of file xmasked_view.hpp.

+ +
+
+ +

◆ flag_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::flag_type = typename inner_types::flag_type
+
+ +

Definition at line 101 of file xmasked_view.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::inner_backstrides_type = typename data_type::inner_backstrides_type
+
+ +

Definition at line 128 of file xmasked_view.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::inner_shape_type = typename data_type::inner_shape_type
+
+ +

Definition at line 126 of file xmasked_view.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::inner_strides_type = typename data_type::inner_strides_type
+
+ +

Definition at line 127 of file xmasked_view.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 87 of file xmasked_view.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::iterable_base = xiterable<xmasked_view<CTD, CTM>>
+
+ +

Definition at line 132 of file xmasked_view.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::iterator = typename iterable_base::iterator
+
+ +

Definition at line 154 of file xmasked_view.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::layout_iterator = typename iterable_base::template layout_iterator<L>
+
+ +

Definition at line 137 of file xmasked_view.hpp.

+ +
+
+ +

◆ mask_expression

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::mask_expression = CTM
+
+ +

Definition at line 93 of file xmasked_view.hpp.

+ +
+
+ +

◆ mask_reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::mask_reference = typename inner_types::mask_reference
+
+ +

Definition at line 106 of file xmasked_view.hpp.

+ +
+
+ +

◆ mask_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::mask_type = typename inner_types::mask_type
+
+ +

Definition at line 91 of file xmasked_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::pointer = xtl::xclosure_pointer<reference>
+
+ +

Definition at line 112 of file xmasked_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::reference = typename inner_types::reference
+
+ +

Definition at line 109 of file xmasked_view.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S, layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 150 of file xmasked_view.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::reverse_iterator = typename iterable_base::reverse_iterator
+
+ +

Definition at line 156 of file xmasked_view.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class CTD, class CTM>
+
+template<layout_type L>
+ + + + +
using xt::xmasked_view< CTD, CTM >::reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
+
+ +

Definition at line 141 of file xmasked_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::self_type = xmasked_view<CTD, CTM>
+
+ +

Definition at line 84 of file xmasked_view.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::semantic_base = xview_semantic<xmasked_view<CTD, CTM>>
+
+ +

Definition at line 85 of file xmasked_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::shape_type = typename data_type::shape_type
+
+ +

Definition at line 120 of file xmasked_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::size_type = typename inner_types::size_type
+
+ +

Definition at line 115 of file xmasked_view.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 133 of file xmasked_view.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::strides_type = typename data_type::strides_type
+
+ +

Definition at line 121 of file xmasked_view.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::temporary_type = typename inner_types::temporary_type
+
+ +

Definition at line 88 of file xmasked_view.hpp.

+ +
+
+ +

◆ val_reference

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::val_reference = typename inner_types::val_reference
+
+ +

Definition at line 105 of file xmasked_view.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::value_expression = CTD
+
+ +

Definition at line 92 of file xmasked_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CTD, class CTM>
+ + + + +
using xt::xmasked_view< CTD, CTM >::value_type = typename inner_types::value_type
+
+ +

Definition at line 108 of file xmasked_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xmasked_view()

+ +
+
+
+template<class CTD, class CTM>
+
+template<class D, class M>
+ + + + + +
+ + + + + + + + + + + +
xt::xmasked_view< CTD, CTM >::xmasked_view (D && data,
M && mask )
+ 		+inline
+
+ +

Creates an xmasked_view, given the xoptional_assembly or xoptional_assembly_adaptor and the mask.

+
Parameters
+ + + +
datathe underlying xoptional_assembly or xoptional_assembly_adaptor
maskthe mask.
+
+
+ +

Definition at line 309 of file xmasked_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ backstrides()

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::backstrides () const
+ 		+inlinenoexcept
+
+ +

Returns the backstrides of the xmasked_view.

+ +

Definition at line 350 of file xmasked_view.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xmasked_view< CTD, CTM >::element (It first,
It last ) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the xmasked_view.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the xmasked_view.
+
+
+ +

Definition at line 475 of file xmasked_view.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xmasked_view< CTD, CTM >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the xmasked_view.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the xmasked_view.
+
+
+ +

Definition at line 489 of file xmasked_view.hpp.

+ +
+
+ +

◆ fill()

+ +
+
+
+template<class CTD, class CTM>
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xmasked_view< CTD, CTM >::fill (const T & value)
+ 		+inline
+
+ +

Fills the data with the given value.

+
Parameters
+ + +
valuethe value to fill the data with.
+
+
+ +

Definition at line 379 of file xmasked_view.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xmasked_view< CTD, CTM >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Definition at line 498 of file xmasked_view.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
bool xt::xmasked_view< CTD, CTM >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 368 of file xmasked_view.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
layout_type xt::xmasked_view< CTD, CTM >::layout () const
+ 		+inlinenoexcept
+
+ +

Return the layout_type of the xmasked_view.

+
Returns
layout_type of the xmasked_view
+ +

Definition at line 362 of file xmasked_view.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::operator() (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the xmasked_view.

+
Parameters
+ + +
argsa list of indices specifying the position in the xmasked_view. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the xmasked_view.
+
+
+ +

Definition at line 396 of file xmasked_view.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the xmasked_view.

+
Parameters
+ + +
argsa list of indices specifying the position in the xmasked_view. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the xmasked_view.
+
+
+ +

Definition at line 409 of file xmasked_view.hpp.

+ +
+
+ +

◆ operator=() [1/3]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::operator= (const E & e) -> disable_xexpression<E, self_type>& +
+ 		+inline
+
+ +

Definition at line 584 of file xmasked_view.hpp.

+ +
+
+ +

◆ operator=() [2/3]

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::operator= (const self_type & rhs)
+ 		+inline
+
+ +

Definition at line 569 of file xmasked_view.hpp.

+ +
+
+ +

◆ operator=() [3/3]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

Definition at line 577 of file xmasked_view.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the xmasked_view.

+ +

Definition at line 332 of file xmasked_view.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::size () const
+ 		+inlinenoexcept
+
+ +

Returns the number of elements in the xmasked_view.

+ +

Definition at line 323 of file xmasked_view.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 555 of file xmasked_view.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::stepper_begin (const S & shape) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 541 of file xmasked_view.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xmasked_view< CTD, CTM >::stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 562 of file xmasked_view.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xmasked_view< CTD, CTM >::stepper_end (const S & shape,
layout_type l ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 548 of file xmasked_view.hpp.

+ +
+
+ +

◆ strides()

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::strides () const
+ 		+inlinenoexcept
+
+ +

Returns the strides of the xmasked_view.

+ +

Definition at line 341 of file xmasked_view.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::unchecked (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the xmasked_view.

+
Parameters
+ + +
argsa list of indices specifying the position in the xmasked_view. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the xmasked_view, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 435 of file xmasked_view.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class CTD, class CTM>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the xmasked_view.

+
Parameters
+ + +
argsa list of indices specifying the position in the xmasked_view. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the xmasked_view, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
+ +

Definition at line 461 of file xmasked_view.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::value () const
+ 		+inlinenoexcept
+
+ +

Return a constant expression for the values of the xmasked_view.

+ +

Definition at line 516 of file xmasked_view.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::value ()
+ 		+inlinenoexcept
+
+ +

Return an expression for the values of the xmasked_view.

+ +

Definition at line 507 of file xmasked_view.hpp.

+ +
+
+ +

◆ visible() [1/2]

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::visible () const
+ 		+inlinenoexcept
+
+ +

Return a constant expression for the mask of the xmasked_view.

+ +

Definition at line 534 of file xmasked_view.hpp.

+ +
+
+ +

◆ visible() [2/2]

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view< CTD, CTM >::visible ()
+ 		+inlinenoexcept
+
+ +

Return an expression for the mask of the xmasked_view.

+ +

Definition at line 525 of file xmasked_view.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< self_type >

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
friend class xaccessible< self_type >
+ 		+friend
+
+ +

Definition at line 243 of file xmasked_view.hpp.

+ +
+
+ +

◆ xconst_accessible< self_type >

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
friend class xconst_accessible< self_type >
+ 		+friend
+
+ +

Definition at line 243 of file xmasked_view.hpp.

+ +
+
+ +

◆ xconst_iterable< self_type >

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
friend class xconst_iterable< self_type >
+ 		+friend
+
+ +

Definition at line 243 of file xmasked_view.hpp.

+ +
+
+ +

◆ xiterable< self_type >

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
friend class xiterable< self_type >
+ 		+friend
+
+ +

Definition at line 243 of file xmasked_view.hpp.

+ +
+
+ +

◆ xview_semantic< self_type >

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
friend class xview_semantic< self_type >
+ 		+friend
+
+ +

Definition at line 243 of file xmasked_view.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
bool xt::xmasked_view< CTD, CTM >::contiguous_layout = false
+ 		+staticconstexpr
+
+ +

Definition at line 124 of file xmasked_view.hpp.

+ +
+
+ +

◆ is_data_const

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
bool xt::xmasked_view< CTD, CTM >::is_data_const = std::is_const<std::remove_reference_t<value_expression>>::value
+ 		+staticconstexpr
+
+ +

Definition at line 95 of file xmasked_view.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CTD, class CTM>
+ + + + + +
+ + + + +
layout_type xt::xmasked_view< CTD, CTM >::static_layout = data_type::static_layout
+ 		+staticconstexpr
+
+ +

Definition at line 123 of file xmasked_view.hpp.

+ +
+
+
The documentation for this class was generated from the following files:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xmime.hpp
    • +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xmasked_view.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xmasked__view.js b/classxt_1_1xmasked__view.js new file mode 100644 index 000000000..285959548 --- /dev/null +++ b/classxt_1_1xmasked__view.js @@ -0,0 +1,24 @@ +var classxt_1_1xmasked__view = +[ + [ "xmasked_view", "classxt_1_1xmasked__view.html#a9c3d8a13f687279e628800050a8d4048", null ], + [ "back", "classxt_1_1xmasked__view.html#a13a096e0045b2375006fec3bcd1c8d1c", null ], + [ "back", "classxt_1_1xmasked__view.html#a37c6719faba4d4aa425d0e5302482e99", null ], + [ "backstrides", "classxt_1_1xmasked__view.html#a11f6663bf33dc7e1afbce7f6132e58fe", null ], + [ "element", "classxt_1_1xmasked__view.html#a9ac6b54e4c97bd60b65a6c02d5823380", null ], + [ "element", "classxt_1_1xmasked__view.html#ae44c90a8ceb326570ea97116ecc5dd2f", null ], + [ "fill", "classxt_1_1xmasked__view.html#a4c949ee680c72512a1d9f02b60536428", null ], + [ "front", "classxt_1_1xmasked__view.html#a13ab25eb31d4b48cb01b7bc38d27e8e0", null ], + [ "front", "classxt_1_1xmasked__view.html#a2ba0b92d6fbdb39b879378eb72c285d4", null ], + [ "layout", "classxt_1_1xmasked__view.html#a7f160d16d17eea921739b9ff1457c374", null ], + [ "operator()", "classxt_1_1xmasked__view.html#a871b0392cccaac8fb981273bb5008186", null ], + [ "operator()", "classxt_1_1xmasked__view.html#a7cd2236961bba48f19933c8450052790", null ], + [ "shape", "classxt_1_1xmasked__view.html#a3e501b72ae46be33e45dd249ac6e369c", null ], + [ "size", "classxt_1_1xmasked__view.html#a9b8f0d6d6f4fd32f161ffbae9828a7e2", null ], + [ "strides", "classxt_1_1xmasked__view.html#a0cc1342c4e640acb9f726ccbb1a74da7", null ], + [ "unchecked", "classxt_1_1xmasked__view.html#a1f080554ead02ec72ee2e53691b2d793", null ], + [ "unchecked", "classxt_1_1xmasked__view.html#a430cf3c34d4e7ac88d55522fcef881ff", null ], + [ "value", "classxt_1_1xmasked__view.html#a8c5a06d1b2b6f5aa3f08ac36dc6956f8", null ], + [ "value", "classxt_1_1xmasked__view.html#a888a7481ce4e40148e55a280dd2d721e", null ], + [ "visible", "classxt_1_1xmasked__view.html#ae0e58b3d80d80523a86ee38b97550c68", null ], + [ "visible", "classxt_1_1xmasked__view.html#a420f33aa357210c322d5d34f06c6b81e", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xmasked__view.png b/classxt_1_1xmasked__view.png new file mode 100644 index 000000000..f6fc2602b Binary files /dev/null and b/classxt_1_1xmasked__view.png differ diff --git a/classxt_1_1xmasked__view__stepper-members.html b/classxt_1_1xmasked__view__stepper-members.html new file mode 100644 index 000000000..09e1a50e9 --- /dev/null +++ b/classxt_1_1xmasked__view__stepper-members.html @@ -0,0 +1,141 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xmasked_view_stepper< D, is_const > Member List
+
+
+ +

This is the complete list of members for xt::xmasked_view_stepper< D, is_const >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + +
data_type typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
difference_type typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
mask_stepper typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
mask_type typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
masked_view_type typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
operator*() const (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
pointer typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
reference typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
reset(size_type dim) (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
reset_back(size_type dim) (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
self_type typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
size_type typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
step(size_type dim) (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
step(size_type dim, size_type n) (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
step_back(size_type dim) (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
step_back(size_type dim, size_type n) (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
to_begin() (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
to_end(layout_type l) (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
value_stepper typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
value_type typedef (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >
xmasked_view_stepper(value_stepper vs, mask_stepper fs) noexcept (defined in xt::xmasked_view_stepper< D, is_const >)xt::xmasked_view_stepper< D, is_const >inline
+
+ + + + diff --git a/classxt_1_1xmasked__view__stepper.html b/classxt_1_1xmasked__view__stepper.html new file mode 100644 index 000000000..b8656fe26 --- /dev/null +++ b/classxt_1_1xmasked__view__stepper.html @@ -0,0 +1,685 @@ + + + + + + + +xtensor: xt::xmasked_view_stepper< D, is_const > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xmasked_view_stepper< D, is_const > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xmasked_view_stepper<D, is_const>
 
using masked_view_type = std::decay_t<D>
 
using value_type = typename masked_view_type::value_type
 
using reference
 
using pointer
 
using size_type = typename masked_view_type::size_type
 
using difference_type = typename masked_view_type::difference_type
 
using data_type = typename masked_view_type::data_type
 
using mask_type = typename masked_view_type::mask_type
 
using value_stepper = std::conditional_t<is_const, typename data_type::const_stepper, typename data_type::stepper>
 
using mask_stepper = std::conditional_t<is_const, typename mask_type::const_stepper, typename mask_type::stepper>
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Data
 xmasked_view_stepper (value_stepper vs, mask_stepper fs) noexcept
 
void step (size_type dim)
 
void step_back (size_type dim)
 
void step (size_type dim, size_type n)
 
void step_back (size_type dim, size_type n)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
reference operator* () const
 
+

Detailed Description

+
template<class D, bool is_const>
+class xt::xmasked_view_stepper< D, is_const >
+

Definition at line 253 of file xmasked_view.hpp.

+

Member Typedef Documentation

+ +

◆ data_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::data_type = typename masked_view_type::data_type
+
+ +

Definition at line 266 of file xmasked_view.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::difference_type = typename masked_view_type::difference_type
+
+ +

Definition at line 265 of file xmasked_view.hpp.

+ +
+
+ +

◆ mask_stepper

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::mask_stepper = std::conditional_t<is_const, typename mask_type::const_stepper, typename mask_type::stepper>
+
+ +

Definition at line 269 of file xmasked_view.hpp.

+ +
+
+ +

◆ mask_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::mask_type = typename masked_view_type::mask_type
+
+ +

Definition at line 267 of file xmasked_view.hpp.

+ +
+
+ +

◆ masked_view_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::masked_view_type = std::decay_t<D>
+
+ +

Definition at line 258 of file xmasked_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::pointer
+
+Initial value:
std::
+
conditional_t<is_const, typename masked_view_type::const_pointer, typename masked_view_type::pointer>
+
+

Definition at line 262 of file xmasked_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::reference
+
+Initial value:
std::
+
conditional_t<is_const, typename masked_view_type::const_reference, typename masked_view_type::reference>
+
+

Definition at line 260 of file xmasked_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::self_type = xmasked_view_stepper<D, is_const>
+
+ +

Definition at line 257 of file xmasked_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::size_type = typename masked_view_type::size_type
+
+ +

Definition at line 264 of file xmasked_view.hpp.

+ +
+
+ +

◆ value_stepper

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::value_stepper = std::conditional_t<is_const, typename data_type::const_stepper, typename data_type::stepper>
+
+ +

Definition at line 268 of file xmasked_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xmasked_view_stepper< D, is_const >::value_type = typename masked_view_type::value_type
+
+ +

Definition at line 259 of file xmasked_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xmasked_view_stepper()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + + + + + +
xt::xmasked_view_stepper< D, C >::xmasked_view_stepper (value_stepper vs,
mask_stepper fs )
+ 		+inlinenoexcept
+
+ +

Definition at line 607 of file xmasked_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xmasked_view_stepper< D, C >::operator* () const
+ 		+inline
+
+ +

Definition at line 670 of file xmasked_view.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xmasked_view_stepper< D, C >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 642 of file xmasked_view.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xmasked_view_stepper< D, C >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 649 of file xmasked_view.hpp.

+ +
+
+ +

◆ step() [1/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xmasked_view_stepper< D, C >::step (size_type dim)
+ 		+inline
+
+ +

Definition at line 614 of file xmasked_view.hpp.

+ +
+
+ +

◆ step() [2/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + + + + + +
void xt::xmasked_view_stepper< D, C >::step (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 628 of file xmasked_view.hpp.

+ +
+
+ +

◆ step_back() [1/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xmasked_view_stepper< D, C >::step_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 621 of file xmasked_view.hpp.

+ +
+
+ +

◆ step_back() [2/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + + + + + +
void xt::xmasked_view_stepper< D, C >::step_back (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 635 of file xmasked_view.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xmasked_view_stepper< D, C >::to_begin ()
+ 		+inline
+
+ +

Definition at line 656 of file xmasked_view.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xmasked_view_stepper< D, C >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 663 of file xmasked_view.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xmultiindex__iterator-members.html b/classxt_1_1xmultiindex__iterator-members.html new file mode 100644 index 000000000..0dc4defa9 --- /dev/null +++ b/classxt_1_1xmultiindex__iterator-members.html @@ -0,0 +1,135 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xmultiindex_iterator< S > Member List
+
+
+ +

This is the complete list of members for xt::xmultiindex_iterator< S >, including all inherited members.

+ + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
iterator_category typedef (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
operator!=(const self_type &rhs) const (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >inline
operator*() (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >inline
operator*() const (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >inline
operator++() (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >inline
operator++(int) (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >inline
operator==(const self_type &rhs) const (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >inline
pointer typedef (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
reference typedef (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
self_type typedef (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
shape_type typedef (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
value_type typedef (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
xmultiindex_iterator()=default (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >
xmultiindex_iterator(B &&begin, E &&end, C &&current, const std::size_t linear_index) (defined in xt::xmultiindex_iterator< S >)xt::xmultiindex_iterator< S >inline
+
+ + + + diff --git a/classxt_1_1xmultiindex__iterator.html b/classxt_1_1xmultiindex__iterator.html new file mode 100644 index 000000000..8f3579be0 --- /dev/null +++ b/classxt_1_1xmultiindex__iterator.html @@ -0,0 +1,513 @@ + + + + + + + +xtensor: xt::xmultiindex_iterator< S > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xmultiindex_iterator< S > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + +

+Public Types

using self_type = xmultiindex_iterator<S>
 
using shape_type = S
 
using value_type = shape_type
 
using reference = value_type&
 
using pointer = value_type*
 
using difference_type = std::size_t
 
using iterator_category = std::forward_iterator_tag
 
+ + + + + + + + + + + + + + + + +

+Public Member Functions

template<class B, class E, class C>
 xmultiindex_iterator (B &&begin, E &&end, C &&current, const std::size_t linear_index)
 
self_type & operator++ ()
 
self_type operator++ (int)
 
shape_type & operator* ()
 
const shape_type & operator* () const
 
bool operator== (const self_type &rhs) const
 
bool operator!= (const self_type &rhs) const
 
+

Detailed Description

+
template<class S>
+class xt::xmultiindex_iterator< S >
+

Definition at line 20 of file xmultiindex_iterator.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class S>
+ + + + +
using xt::xmultiindex_iterator< S >::difference_type = std::size_t
+
+ +

Definition at line 30 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ iterator_category

+ +
+
+
+template<class S>
+ + + + +
using xt::xmultiindex_iterator< S >::iterator_category = std::forward_iterator_tag
+
+ +

Definition at line 31 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class S>
+ + + + +
using xt::xmultiindex_iterator< S >::pointer = value_type*
+
+ +

Definition at line 29 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class S>
+ + + + +
using xt::xmultiindex_iterator< S >::reference = value_type&
+
+ +

Definition at line 28 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class S>
+ + + + +
using xt::xmultiindex_iterator< S >::self_type = xmultiindex_iterator<S>
+
+ +

Definition at line 24 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class S>
+ + + + +
using xt::xmultiindex_iterator< S >::shape_type = S
+
+ +

Definition at line 25 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class S>
+ + + + +
using xt::xmultiindex_iterator< S >::value_type = shape_type
+
+ +

Definition at line 27 of file xmultiindex_iterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xmultiindex_iterator()

+ +
+
+
+template<class S>
+
+template<class B, class E, class C>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xmultiindex_iterator< S >::xmultiindex_iterator (B && begin,
E && end,
C && current,
const std::size_t linear_index )
+ 		+inline
+
+ +

Definition at line 36 of file xmultiindex_iterator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator!=()

+ +
+
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xmultiindex_iterator< S >::operator!= (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 86 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ operator*() [1/2]

+ +
+
+
+template<class S>
+ + + + + +
+ + + + + + + +
shape_type & xt::xmultiindex_iterator< S >::operator* ()
+ 		+inline
+
+ +

Definition at line 71 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ operator*() [2/2]

+ +
+
+
+template<class S>
+ + + + + +
+ + + + + + + +
const shape_type & xt::xmultiindex_iterator< S >::operator* () const
+ 		+inline
+
+ +

Definition at line 76 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ operator++() [1/2]

+ +
+
+
+template<class S>
+ + + + + +
+ + + + + + + +
self_type & xt::xmultiindex_iterator< S >::operator++ ()
+ 		+inline
+
+ +

Definition at line 44 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ operator++() [2/2]

+ +
+
+
+template<class S>
+ + + + + +
+ + + + + + + +
self_type xt::xmultiindex_iterator< S >::operator++ (int )
+ 		+inline
+
+ +

Definition at line 64 of file xmultiindex_iterator.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xmultiindex_iterator< S >::operator== (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 81 of file xmultiindex_iterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xnewaxis-members.html b/classxt_1_1xnewaxis-members.html new file mode 100644 index 000000000..5c2b10690 --- /dev/null +++ b/classxt_1_1xnewaxis-members.html @@ -0,0 +1,133 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xnewaxis< T > Member List
+
+
+ +

This is the complete list of members for xt::xnewaxis< T >, including all inherited members.

+ + + + + + + + + + + + + + +
contains(size_type i) const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
convert() const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
operator xnewaxis< S >() const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
operator!=(const self_type &rhs) const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
operator()(size_type i) const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
operator==(const self_type &rhs) const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
revert_index(std::size_t i) const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
self_type typedef (defined in xt::xnewaxis< T >)xt::xnewaxis< T >
size() const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
size_type typedef (defined in xt::xnewaxis< T >)xt::xnewaxis< T >
step_size() const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
step_size(std::size_t i, std::size_t n=1) const noexcept (defined in xt::xnewaxis< T >)xt::xnewaxis< T >inline
xnewaxis()=default (defined in xt::xnewaxis< T >)xt::xnewaxis< T >
+
+ + + + diff --git a/classxt_1_1xnewaxis.html b/classxt_1_1xnewaxis.html new file mode 100644 index 000000000..6aa2a59d7 --- /dev/null +++ b/classxt_1_1xnewaxis.html @@ -0,0 +1,531 @@ + + + + + + + +xtensor: xt::xnewaxis< T > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xnewaxis< T > Class Template Reference
+
+
+
+Inheritance diagram for xt::xnewaxis< T >:
+
+
+ + +xt::xslice< xnewaxis< T > > + +
+ + + + + + + + + +

+Public Types

using size_type = T
 
using self_type = xnewaxis<T>
 
- Public Types inherited from xt::xslice< xnewaxis< T > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<std::convertible_to< T > S>
 operator xnewaxis< S > () const noexcept
 
template<std::convertible_to< T > S>
xnewaxis< S > convert () const noexcept
 
size_type operator() (size_type i) const noexcept
 
size_type size () const noexcept
 
size_type step_size () const noexcept
 
size_type step_size (std::size_t i, std::size_t n=1) const noexcept
 
size_type revert_index (std::size_t i) const noexcept
 
bool contains (size_type i) const noexcept
 
bool operator== (const self_type &rhs) const noexcept
 
bool operator!= (const self_type &rhs) const noexcept
 
- Public Member Functions inherited from xt::xslice< xnewaxis< T > >
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xslice< xnewaxis< T > >
+ xslice (const xslice &)=default
 
+ xslice (xslice &&)=default
 
+xslice & operator= (const xslice &)=default
 
+xslice & operator= (xslice &&)=default
 
+

Detailed Description

+
template<class T>
+class xt::xnewaxis< T >
+

Definition at line 262 of file xslice.hpp.

+

Member Typedef Documentation

+ +

◆ self_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xnewaxis< T >::self_type = xnewaxis<T>
+
+ +

Definition at line 267 of file xslice.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xnewaxis< T >::size_type = T
+
+ +

Definition at line 266 of file xslice.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ contains()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xnewaxis< T >::contains (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1262 of file xslice.hpp.

+ +
+
+ +

◆ convert()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xnewaxis< S > xt::xnewaxis< T >::convert () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1226 of file xslice.hpp.

+ +
+
+ +

◆ operator xnewaxis< S >()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xt::xnewaxis< T >::operator xnewaxis< S > () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1219 of file xslice.hpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xnewaxis< T >::operator!= (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1274 of file xslice.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xnewaxis< T >::operator() (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1232 of file xslice.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xnewaxis< T >::operator== (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1268 of file xslice.hpp.

+ +
+
+ +

◆ revert_index()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xnewaxis< T >::revert_index (std::size_t i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1256 of file xslice.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xnewaxis< T >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1238 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [1/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xnewaxis< T >::step_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1244 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [2/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xnewaxis< T >::step_size (std::size_t i,
std::size_t n = 1 ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1250 of file xslice.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xslice.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xnewaxis.png b/classxt_1_1xnewaxis.png new file mode 100644 index 000000000..313a92357 Binary files /dev/null and b/classxt_1_1xnewaxis.png differ diff --git a/classxt_1_1xoptional__assembly-members.html b/classxt_1_1xoptional__assembly-members.html new file mode 100644 index 000000000..74e989cc7 --- /dev/null +++ b/classxt_1_1xoptional__assembly-members.html @@ -0,0 +1,263 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xoptional_assembly< VE, FE > Member List
+
+
+ +

This is the complete list of members for xt::xoptional_assembly< VE, FE >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assembly_type typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xoptional_assembly< VE, FE > >inline
at(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
at(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
at(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
at(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
back()xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
back() constxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
backstrides() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
base_type typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
const_flag_expression typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
const_pointer typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
const_reference typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
const_value_expression typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
dimension() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
element(It first, It last) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
element(It first, It last) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
element(It first, It last) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
element(It first, It last) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
fill(const T &value)xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
flag_expression typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
flat(size_type args)xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
flat(size_type args) constxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
from_shape(S &&s) (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >static
from_shape(S &&s)xt::xoptional_assembly< VE, FE >inline
front()xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
front() constxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
has_linear_assign(const S &strides) const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
has_value() noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
has_value() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
in_bounds(Args... args) constxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
layout() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator()(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator()(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator()(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator()(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator=(const xoptional_assembly &) (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >inline
operator=(xoptional_assembly &&) (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >inline
operator=(const xexpression< E > &e) (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
operator=(const xexpression< E > &e) -> self_type &xt::xoptional_assembly< VE, FE >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
periodic(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
periodic(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
periodic(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
periodic(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly< VE, FE > >inline
pointer typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
raw_flag_expression typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
raw_value_expression typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
reference typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
reshape(const S &shape, layout_type layout=static_layout) &xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
resize(const S &shape, bool force=false)xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
resize(const S &shape, layout_type l)xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
resize(const S &shape, const strides_type &strides)xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
self_type typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
semantic_base typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
shape() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
shape(size_type index) constxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
shape_type typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
size() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
storage_type typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
strides() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
strides_type typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
unchecked(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
unchecked(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
unchecked(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
unchecked(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
value() noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
value() const noexceptxt::xoptional_assembly_base< xoptional_assembly< VE, FE > >inline
value_expression typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
value_type typedef (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
xoptional_assembly()xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(const shape_type &shape, layout_type l=base_type::static_layout)xt::xoptional_assembly< VE, FE >inlineexplicit
xoptional_assembly(const shape_type &shape, const value_type &value, layout_type l=base_type::static_layout)xt::xoptional_assembly< VE, FE >inlineexplicit
xoptional_assembly(const shape_type &shape, const strides_type &strides)xt::xoptional_assembly< VE, FE >inlineexplicit
xoptional_assembly(const shape_type &shape, const strides_type &strides, const value_type &value)xt::xoptional_assembly< VE, FE >inlineexplicit
xoptional_assembly(const VE &ve)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(VE &&ve)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(OVE &&ove, OFE &&ofe)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(const value_type &value)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(nested_initializer_list_t< value_type, 1 > t)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(nested_initializer_list_t< value_type, 2 > t)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(nested_initializer_list_t< value_type, 3 > t)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(nested_initializer_list_t< value_type, 4 > t)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(nested_initializer_list_t< value_type, 5 > t)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(const xoptional_assembly &) (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(xoptional_assembly &&) (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly(const xexpression< E > &e)xt::xoptional_assembly< VE, FE >inline
xoptional_assembly_base< xoptional_assembly< VE, FE > > (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >friend
~xoptional_assembly()=default (defined in xt::xoptional_assembly< VE, FE >)xt::xoptional_assembly< VE, FE >
+
+ + + + diff --git a/classxt_1_1xoptional__assembly.html b/classxt_1_1xoptional__assembly.html new file mode 100644 index 000000000..46cf9a18e --- /dev/null +++ b/classxt_1_1xoptional__assembly.html @@ -0,0 +1,2204 @@ + + + + + + + +xtensor: xt::xoptional_assembly< VE, FE > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +Friends | +List of all members
+
xt::xoptional_assembly< VE, FE > Class Template Reference
+
+
+ +

Dense multidimensional container holding optional values, optimized for tensor operations. + More...

+ +

#include <xoptional_assembly.hpp>

+
+Inheritance diagram for xt::xoptional_assembly< VE, FE >:
+
+
+ + +xt::xoptional_assembly_base< xoptional_assembly< VE, FE > > +xt::xcontainer_semantic< xoptional_assembly< VE, FE > > +xt::xiterable< xoptional_assembly< VE, FE > > +xt::xsemantic_base< xoptional_assembly< VE, FE > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xoptional_assembly<VE, FE>
 
using base_type = xoptional_assembly_base<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using raw_value_expression = typename base_type::raw_value_expression
 
using raw_flag_expression = typename base_type::raw_flag_expression
 
using value_expression = typename base_type::value_expression
 
using flag_expression = typename base_type::flag_expression
 
using const_value_expression = typename base_type::const_value_expression
 
using const_flag_expression = typename base_type::const_flag_expression
 
using storage_type = typename base_type::storage_type
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using assembly_type = base_type
 
- Public Types inherited from xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >
using self_type
 
using derived_type
 
using inner_types
 
using raw_value_expression
 
using base_value_type
 
using base_reference
 
using base_const_reference
 
using raw_flag_expression
 
using flag_type
 
using flag_reference
 
using flag_const_reference
 
using storage_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using expression_tag
 
using value_expression
 
using flag_expression
 
using const_value_expression
 
using const_flag_expression
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xoptional_assembly< VE, FE > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xoptional_assembly< VE, FE > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
xoptional_assembly & operator= (const xexpression< E > &e)
 
Constructors
 xoptional_assembly ()
 Allocates an uninitialized xoptional_assembly that holds 0 element.
 
 xoptional_assembly (const shape_type &shape, layout_type l=base_type::static_layout)
 Allocates an uninitialized xoptional_assembly with the specified shape and layout_type.
 
 xoptional_assembly (const shape_type &shape, const value_type &value, layout_type l=base_type::static_layout)
 Allocates an xoptional_assembly with the specified shape and layout_type.
 
 xoptional_assembly (const shape_type &shape, const strides_type &strides)
 Allocates an uninitialized xoptional_assembly with the specified shape and strides.
 
 xoptional_assembly (const shape_type &shape, const strides_type &strides, const value_type &value)
 Allocates an uninitialized xoptional_assembly with the specified shape and strides.
 
 xoptional_assembly (const VE &ve)
 Allocates an xoptional_assembly from the specified value expression.
 
 xoptional_assembly (VE &&ve)
 Allocates an xoptional_assembly from the specified value expression.
 
template<class OVE, class OFE, typename = std::enable_if_t<is_xexpression<OVE>::value && is_xexpression<OFE>::value>>
 xoptional_assembly (OVE &&ove, OFE &&ofe)
 Allocates an xoptional_assembly from the specified value expression and missing mask expression.
 
 xoptional_assembly (const value_type &value)
 Allocates an xoptional_assembly that holds a single element initialized to the specified value.
 
Constructors from initializer list
 xoptional_assembly (nested_initializer_list_t< value_type, 1 > t)
 Allocates a one-dimensional xoptional_assembly.
 
 xoptional_assembly (nested_initializer_list_t< value_type, 2 > t)
 Allocates a two-dimensional xoptional_assembly.
 
 xoptional_assembly (nested_initializer_list_t< value_type, 3 > t)
 Allocates a three-dimensional xoptional_assembly.
 
 xoptional_assembly (nested_initializer_list_t< value_type, 4 > t)
 Allocates a four-dimensional xoptional_assembly.
 
 xoptional_assembly (nested_initializer_list_t< value_type, 5 > t)
 Allocates a five-dimensional xoptional_assembly.
 
 xoptional_assembly (const xoptional_assembly &)
 
xoptional_assembly & operator= (const xoptional_assembly &)
 
 xoptional_assembly (xoptional_assembly &&)
 
xoptional_assembly & operator= (xoptional_assembly &&)
 
template<class S>
xoptional_assembly< VE, FE > from_shape (S &&s)
 Allocates and returns an xoptional_assembly with the specified shape.
 
- Public Member Functions inherited from xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >
+layout_iterator< L > begin () noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+layout_iterator< L > end () noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rbegin () noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rend () noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference at (Args... args)
 
+const_reference at (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+reference periodic (Args... args)
 
+const_reference periodic (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+layout_iterator< L > begin () noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+layout_iterator< L > end () noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rbegin () noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rend () noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
reference front ()
 Returns a reference to the first element of the optional assembly.
 
const_reference front () const
 Returns a constant reference to the first element of the optional assembly.
 
reference back ()
 Returns a reference to the last element of the optional assembly.
 
const_reference back () const
 Returns a constant reference to the last element of the optional assembly.
 
reference flat (size_type args)
 Returns a reference to the element at the specified position of the underlying storage in the optional assembly.
 
const_reference flat (size_type args) const
 Returns a constant reference to the element at the specified position of the underlying storage in the optional assembly.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
storage_type & storage () noexcept
 
const storage_type & storage () const noexcept
 
value_type * data () noexcept
 
const value_type * data () const noexcept
 
const size_type data_offset () const noexcept
 
size_type size () const noexcept
 Returns the number of element in the optional assembly.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the optional assembly.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the optional assembly.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the optional assembly.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the optional assembly.
 
void resize (const S &shape, bool force=false)
 Resizes the optional assembly.
 
void resize (const S &shape, layout_type l)
 Resizes the optional assembly.
 
void resize (const S &shape, const strides_type &strides)
 Resizes the optional assembly.
 
auto & reshape (const S &shape, layout_type layout=static_layout) &
 Reshapes the optional assembly.
 
auto & reshape (std::initializer_list< T > shape, layout_type layout=static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
void fill (const T &value)
 Fills the data with the given value.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the optional assembly to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xoptional_assembly_base can be linearly assigned to an expression with the specified strides.
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
value_expression value () noexcept
 Return an expression for the values of the optional assembly.
 
const_value_expression value () const noexcept
 Return a constant expression for the values of the optional assembly.
 
flag_expression has_value () noexcept
 Return an expression for the missing mask of the optional assembly.
 
const_flag_expression has_value () const noexcept
 Return a constant expression for the missing mask of the optional assembly.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xoptional_assembly< VE, FE > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xoptional_assembly< VE, FE > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + +

+Static Public Member Functions

+template<class S = shape_type>
static xoptional_assembly from_shape (S &&s)
 
+ + + +

+Friends

class xoptional_assembly_base< xoptional_assembly< VE, FE > >
 
+ + + + + + + + + +

Extended copy semantic

template<class E>
 xoptional_assembly (const xexpression< E > &e)
 The extended copy constructor.
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Attributes inherited from xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Protected Member Functions inherited from xt::xoptional_assembly_base< xoptional_assembly< VE, FE > >
+ xoptional_assembly_base (const xoptional_assembly_base &)=default
 
+ xoptional_assembly_base (xoptional_assembly_base &&)=default
 
+xoptional_assembly_base & operator= (const xoptional_assembly_base &)=default
 
+xoptional_assembly_base & operator= (xoptional_assembly_base &&)=default
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xoptional_assembly< VE, FE > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xoptional_assembly< VE, FE > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class VE, class FE>
+class xt::xoptional_assembly< VE, FE >

Dense multidimensional container holding optional values, optimized for tensor operations.

+

The xoptional_assembly class implements a dense multidimensional container hoding optional values. This container is optimized of tensor operations: contrary to xarray_optional, xoptional_assembly holds two separated expressions, one for the values, the other for the missing mask.

+
Template Parameters
+ + + +
VEThe type of expression holding the values.
FEThe type of expression holding the missing mask.
+
+
+ +

Definition at line 61 of file xoptional_assembly.hpp.

+

Member Typedef Documentation

+ +

◆ assembly_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::assembly_type = base_type
+
+ +

Definition at line 84 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::base_type = xoptional_assembly_base<self_type>
+
+ +

Definition at line 67 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_flag_expression

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::const_flag_expression = typename base_type::const_flag_expression
+
+ +

Definition at line 74 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 80 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 78 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::const_value_expression = typename base_type::const_value_expression
+
+ +

Definition at line 73 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::flag_expression = typename base_type::flag_expression
+
+ +

Definition at line 72 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::pointer = typename base_type::pointer
+
+ +

Definition at line 79 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ raw_flag_expression

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::raw_flag_expression = typename base_type::raw_flag_expression
+
+ +

Definition at line 70 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ raw_value_expression

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::raw_value_expression = typename base_type::raw_value_expression
+
+ +

Definition at line 69 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::reference = typename base_type::reference
+
+ +

Definition at line 77 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::self_type = xoptional_assembly<VE, FE>
+
+ +

Definition at line 66 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 68 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 81 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 75 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 82 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::value_expression = typename base_type::value_expression
+
+ +

Definition at line 71 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly< VE, FE >::value_type = typename base_type::value_type
+
+ +

Definition at line 76 of file xoptional_assembly.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xoptional_assembly() [1/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly ()
+ 		+inline
+
+ +

Allocates an uninitialized xoptional_assembly that holds 0 element.

+ +

Definition at line 279 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [2/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const shape_type & shape,
layout_type l = base_type::static_layout )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xoptional_assembly with the specified shape and layout_type.

+
Parameters
+ + + +
shapethe shape of the xoptional_assembly
lthe layout_type of the xoptional_assembly
+
+
+ +

Definition at line 293 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [3/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const shape_type & shape,
const value_type & value,
layout_type l = base_type::static_layout )
+ 		+inlineexplicit
+
+ +

Allocates an xoptional_assembly with the specified shape and layout_type.

+

Elements are initialized to the specified value.

Parameters
+ + + + +
shapethe shape of the xoptional_assembly
valuethe value of the elements
lthe layout_type of the xoptional_assembly
+
+
+ +

Definition at line 308 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [4/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const shape_type & shape,
const strides_type & strides )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xoptional_assembly with the specified shape and strides.

+
Parameters
+ + + +
shapethe shape of the xoptional_assembly
stridesthe strides of the xoptional_assembly
+
+
+ +

Definition at line 325 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [5/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const shape_type & shape,
const strides_type & strides,
const value_type & value )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xoptional_assembly with the specified shape and strides.

+

Elements are initialized to the specified value.

Parameters
+ + + + +
shapethe shape of the xoptional_assembly
stridesthe strides of the xoptional_assembly
valuethe value of the elements
+
+
+ +

Definition at line 340 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [6/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const VE & ve)
+ 		+inline
+
+ +

Allocates an xoptional_assembly from the specified value expression.

+

The flag expression is initialized as if no value is missing.

Parameters
+ + +
vethe expression holding the values
+
+
+ +

Definition at line 370 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [7/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (VE && ve)
+ 		+inline
+
+ +

Allocates an xoptional_assembly from the specified value expression.

+

The flag expression is initialized as if no value is missing. The value expression is moved inside the xoptional_assembly and is therefore not available after the xoptional_assembly has been constructed.

Parameters
+ + +
vethe expression holding the values
+
+
+ +

Definition at line 385 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [8/17]

+ +
+
+
+template<class VE, class FE>
+
+template<class OVE, class OFE, typename>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (OVE && ove,
OFE && ofe )
+ 		+inline
+
+ +

Allocates an xoptional_assembly from the specified value expression and missing mask expression.

+
Parameters
+ + + +
ovethe expression holding the values
ofethe expression holding the missing mask
+
+
+ +

Definition at line 400 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [9/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const value_type & value)
+ 		+inline
+
+ +

Allocates an xoptional_assembly that holds a single element initialized to the specified value.

+
Parameters
+ + +
valuethe value of the element
+
+
+ +

Definition at line 357 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [10/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (nested_initializer_list_t< value_type, 1 > t)
+ 		+inline
+
+ +

Allocates a one-dimensional xoptional_assembly.

+
Parameters
+ + +
tthe elements of the xoptional_assembly
+
+
+ +

Definition at line 418 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [11/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (nested_initializer_list_t< value_type, 2 > t)
+ 		+inline
+
+ +

Allocates a two-dimensional xoptional_assembly.

+
Parameters
+ + +
tthe elements of the xoptional_assembly
+
+
+ +

Definition at line 436 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [12/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (nested_initializer_list_t< value_type, 3 > t)
+ 		+inline
+
+ +

Allocates a three-dimensional xoptional_assembly.

+
Parameters
+ + +
tthe elements of the xoptional_assembly
+
+
+ +

Definition at line 454 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [13/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (nested_initializer_list_t< value_type, 4 > t)
+ 		+inline
+
+ +

Allocates a four-dimensional xoptional_assembly.

+
Parameters
+ + +
tthe elements of the xoptional_assembly
+
+
+ +

Definition at line 472 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [14/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (nested_initializer_list_t< value_type, 5 > t)
+ 		+inline
+
+ +

Allocates a five-dimensional xoptional_assembly.

+
Parameters
+ + +
tthe elements of the xoptional_assembly
+
+
+ +

Definition at line 490 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [15/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const xoptional_assembly< VE, FE > & rhs)
+ 		+inline
+
+ +

Definition at line 518 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [16/17]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (xoptional_assembly< VE, FE > && rhs)
+ 		+inline
+
+ +

Definition at line 528 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly() [17/17]

+ +
+
+
+template<class VE, class FE>
+
+template<class E>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly< VE, FE >::xoptional_assembly (const xexpression< E > & e)
+ 		+inline
+
+ +

The extended copy constructor.

+ +

Definition at line 564 of file xoptional_assembly.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ from_shape()

+ +
+
+
+template<class VE, class FE>
+
+template<class S>
+ + + + + +
+ + + + + + + +
xoptional_assembly< VE, FE > xt::xoptional_assembly< VE, FE >::from_shape (S && s)
+ 		+inline
+
+ +

Allocates and returns an xoptional_assembly with the specified shape.

+
Parameters
+ + +
sthe shape of the xoptional_assembly
+
+
+ +

Definition at line 511 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ operator=() [1/3]

+ +
+
+
+template<class VE, class FE>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly< VE, FE >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 578 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ operator=() [2/3]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly< VE, FE >::operator= (const xoptional_assembly< VE, FE > & rhs)
+ 		+inline
+
+ +

Definition at line 538 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ operator=() [3/3]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly< VE, FE >::operator= (xoptional_assembly< VE, FE > && rhs)
+ 		+inline
+
+ +

Definition at line 547 of file xoptional_assembly.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xoptional_assembly_base< xoptional_assembly< VE, FE > >

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + +
friend class xoptional_assembly_base< xoptional_assembly< VE, FE > >
+ 		+friend
+
+ +

Definition at line 139 of file xoptional_assembly.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+
+ + + + diff --git a/classxt_1_1xoptional__assembly.js b/classxt_1_1xoptional__assembly.js new file mode 100644 index 000000000..b8e055c42 --- /dev/null +++ b/classxt_1_1xoptional__assembly.js @@ -0,0 +1,20 @@ +var classxt_1_1xoptional__assembly = +[ + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a13b42b1a2ff43f41688d9e9dfecb70ab", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a9148277e3915fdc930d875a7ad4b1156", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#af86f39ed88264ad627dcc09454b02d3e", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#af53e6578e2720b3de87db901d4ef63c0", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a91d71b9f5a1c0df8f7f10568a667149c", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a3ded488b5944690be387afa5e35165fb", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#aa525cc23b8a082ca1caf3fafcd321c88", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a18157a685aad00bd30890b9fe0484628", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#ae5c0585bcb1ec14efb01b993aa17c9d7", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a2454d878267c2ac27179ef2ca365d48e", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#ae13345d56e1c0e1b2a21290a66c8aa46", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a61dd51f2bf58adb62310d475253fc5b5", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#ace216a4aee450e4bd52f50b791091d99", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a16611b26c4241fdbbc7e6afcc8a09780", null ], + [ "xoptional_assembly", "classxt_1_1xoptional__assembly.html#a251ff352299adb4dd685ae71755c112f", null ], + [ "from_shape", "classxt_1_1xoptional__assembly.html#a04719a5f78f5bba3faa0f9a8d6aa393d", null ], + [ "operator=", "classxt_1_1xoptional__assembly.html#af67042d373194546b43afffb160ce687", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xoptional__assembly.png b/classxt_1_1xoptional__assembly.png new file mode 100644 index 000000000..03b0fe269 Binary files /dev/null and b/classxt_1_1xoptional__assembly.png differ diff --git a/classxt_1_1xoptional__assembly__adaptor-members.html b/classxt_1_1xoptional__assembly__adaptor-members.html new file mode 100644 index 000000000..7a99ea9fc --- /dev/null +++ b/classxt_1_1xoptional__assembly__adaptor-members.html @@ -0,0 +1,247 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xoptional_assembly_adaptor< VEC, FEC > Member List
+
+
+ +

This is the complete list of members for xt::xoptional_assembly_adaptor< VEC, FEC >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assembly_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xoptional_assembly_adaptor< VEC, FEC > >inline
at(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
at(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
at(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
at(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
back()xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
back() constxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
backstrides() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
base_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
const_flag_expression typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
const_pointer typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
const_reference typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
const_value_expression typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
dimension() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
element(It first, It last) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
element(It first, It last) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
element(It first, It last) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
element(It first, It last) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
fill(const T &value)xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
flag_expression typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
flat(size_type args)xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
flat(size_type args) constxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
front()xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
front() constxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
has_linear_assign(const S &strides) const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
has_value() noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
has_value() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
in_bounds(Args... args) constxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
layout() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator()(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator()(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator()(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator()(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator=(const xoptional_assembly_adaptor &) (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >inline
operator=(xoptional_assembly_adaptor &&) (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >inline
operator=(temporary_type &&) (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >inline
operator=(const xexpression< E > &e) (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
operator=(const xexpression< E > &e) -> self_type &xt::xoptional_assembly_adaptor< VEC, FEC >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
periodic(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
periodic(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
periodic(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
periodic(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >inline
pointer typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
reference typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
reshape(const S &shape, layout_type layout=static_layout) &xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
resize(const S &shape, bool force=false)xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
resize(const S &shape, layout_type l)xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
resize(const S &shape, const strides_type &strides)xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
self_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
semantic_base typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
shape() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
shape(size_type index) constxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
shape_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
size() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
storage_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
strides() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
strides_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
temporary_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
unchecked(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
unchecked(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
unchecked(Args... args) -> referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
unchecked(Args... args) const -> const_referencext::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
value() noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
value() const noexceptxt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >inline
value_expression typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
value_type typedef (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
xoptional_assembly_adaptor(OVE &&ve, OFE &&fe)xt::xoptional_assembly_adaptor< VEC, FEC >inline
xoptional_assembly_adaptor(const xoptional_assembly_adaptor &) (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >inline
xoptional_assembly_adaptor(xoptional_assembly_adaptor &&) (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >inline
xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > > (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >friend
~xoptional_assembly_adaptor()=default (defined in xt::xoptional_assembly_adaptor< VEC, FEC >)xt::xoptional_assembly_adaptor< VEC, FEC >
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__adaptor.html b/classxt_1_1xoptional__assembly__adaptor.html new file mode 100644 index 000000000..487c5c28f --- /dev/null +++ b/classxt_1_1xoptional__assembly__adaptor.html @@ -0,0 +1,1580 @@ + + + + + + + +xtensor: xt::xoptional_assembly_adaptor< VEC, FEC > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
xt::xoptional_assembly_adaptor< VEC, FEC > Class Template Reference
+
+
+ +

Dense multidimensional adaptor holding optional values, optimized for tensor operations. + More...

+ +

#include <xoptional_assembly.hpp>

+
+Inheritance diagram for xt::xoptional_assembly_adaptor< VEC, FEC >:
+
+
+ + +xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > > +xt::xcontainer_semantic< xoptional_assembly_adaptor< VEC, FEC > > +xt::xiterable< xoptional_assembly_adaptor< VEC, FEC > > +xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xoptional_assembly_adaptor<VEC, FEC>
 
using base_type = xoptional_assembly_base<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using storage_type = typename base_type::storage_type
 
using value_expression = typename base_type::value_expression
 
using flag_expression = typename base_type::flag_expression
 
using const_value_expression = typename base_type::const_value_expression
 
using const_flag_expression = typename base_type::const_flag_expression
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using assembly_type = base_type
 
- Public Types inherited from xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >
using self_type
 
using derived_type
 
using inner_types
 
using raw_value_expression
 
using base_value_type
 
using base_reference
 
using base_const_reference
 
using raw_flag_expression
 
using flag_type
 
using flag_reference
 
using flag_const_reference
 
using storage_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using expression_tag
 
using value_expression
 
using flag_expression
 
using const_value_expression
 
using const_flag_expression
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xoptional_assembly_adaptor< VEC, FEC > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
xoptional_assembly_adaptor & operator= (const xexpression< E > &e)
 
Constructors
template<class OVE, class OFE>
 xoptional_assembly_adaptor (OVE &&ve, OFE &&fe)
 Constructs an xoptional_assembly_adaptor of the given value and missing mask expressions.
 
 xoptional_assembly_adaptor (const xoptional_assembly_adaptor &)
 
xoptional_assembly_adaptor & operator= (const xoptional_assembly_adaptor &)
 
 xoptional_assembly_adaptor (xoptional_assembly_adaptor &&)
 
xoptional_assembly_adaptor & operator= (xoptional_assembly_adaptor &&)
 
xoptional_assembly_adaptor & operator= (temporary_type &&)
 
- Public Member Functions inherited from xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >
+layout_iterator< L > begin () noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+layout_iterator< L > end () noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rbegin () noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rend () noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference at (Args... args)
 
+const_reference at (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+reference periodic (Args... args)
 
+const_reference periodic (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+layout_iterator< L > begin () noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+layout_iterator< L > end () noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rbegin () noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+reverse_layout_iterator< L > rend () noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the optional assembly.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
reference front ()
 Returns a reference to the first element of the optional assembly.
 
const_reference front () const
 Returns a constant reference to the first element of the optional assembly.
 
reference back ()
 Returns a reference to the last element of the optional assembly.
 
const_reference back () const
 Returns a constant reference to the last element of the optional assembly.
 
reference flat (size_type args)
 Returns a reference to the element at the specified position of the underlying storage in the optional assembly.
 
const_reference flat (size_type args) const
 Returns a constant reference to the element at the specified position of the underlying storage in the optional assembly.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
storage_type & storage () noexcept
 
const storage_type & storage () const noexcept
 
value_type * data () noexcept
 
const value_type * data () const noexcept
 
const size_type data_offset () const noexcept
 
size_type size () const noexcept
 Returns the number of element in the optional assembly.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the optional assembly.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the optional assembly.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the optional assembly.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the optional assembly.
 
void resize (const S &shape, bool force=false)
 Resizes the optional assembly.
 
void resize (const S &shape, layout_type l)
 Resizes the optional assembly.
 
void resize (const S &shape, const strides_type &strides)
 Resizes the optional assembly.
 
auto & reshape (const S &shape, layout_type layout=static_layout) &
 Reshapes the optional assembly.
 
auto & reshape (std::initializer_list< T > shape, layout_type layout=static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
void fill (const T &value)
 Fills the data with the given value.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the optional assembly to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xoptional_assembly_base can be linearly assigned to an expression with the specified strides.
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
value_expression value () noexcept
 Return an expression for the values of the optional assembly.
 
const_value_expression value () const noexcept
 Return a constant expression for the values of the optional assembly.
 
flag_expression has_value () noexcept
 Return an expression for the missing mask of the optional assembly.
 
const_flag_expression has_value () const noexcept
 Return a constant expression for the missing mask of the optional assembly.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xoptional_assembly_adaptor< VEC, FEC > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + +

+Friends

class xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >
 
+ + + + + +

Extended copy semantic

template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Attributes inherited from xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Protected Member Functions inherited from xt::xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >
+ xoptional_assembly_base (const xoptional_assembly_base &)=default
 
+ xoptional_assembly_base (xoptional_assembly_base &&)=default
 
+xoptional_assembly_base & operator= (const xoptional_assembly_base &)=default
 
+xoptional_assembly_base & operator= (xoptional_assembly_base &&)=default
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xoptional_assembly_adaptor< VEC, FEC > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xoptional_assembly_adaptor< VEC, FEC > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class VEC, class FEC>
+class xt::xoptional_assembly_adaptor< VEC, FEC >

Dense multidimensional adaptor holding optional values, optimized for tensor operations.

+

The xoptional_assembly_adaptor class implements a dense multidimensional adaptor hoding optional values. It is used to provide an optional expression semantic to two tensor expressions, one holding the value, the hother holding the missing mask.

+
Template Parameters
+ + + +
VECThe closure for the type of expression holding the values.
FEThe closure for the type of expression holding the missing mask.
+
+
+ +

Definition at line 190 of file xoptional_assembly.hpp.

+

Member Typedef Documentation

+ +

◆ assembly_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::assembly_type = base_type
+
+ +

Definition at line 212 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::base_type = xoptional_assembly_base<self_type>
+
+ +

Definition at line 196 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_flag_expression

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::const_flag_expression = typename base_type::const_flag_expression
+
+ +

Definition at line 202 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 207 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 205 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::const_value_expression = typename base_type::const_value_expression
+
+ +

Definition at line 201 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::flag_expression = typename base_type::flag_expression
+
+ +

Definition at line 200 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::pointer = typename base_type::pointer
+
+ +

Definition at line 206 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::reference = typename base_type::reference
+
+ +

Definition at line 204 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::self_type = xoptional_assembly_adaptor<VEC, FEC>
+
+ +

Definition at line 195 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 197 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 208 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 198 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 209 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 210 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::value_expression = typename base_type::value_expression
+
+ +

Definition at line 199 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class VEC, class FEC>
+ + + + +
using xt::xoptional_assembly_adaptor< VEC, FEC >::value_type = typename base_type::value_type
+
+ +

Definition at line 203 of file xoptional_assembly.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xoptional_assembly_adaptor() [1/3]

+ +
+
+
+template<class VEC, class FEC>
+
+template<class OVE, class OFE>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly_adaptor< VEC, FEC >::xoptional_assembly_adaptor (OVE && ve,
OFE && fe )
+ 		+inline
+
+ +

Constructs an xoptional_assembly_adaptor of the given value and missing mask expressions.

+
Parameters
+ + + +
vethe expression holding the values
fethe expression holding the missing mask
+
+
+ +

Definition at line 637 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly_adaptor() [2/3]

+ +
+
+
+template<class VEC, class FEC>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly_adaptor< VEC, FEC >::xoptional_assembly_adaptor (const xoptional_assembly_adaptor< VEC, FEC > & rhs)
+ 		+inline
+
+ +

Definition at line 647 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ xoptional_assembly_adaptor() [3/3]

+ +
+
+
+template<class VEC, class FEC>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly_adaptor< VEC, FEC >::xoptional_assembly_adaptor (xoptional_assembly_adaptor< VEC, FEC > && rhs)
+ 		+inline
+
+ +

Definition at line 666 of file xoptional_assembly.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator=() [1/4]

+ +
+
+
+template<class VEC, class FEC>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_adaptor< VEC, FEC >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 701 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ operator=() [2/4]

+ +
+
+
+template<class VEC, class FEC>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_adaptor< VEC, FEC >::operator= (const xoptional_assembly_adaptor< VEC, FEC > & rhs)
+ 		+inline
+
+ +

Definition at line 657 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ operator=() [3/4]

+ +
+
+
+template<class VEC, class FEC>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_adaptor< VEC, FEC >::operator= (temporary_type && tmp)
+ 		+inline
+
+ +

Definition at line 685 of file xoptional_assembly.hpp.

+ +
+
+ +

◆ operator=() [4/4]

+ +
+
+
+template<class VEC, class FEC>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_adaptor< VEC, FEC >::operator= (xoptional_assembly_adaptor< VEC, FEC > && rhs)
+ 		+inline
+
+ +

Definition at line 676 of file xoptional_assembly.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >

+ +
+
+
+template<class VEC, class FEC>
+ + + + + +
+ + + + +
friend class xoptional_assembly_base< xoptional_assembly_adaptor< VEC, FEC > >
+ 		+friend
+
+ +

Definition at line 242 of file xoptional_assembly.hpp.

+ +
+
+
The documentation for this class was generated from the following files: +
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__adaptor.js b/classxt_1_1xoptional__assembly__adaptor.js new file mode 100644 index 000000000..87fc476ce --- /dev/null +++ b/classxt_1_1xoptional__assembly__adaptor.js @@ -0,0 +1,5 @@ +var classxt_1_1xoptional__assembly__adaptor = +[ + [ "xoptional_assembly_adaptor", "classxt_1_1xoptional__assembly__adaptor.html#a49ed47cb40d83d823a72f7907f4b4430", null ], + [ "operator=", "classxt_1_1xoptional__assembly__adaptor.html#ae9fc0069591e77f0b879152b82032987", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xoptional__assembly__adaptor.png b/classxt_1_1xoptional__assembly__adaptor.png new file mode 100644 index 000000000..18fe39417 Binary files /dev/null and b/classxt_1_1xoptional__assembly__adaptor.png differ diff --git a/classxt_1_1xoptional__assembly__base-members.html b/classxt_1_1xoptional__assembly__base-members.html new file mode 100644 index 000000000..2abfa96f7 --- /dev/null +++ b/classxt_1_1xoptional__assembly__base-members.html @@ -0,0 +1,279 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xoptional_assembly_base< D > Member List
+
+
+ +

This is the complete list of members for xt::xoptional_assembly_base< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
at(Args... args) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
at(Args... args) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
at(Args... args) -> referencext::xoptional_assembly_base< D >inline
at(Args... args) const -> const_referencext::xoptional_assembly_base< D >inline
back()xt::xoptional_assembly_base< D >inline
back() constxt::xoptional_assembly_base< D >inline
backstrides() const noexceptxt::xoptional_assembly_base< D >inline
backstrides_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
base_const_reference typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
base_reference typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
base_value_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
begin() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
begin(const S &shape) noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
begin() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
begin(const S &shape) const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
bool_load_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
broadcast_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xoptional_assembly_base< D >inline
const_broadcast_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_flag_expression typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_layout_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_linear_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_pointer typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_reference typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_reverse_broadcast_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_reverse_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_reverse_layout_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_reverse_linear_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_stepper typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
const_value_expression typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
contiguous_layout (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >static
data() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
data() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
data_offset() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
derived_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
difference_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
dimension() const noexceptxt::xoptional_assembly_base< D >inline
element(It first, It last) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
element(It first, It last) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
element(It first, It last) -> referencext::xoptional_assembly_base< D >inline
element(It first, It last) const -> const_referencext::xoptional_assembly_base< D >inline
end() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
end(const S &shape) noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
end() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
end(const S &shape) const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
expression_tag typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
fill(const T &value)xt::xoptional_assembly_base< D >inline
flag_const_reference typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
flag_expression typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
flag_reference typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
flag_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
flat(size_type args)xt::xoptional_assembly_base< D >inline
flat(size_type args) constxt::xoptional_assembly_base< D >inline
front()xt::xoptional_assembly_base< D >inline
front() constxt::xoptional_assembly_base< D >inline
has_linear_assign(const S &strides) const noexceptxt::xoptional_assembly_base< D >inline
has_value() noexceptxt::xoptional_assembly_base< D >inline
has_value() const noexceptxt::xoptional_assembly_base< D >inline
in_bounds(Args... args) constxt::xoptional_assembly_base< D >inline
inner_backstrides_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
inner_shape_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
inner_strides_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
inner_types typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
is_contiguous() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
iterable_base typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
layout() const noexceptxt::xoptional_assembly_base< D >inline
layout_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
linear_begin() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_begin() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_cbegin() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_cend() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_crbegin() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_crend() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_end() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_end() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
linear_rbegin() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_rbegin() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_rend() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
linear_rend() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
operator()(Args... args) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
operator()(Args... args) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
operator()(Args... args) -> referencext::xoptional_assembly_base< D >inline
operator()(Args... args) const -> const_referencext::xoptional_assembly_base< D >inline
operator=(const xoptional_assembly_base &)=default (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >protected
operator=(xoptional_assembly_base &&)=default (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >protected
operator[](const S &index) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
operator[](std::initializer_list< I > index) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
operator[](size_type i) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
operator[](const S &index) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
operator[](std::initializer_list< I > index) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
operator[](size_type i) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xoptional_assembly_base< D >inline
operator[](std::initializer_list< I > index) -> reference (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xoptional_assembly_base< D >inline
operator[](std::initializer_list< I > index) const -> const_reference (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
periodic(Args... args) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
periodic(Args... args) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
periodic(Args... args) -> referencext::xoptional_assembly_base< D >inline
periodic(Args... args) const -> const_referencext::xoptional_assembly_base< D >inline
pointer typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
raw_flag_expression typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
raw_value_expression typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rbegin() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rbegin(const S &shape) noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rbegin() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rbegin(const S &shape) const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
reference typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rend() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rend(const S &shape) noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rend() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
rend(const S &shape) const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
reshape(const S &shape, layout_type layout=static_layout) &xt::xoptional_assembly_base< D >inline
reshape(std::initializer_list< T > shape, layout_type layout=static_layout) & (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
resize(const S &shape, bool force=false)xt::xoptional_assembly_base< D >inline
resize(const S &shape, layout_type l)xt::xoptional_assembly_base< D >inline
resize(const S &shape, const strides_type &strides)xt::xoptional_assembly_base< D >inline
reverse_broadcast_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
reverse_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
reverse_layout_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
reverse_linear_iterator typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
self_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
shape() const noexceptxt::xoptional_assembly_base< D >inline
shape(size_type index) constxt::xoptional_assembly_base< D >inline
shape_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
simd_value_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
size() const noexceptxt::xoptional_assembly_base< D >inline
size_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
static_layout (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >static
stepper typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
stepper_begin(const S &shape) noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
stepper_begin(const S &shape) const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
stepper_end(const S &shape, layout_type l) noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
stepper_end(const S &shape, layout_type l) noexcept -> stepper (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
storage() noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
storage() const noexcept (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >inline
storage_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
strides() const noexceptxt::xoptional_assembly_base< D >inline
strides_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
unchecked(Args... args) (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
unchecked(Args... args) const (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
unchecked(Args... args) -> referencext::xoptional_assembly_base< D >inline
unchecked(Args... args) const -> const_referencext::xoptional_assembly_base< D >inline
value() noexceptxt::xoptional_assembly_base< D >inline
value() const noexceptxt::xoptional_assembly_base< D >inline
value_expression typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
value_type typedef (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >
xconst_iterable< D > (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >friend
xiterable< D > (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >friend
xoptional_assembly_base()=default (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >protected
xoptional_assembly_base(const xoptional_assembly_base &)=default (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >protected
xoptional_assembly_base(xoptional_assembly_base &&)=default (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >protected
~xoptional_assembly_base()=default (defined in xt::xoptional_assembly_base< D >)xt::xoptional_assembly_base< D >protected
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__base.html b/classxt_1_1xoptional__assembly__base.html new file mode 100644 index 000000000..c837b28ab --- /dev/null +++ b/classxt_1_1xoptional__assembly__base.html @@ -0,0 +1,3881 @@ + + + + + + + +xtensor: xt::xoptional_assembly_base< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Protected Member Functions | +Friends | +List of all members
+
xt::xoptional_assembly_base< D > Class Template Reference
+
+
+ +

Base class for dense multidimensional optional assemblies. + More...

+ +

#include <xoptional_assembly_base.hpp>

+
+Inheritance diagram for xt::xoptional_assembly_base< D >:
+
+
+ + +xt::xiterable< D > +xt::xoptional_assembly< raw_value_expression, raw_flag_expression > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xoptional_assembly_base<D>
 
using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using raw_value_expression = typename inner_types::raw_value_expression
 
using base_value_type = typename raw_value_expression::value_type
 
using base_reference = typename raw_value_expression::reference
 
using base_const_reference = typename raw_value_expression::const_reference
 
using raw_flag_expression = typename inner_types::raw_flag_expression
 
using flag_type = typename raw_flag_expression::value_type
 
using flag_reference = typename raw_flag_expression::reference
 
using flag_const_reference = typename raw_flag_expression::const_reference
 
using storage_type = typename inner_types::storage_type
 
using value_type = typename storage_type::value_type
 
using reference = typename storage_type::reference
 
using const_reference = typename storage_type::const_reference
 
using pointer = typename storage_type::pointer
 
using const_pointer = typename storage_type::const_pointer
 
using size_type = typename raw_value_expression::size_type
 
using difference_type = typename raw_value_expression::difference_type
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = xt::bool_load_type<value_type>
 
using shape_type = typename raw_value_expression::shape_type
 
using strides_type = typename raw_value_expression::strides_type
 
using backstrides_type = typename raw_value_expression::backstrides_type
 
using inner_shape_type = typename raw_value_expression::inner_shape_type
 
using inner_strides_type = typename raw_value_expression::inner_strides_type
 
using inner_backstrides_type = typename raw_value_expression::inner_backstrides_type
 
using iterable_base = xiterable<D>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using expression_tag = xoptional_expression_tag
 
using value_expression = raw_value_expression&
 
using flag_expression = raw_flag_expression&
 
using const_value_expression = const raw_value_expression&
 
using const_flag_expression = const raw_flag_expression&
 
template<layout_type L>
using layout_iterator = typename iterable_base::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
 
using linear_iterator = typename storage_type::iterator
 
using const_linear_iterator = typename storage_type::const_iterator
 
using reverse_linear_iterator = typename storage_type::reverse_iterator
 
using const_reverse_linear_iterator = typename storage_type::const_reverse_iterator
 
using iterator = typename iterable_base::iterator
 
using const_iterator = typename iterable_base::const_iterator
 
using reverse_iterator = typename iterable_base::reverse_iterator
 
using const_reverse_iterator = typename iterable_base::const_reverse_iterator
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
reference at (Args... args)
 
+template<class... Args>
const_reference at (Args... args) const
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class S>
disable_integral_t< S, reference > operator[] (const S &index)
 
+template<class I>
reference operator[] (std::initializer_list< I > index)
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class I>
const_reference operator[] (std::initializer_list< I > index) const
 
+template<class... Args>
reference periodic (Args... args)
 
+template<class... Args>
const_reference periodic (Args... args) const
 
+template<class It>
reference element (It first, It last)
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class S>
stepper stepper_begin (const S &shape) noexcept
 
+template<class S>
stepper stepper_end (const S &shape, layout_type l) noexcept
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
layout_iterator< L > begin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
layout_iterator< L > end () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_layout_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_layout_iterator< L > rbegin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_layout_iterator< L > rend () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_layout_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
Size and shape
size_type size () const noexcept
 Returns the number of element in the optional assembly.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the optional assembly.
 
const inner_shape_type & shape () const noexcept
 Returns the shape of the optional assembly.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the optional assembly.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the optional assembly.
 
template<class S = shape_type>
void resize (const S &shape, bool force=false)
 Resizes the optional assembly.
 
template<class S = shape_type>
void resize (const S &shape, layout_type l)
 Resizes the optional assembly.
 
template<class S = shape_type>
void resize (const S &shape, const strides_type &strides)
 Resizes the optional assembly.
 
template<class S = shape_type>
auto & reshape (const S &shape, layout_type layout=static_layout) &
 Reshapes the optional assembly.
 
template<class T>
auto & reshape (std::initializer_list< T > shape, layout_type layout=static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
template<class T>
void fill (const T &value)
 Fills the data with the given value.
 
Data
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference front ()
 Returns a reference to the first element of the optional assembly.
 
const_reference front () const
 Returns a constant reference to the first element of the optional assembly.
 
reference back ()
 Returns a reference to the last element of the optional assembly.
 
const_reference back () const
 Returns a constant reference to the last element of the optional assembly.
 
reference flat (size_type args)
 Returns a reference to the element at the specified position of the underlying storage in the optional assembly.
 
const_reference flat (size_type args) const
 Returns a constant reference to the element at the specified position of the underlying storage in the optional assembly.
 
template<class... Args>
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
storage_type & storage () noexcept
 
const storage_type & storage () const noexcept
 
value_type * data () noexcept
 
const value_type * data () const noexcept
 
const size_type data_offset () const noexcept
 
template<class... Args>
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
template<class... Args>
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
template<class... Args>
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after dimension and bounds checking.
 
template<class... Args>
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
template<class S>
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the optional assembly.
 
template<class I>
auto operator[] (std::initializer_list< I > index) -> reference
 
template<class S>
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the optional assembly.
 
template<class I>
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
template<class... Args>
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
template<class... Args>
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
template<class It>
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the optional assembly.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the optional assembly.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = raw_value_expression::static_layout
 
static constexpr bool contiguous_layout = raw_value_expression::contiguous_layout
 
+ + + + + + + + + +

+Protected Member Functions

+ xoptional_assembly_base (const xoptional_assembly_base &)=default
 
+xoptional_assembly_base & operator= (const xoptional_assembly_base &)=default
 
+ xoptional_assembly_base (xoptional_assembly_base &&)=default
 
+xoptional_assembly_base & operator= (xoptional_assembly_base &&)=default
 
+ + + + + +

+Friends

class xiterable< D >
 
class xconst_iterable< D >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the optional assembly to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xoptional_assembly_base can be linearly assigned to an expression with the specified strides.
 
linear_iterator linear_begin () noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
value_expression value () noexcept
 Return an expression for the values of the optional assembly.
 
const_value_expression value () const noexcept
 Return a constant expression for the values of the optional assembly.
 
flag_expression has_value () noexcept
 Return an expression for the missing mask of the optional assembly.
 
const_flag_expression has_value () const noexcept
 Return a constant expression for the missing mask of the optional assembly.
 
template<class S>
auto stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
+

Detailed Description

+
template<class D>
+class xt::xoptional_assembly_base< D >

Base class for dense multidimensional optional assemblies.

+

The xoptional_assembly_base class defines the interface for dense multidimensional optional assembly classes. Optional assembly classes hold optional values and are optimized for tensor operations. xoptional_assembly_base does not embed any data container, this responsibility is delegated to the inheriting classes.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xoptional_assembly_base provides the interface.
+
+
+ +

Definition at line 39 of file xoptional_assembly_base.hpp.

+

Member Typedef Documentation

+ +

◆ backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::backstrides_type = typename raw_value_expression::backstrides_type
+
+ +

Definition at line 71 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ base_const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::base_const_reference = typename raw_value_expression::const_reference
+
+ +

Definition at line 50 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ base_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::base_reference = typename raw_value_expression::reference
+
+ +

Definition at line 49 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ base_value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::base_value_type = typename raw_value_expression::value_type
+
+ +

Definition at line 48 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::bool_load_type = xt::bool_load_type<value_type>
+
+ +

Definition at line 67 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
+
+ +

Definition at line 100 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
+
+ +

Definition at line 102 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_flag_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_flag_expression = const raw_flag_expression&
+
+ +

Definition at line 88 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_iterator = typename iterable_base::const_iterator
+
+ +

Definition at line 114 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
+
+ +

Definition at line 93 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_linear_iterator = typename storage_type::const_iterator
+
+ +

Definition at line 109 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_pointer = typename storage_type::const_pointer
+
+ +

Definition at line 63 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_reference = typename storage_type::const_reference
+
+ +

Definition at line 61 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 106 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_reverse_iterator = typename iterable_base::const_reverse_iterator
+
+ +

Definition at line 116 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
+
+ +

Definition at line 97 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_reverse_linear_iterator = typename storage_type::const_reverse_iterator
+
+ +

Definition at line 111 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 79 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ const_value_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::const_value_expression = const raw_value_expression&
+
+ +

Definition at line 87 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::derived_type = D
+
+ +

Definition at line 44 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::difference_type = typename raw_value_expression::difference_type
+
+ +

Definition at line 65 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::expression_tag = xoptional_expression_tag
+
+ +

Definition at line 84 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ flag_const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::flag_const_reference = typename raw_flag_expression::const_reference
+
+ +

Definition at line 55 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ flag_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::flag_expression = raw_flag_expression&
+
+ +

Definition at line 86 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ flag_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::flag_reference = typename raw_flag_expression::reference
+
+ +

Definition at line 54 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ flag_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::flag_type = typename raw_flag_expression::value_type
+
+ +

Definition at line 53 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::inner_backstrides_type = typename raw_value_expression::inner_backstrides_type
+
+ +

Definition at line 75 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::inner_shape_type = typename raw_value_expression::inner_shape_type
+
+ +

Definition at line 73 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::inner_strides_type = typename raw_value_expression::inner_strides_type
+
+ +

Definition at line 74 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::inner_types = xcontainer_inner_types<D>
+
+ +

Definition at line 45 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::iterable_base = xiterable<D>
+
+ +

Definition at line 77 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::iterator = typename iterable_base::iterator
+
+ +

Definition at line 113 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::layout_iterator = typename iterable_base::template layout_iterator<L>
+
+ +

Definition at line 91 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::linear_iterator = typename storage_type::iterator
+
+ +

Definition at line 108 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::pointer = typename storage_type::pointer
+
+ +

Definition at line 62 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ raw_flag_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::raw_flag_expression = typename inner_types::raw_flag_expression
+
+ +

Definition at line 52 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ raw_value_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::raw_value_expression = typename inner_types::raw_value_expression
+
+ +

Definition at line 47 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::reference = typename storage_type::reference
+
+ +

Definition at line 60 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class D>
+
+template<class S, layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 104 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::reverse_iterator = typename iterable_base::reverse_iterator
+
+ +

Definition at line 115 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class D>
+
+template<layout_type L>
+ + + + +
using xt::xoptional_assembly_base< D >::reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
+
+ +

Definition at line 95 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::reverse_linear_iterator = typename storage_type::reverse_iterator
+
+ +

Definition at line 110 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::self_type = xoptional_assembly_base<D>
+
+ +

Definition at line 43 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::shape_type = typename raw_value_expression::shape_type
+
+ +

Definition at line 69 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 66 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::size_type = typename raw_value_expression::size_type
+
+ +

Definition at line 64 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 78 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::storage_type = typename inner_types::storage_type
+
+ +

Definition at line 57 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::strides_type = typename raw_value_expression::strides_type
+
+ +

Definition at line 70 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ value_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::value_expression = raw_value_expression&
+
+ +

Definition at line 85 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xoptional_assembly_base< D >::value_type = typename storage_type::value_type
+
+ +

Definition at line 59 of file xoptional_assembly_base.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ at() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::at (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the optional assembly, after dimension and bounds checking.

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices should be equal to the number of dimensions of the optional assembly.
+
+
+
Exceptions
+ + +
std::out_of_rangeif the number of argument is greater than the number of dimensions or if indices are out of bounds.
+
+
+ +

Definition at line 510 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ at() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::at (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the optional assembly, after dimension and bounds checking.

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices should be equal to the number of dimensions of the optional assembly.
+
+
+
Exceptions
+ + +
std::out_of_rangeif the number of argument is greater than the number of dimensions or if indices are out of bounds.
+
+
+ +

Definition at line 526 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ back() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::back ()
+ 		+inline
+
+ +

Returns a reference to the last element of the optional assembly.

+ +

Definition at line 686 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ back() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::back () const
+ 		+inline
+
+ +

Returns a constant reference to the last element of the optional assembly.

+ +

Definition at line 695 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ backstrides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::backstrides () const
+ 		+inlinenoexcept
+
+ +

Returns the backstrides of the optional assembly.

+ +

Definition at line 373 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xoptional_assembly_base< D >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the optional assembly to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 806 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::data () const
+ 		+inlinenoexcept
+
+ +

Definition at line 783 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::data ()
+ 		+inlinenoexcept
+
+ +

Definition at line 777 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ data_offset()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::data_offset () const
+ 		+inlinenoexcept
+
+ +

Definition at line 789 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::dimension () const
+ 		+inlineconstexprnoexcept
+
+ +

Returns the number of dimensions of the optional assembly.

+ +

Definition at line 337 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class D>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xoptional_assembly_base< D >::element (It first,
It last ) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the optional assembly.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 731 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class D>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xoptional_assembly_base< D >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the optional assembly.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 745 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ fill()

+ +
+
+
+template<class D>
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_base< D >::fill (const T & value)
+ 		+inline
+
+ +

Fills the data with the given value.

+
Parameters
+ + +
valuethe value to fill the data with.
+
+
+ +

Definition at line 464 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ flat() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::flat (size_type i)
+ 		+inline
+
+ +

Returns a reference to the element at the specified position of the underlying storage in the optional assembly.

+
Parameters
+ + +
iindex to underlying flat storage.
+
+
+ +

Definition at line 706 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ flat() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::flat (size_type i) const
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position of the underlying storage in the optional assembly.

+
Parameters
+ + +
iindex to underlying flat storage.
+
+
+ +

Definition at line 717 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ front() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::front ()
+ 		+inline
+
+ +

Returns a reference to the first element of the optional assembly.

+ +

Definition at line 668 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ front() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::front () const
+ 		+inline
+
+ +

Returns a constant reference to the first element of the optional assembly.

+ +

Definition at line 677 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xoptional_assembly_base< D >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xoptional_assembly_base can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 819 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ has_value() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::has_value () const
+ 		+inlinenoexcept
+
+ +

Return a constant expression for the missing mask of the optional assembly.

+ +

Definition at line 958 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::has_value ()
+ 		+inlinenoexcept
+
+ +

Return an expression for the missing mask of the optional assembly.

+ +

Definition at line 949 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ in_bounds()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
bool xt::xoptional_assembly_base< D >::in_bounds (Args... args) const
+ 		+inline
+
+ +

Returns true only if the the specified position is a valid entry in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression.
+
+
+
Returns
bool
+ +

Definition at line 757 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
bool xt::xoptional_assembly_base< D >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 453 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
layout_type xt::xoptional_assembly_base< D >::layout () const
+ 		+inlinenoexcept
+
+ +

Return the layout_type of the container.

+
Returns
layout_type of the container
+ +

Definition at line 447 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_begin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 839 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_begin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 827 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 851 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 857 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 887 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 893 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_end() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 845 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_end() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 833 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_rbegin() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 875 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_rbegin() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_rbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 863 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_rend() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 881 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ linear_rend() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::linear_rend ()
+ 		+inlinenoexcept
+
+ +

Definition at line 869 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator() (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the optional assembly.

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 481 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the optional assembly.

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 494 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator[]() [1/6]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator[] (const S & index) -> disable_integral_t<S, reference> +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the optional assembly.

+
Parameters
+ + +
indexa sequence of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices in the list should be equal or greater than the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 591 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator[]() [2/6]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator[] (const S & index) const -> disable_integral_t<S, const_reference> +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the optional assembly.

+
Parameters
+ + +
indexa sequence of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices in the list should be equal or greater than the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 617 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator[]() [3/6]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 604 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator[]() [4/6]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 631 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator[]() [5/6]

+ +
+
+
+template<class D>
+
+template<class I>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator[] (std::initializer_list< I > index) -> reference +
+ 		+inline
+
+ +

Definition at line 598 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ operator[]() [6/6]

+ +
+
+
+template<class D>
+
+template<class I>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::operator[] (std::initializer_list< I > index) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 625 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ periodic() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::periodic (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices should be equal to the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 645 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ periodic() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::periodic (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the optional assembly, after applying periodicity to the indices (negative and 'overflowing' indices are changed).

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices should be equal to the number of dimensions of the optional assembly.
+
+
+ +

Definition at line 659 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reshape() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto & xt::xoptional_assembly_base< D >::reshape (const S & shape,
layout_type layout = static_layout ) &
+ 		+inline
+
+ +

Reshapes the optional assembly.

+
Parameters
+ + + +
shapethe new shape
layoutthe new layout
+
+
+ +

Definition at line 426 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reshape() [2/2]

+ +
+
+
+template<class D>
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto & xt::xoptional_assembly_base< D >::reshape (std::initializer_list< T > shape,
layout_type layout = static_layout ) &
+ 		+inline
+
+ +

Definition at line 435 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ resize() [1/3]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xoptional_assembly_base< D >::resize (const S & shape,
bool force = false )
+ 		+inline
+
+ +

Resizes the optional assembly.

+
Parameters
+ + + +
shapethe new shape
forceforce reshaping, even if the shape stays the same (default: false)
+
+
+ +

Definition at line 387 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ resize() [2/3]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xoptional_assembly_base< D >::resize (const S & shape,
const strides_type & strides )
+ 		+inline
+
+ +

Resizes the optional assembly.

+
Parameters
+ + + +
shapethe new shape
stridesthe new strides
+
+
+ +

Definition at line 413 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ resize() [3/3]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xoptional_assembly_base< D >::resize (const S & shape,
layout_type l )
+ 		+inline
+
+ +

Resizes the optional assembly.

+
Parameters
+ + + +
shapethe new shape
lthe new layout_type
+
+
+ +

Definition at line 400 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ shape() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the optional assembly.

+ +

Definition at line 346 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ shape() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::shape (size_type index) const
+ 		+inline
+
+ +

Returns the i-th dimension of the expression.

+ +

Definition at line 355 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::size () const
+ 		+inlinenoexcept
+
+ +

Returns the number of element in the optional assembly.

+ +

Definition at line 328 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 914 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::stepper_begin (const S & shape) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 900 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xoptional_assembly_base< D >::stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 921 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xoptional_assembly_base< D >::stepper_end (const S & shape,
layout_type l ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 907 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ storage() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::storage () const
+ 		+inlinenoexcept
+
+ +

Definition at line 771 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ storage() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::storage ()
+ 		+inlinenoexcept
+
+ +

Definition at line 765 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ strides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::strides () const
+ 		+inlinenoexcept
+
+ +

Returns the strides of the optional assembly.

+ +

Definition at line 364 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::unchecked (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the optional assembly.

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the optional assembly, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 552 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the optional assembly.

+
Parameters
+ + +
argsa list of indices specifying the position in the optional assembly. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the optional assembly, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
+ +

Definition at line 578 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::value () const
+ 		+inlinenoexcept
+
+ +

Return a constant expression for the values of the optional assembly.

+ +

Definition at line 940 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_base< D >::value ()
+ 		+inlinenoexcept
+
+ +

Return an expression for the values of the optional assembly.

+ +

Definition at line 931 of file xoptional_assembly_base.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xconst_iterable< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xconst_iterable< D >
+ 		+friend
+
+ +

Definition at line 265 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ xiterable< D >

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
friend class xiterable< D >
+ 		+friend
+
+ +

Definition at line 265 of file xoptional_assembly_base.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
bool xt::xoptional_assembly_base< D >::contiguous_layout = raw_value_expression::contiguous_layout
+ 		+staticconstexpr
+
+ +

Definition at line 82 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
layout_type xt::xoptional_assembly_base< D >::static_layout = raw_value_expression::static_layout
+ 		+staticconstexpr
+
+ +

Definition at line 81 of file xoptional_assembly_base.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__base.js b/classxt_1_1xoptional__assembly__base.js new file mode 100644 index 000000000..45824d7ec --- /dev/null +++ b/classxt_1_1xoptional__assembly__base.js @@ -0,0 +1,40 @@ +var classxt_1_1xoptional__assembly__base = +[ + [ "at", "classxt_1_1xoptional__assembly__base.html#a73dd5d1abc3eeb977466ea06cbd010a6", null ], + [ "at", "classxt_1_1xoptional__assembly__base.html#ab6aeecb3fd2184aa49cf51142487ae31", null ], + [ "back", "classxt_1_1xoptional__assembly__base.html#a30a6a24dfa921de015892bddeef5e731", null ], + [ "back", "classxt_1_1xoptional__assembly__base.html#a8d17eac6565a38c69ce3597b087daa24", null ], + [ "backstrides", "classxt_1_1xoptional__assembly__base.html#a0af0bee6bcff1b475520937f31b84bd5", null ], + [ "broadcast_shape", "classxt_1_1xoptional__assembly__base.html#a98fdda9ecaf31ce8310614ad46aee9cd", null ], + [ "dimension", "classxt_1_1xoptional__assembly__base.html#a89f917b17d7b6ded98b95ba5f9c52de2", null ], + [ "element", "classxt_1_1xoptional__assembly__base.html#a1878f869c91ab899acc2fc560990538c", null ], + [ "element", "classxt_1_1xoptional__assembly__base.html#afe8cc2e4841489d3f1af56dbab957af3", null ], + [ "fill", "classxt_1_1xoptional__assembly__base.html#a6b2d66863b5c7e149d54f75d3911d34d", null ], + [ "flat", "classxt_1_1xoptional__assembly__base.html#abdea1fd8c021f170b2b34fbfae36f2db", null ], + [ "flat", "classxt_1_1xoptional__assembly__base.html#a2ab81721e7b9e8986206742c4baddf71", null ], + [ "front", "classxt_1_1xoptional__assembly__base.html#a0e191af3d00801e0018161ab739fc6d2", null ], + [ "front", "classxt_1_1xoptional__assembly__base.html#aacfa0f794bd3a92bf3ad57833861f73e", null ], + [ "has_linear_assign", "classxt_1_1xoptional__assembly__base.html#a7e2c9d6439909805db95ebe75339fc06", null ], + [ "has_value", "classxt_1_1xoptional__assembly__base.html#a4501b171b337744f6c013a9a46c6414b", null ], + [ "has_value", "classxt_1_1xoptional__assembly__base.html#af274b99476f869609568a3e09fcf3c55", null ], + [ "in_bounds", "classxt_1_1xoptional__assembly__base.html#a109b7cd1df5661aaacc763e2c914795d", null ], + [ "layout", "classxt_1_1xoptional__assembly__base.html#a894c8a27844c4543906eb44fb33f579e", null ], + [ "operator()", "classxt_1_1xoptional__assembly__base.html#aea309f566b610b826a2609bb32b63d25", null ], + [ "operator()", "classxt_1_1xoptional__assembly__base.html#ab5abb6c1e1c8c57c1662421c5f679b5a", null ], + [ "operator[]", "classxt_1_1xoptional__assembly__base.html#ab9a1749164786ed873b216223098fe31", null ], + [ "operator[]", "classxt_1_1xoptional__assembly__base.html#af783d13bcc3bbd5082fdc79f8f2aeee8", null ], + [ "periodic", "classxt_1_1xoptional__assembly__base.html#a1b77e82dc265d815b17f17d337d96636", null ], + [ "periodic", "classxt_1_1xoptional__assembly__base.html#a282a52135c367ae4d80db9575f41d3a5", null ], + [ "reshape", "classxt_1_1xoptional__assembly__base.html#adcf1eb03fa74eac4bfd3c1c53647e841", null ], + [ "resize", "classxt_1_1xoptional__assembly__base.html#ad75f3602dcf419d0d35af7121da5e802", null ], + [ "resize", "classxt_1_1xoptional__assembly__base.html#a6679efb40275d9066e15627f79430759", null ], + [ "resize", "classxt_1_1xoptional__assembly__base.html#a346e0ff791f6279005d0229311e62b75", null ], + [ "shape", "classxt_1_1xoptional__assembly__base.html#a574aec951fe205155709a7871055ec75", null ], + [ "shape", "classxt_1_1xoptional__assembly__base.html#a58bcff261d17d4b7e5b89a9d4ac6a362", null ], + [ "size", "classxt_1_1xoptional__assembly__base.html#a21f778be8956cf3c7c72aa37169a0d2a", null ], + [ "strides", "classxt_1_1xoptional__assembly__base.html#aa1afe87047106cd980f036335b978199", null ], + [ "unchecked", "classxt_1_1xoptional__assembly__base.html#afca63e0308421875f479c8373eea66d3", null ], + [ "unchecked", "classxt_1_1xoptional__assembly__base.html#a53735c2da40556583e93ec94c618b325", null ], + [ "value", "classxt_1_1xoptional__assembly__base.html#ad6761e5fda241e0eed545c4b545d9f1c", null ], + [ "value", "classxt_1_1xoptional__assembly__base.html#a5b5b3c3f0201b416989eb3cc388c9ea2", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xoptional__assembly__base.png b/classxt_1_1xoptional__assembly__base.png new file mode 100644 index 000000000..d147d6279 Binary files /dev/null and b/classxt_1_1xoptional__assembly__base.png differ diff --git a/classxt_1_1xoptional__assembly__linear__iterator-members.html b/classxt_1_1xoptional__assembly__linear__iterator-members.html new file mode 100644 index 000000000..6c137d748 --- /dev/null +++ b/classxt_1_1xoptional__assembly__linear__iterator-members.html @@ -0,0 +1,139 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xoptional_assembly_linear_iterator< VE, FE, is_const > Member List
+
+
+ +

This is the complete list of members for xt::xoptional_assembly_linear_iterator< VE, FE, is_const >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
base_type typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
difference_type typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
flag_iterator typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
operator*() const (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator++() (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator+=(difference_type n) (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator-(const self_type &rhs) const (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator--() (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator-=(difference_type n) (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator->() const (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator<(const self_type &rhs) const (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
operator==(const self_type &rhs) const (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
pointer typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
reference typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
self_type typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
value_iterator typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
value_type typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
xoptional_assembly_linear_iterator(value_iterator value_it, flag_iterator flag_it) (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >inline
xoptional_assembly_storage_type typedef (defined in xt::xoptional_assembly_linear_iterator< VE, FE, is_const >)xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__linear__iterator.html b/classxt_1_1xoptional__assembly__linear__iterator.html new file mode 100644 index 000000000..f7037d096 --- /dev/null +++ b/classxt_1_1xoptional__assembly__linear__iterator.html @@ -0,0 +1,650 @@ + + + + + + + +xtensor: xt::xoptional_assembly_linear_iterator< VE, FE, is_const > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xoptional_assembly_linear_iterator< VE, FE, is_const > Class Template Reference
+
+
+
+Inheritance diagram for xt::xoptional_assembly_linear_iterator< VE, FE, is_const >:
+
+
+ +
+ + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xoptional_assembly_linear_iterator<VE, FE, is_const>
 
using base_type
 
using xoptional_assembly_storage_type = xoptional_assembly_storage<VE, FE>
 
using value_iterator
 
using flag_iterator
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using pointer = typename base_type::pointer
 
using difference_type = typename base_type::difference_type
 
+ + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xoptional_assembly_linear_iterator (value_iterator value_it, flag_iterator flag_it)
 
self_type & operator++ ()
 
self_type & operator-- ()
 
self_type & operator+= (difference_type n)
 
self_type & operator-= (difference_type n)
 
difference_type operator- (const self_type &rhs) const
 
reference operator* () const
 
pointer operator-> () const
 
bool operator== (const self_type &rhs) const
 
bool operator< (const self_type &rhs) const
 
+

Detailed Description

+
template<class VE, class FE, bool is_const>
+class xt::xoptional_assembly_linear_iterator< VE, FE, is_const >
+

Definition at line 169 of file xoptional_assembly_storage.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::base_type
+
+Initial value:
xtl::xrandom_access_iterator_base2<
+
xoptional_assembly_linear_iterator_traits<VE, FE, is_const>>
+
xt::xoptional_assembly_linear_iterator_traits
Definition xoptional_assembly_storage.hpp:153
+
+

Definition at line 175 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::difference_type = typename base_type::difference_type
+
+ +

Definition at line 191 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ flag_iterator

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::flag_iterator
+
+Initial value:
std::conditional_t<
+
is_const,
+
typename xoptional_assembly_storage_type::flag_storage::const_iterator,
+
typename xoptional_assembly_storage_type::flag_storage::iterator>
+
+

Definition at line 183 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::pointer = typename base_type::pointer
+
+ +

Definition at line 190 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::reference = typename base_type::reference
+
+ +

Definition at line 189 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::self_type = xoptional_assembly_linear_iterator<VE, FE, is_const>
+
+ +

Definition at line 174 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ value_iterator

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::value_iterator
+
+Initial value:
std::conditional_t<
+
is_const,
+
typename xoptional_assembly_storage_type::value_storage::const_iterator,
+
typename xoptional_assembly_storage_type::value_storage::iterator>
+
+

Definition at line 179 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::value_type = typename base_type::value_type
+
+ +

Definition at line 188 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ xoptional_assembly_storage_type

+ +
+
+
+template<class VE, class FE, bool is_const>
+ + + + +
using xt::xoptional_assembly_linear_iterator< VE, FE, is_const >::xoptional_assembly_storage_type = xoptional_assembly_storage<VE, FE>
+
+ +

Definition at line 178 of file xoptional_assembly_storage.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xoptional_assembly_linear_iterator()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly_linear_iterator< VE, FE, C >::xoptional_assembly_linear_iterator (value_iterator value_it,
flag_iterator flag_it )
+ 		+inline
+
+ +

Definition at line 486 of file xoptional_assembly_storage.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator* () const
+ 		+inline
+
+ +

Definition at line 535 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator++()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator++ ()
+ 		+inline
+
+ +

Definition at line 496 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator+=()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator+= (difference_type n)
+ 		+inline
+
+ +

Definition at line 512 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator-()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator- (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 528 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator--()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator-- ()
+ 		+inline
+
+ +

Definition at line 504 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator-=()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator-= (difference_type n)
+ 		+inline
+
+ +

Definition at line 520 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator->()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator-> () const
+ 		+inline
+
+ +

Definition at line 541 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator<()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
bool xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator< (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 553 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class VE, class FE, bool C>
+ + + + + +
+ + + + + + + +
bool xt::xoptional_assembly_linear_iterator< VE, FE, C >::operator== (const self_type & rhs) const
+ 		+inline
+
+ +

Definition at line 547 of file xoptional_assembly_storage.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__linear__iterator.png b/classxt_1_1xoptional__assembly__linear__iterator.png new file mode 100644 index 000000000..58f8cca38 Binary files /dev/null and b/classxt_1_1xoptional__assembly__linear__iterator.png differ diff --git a/classxt_1_1xoptional__assembly__stepper-members.html b/classxt_1_1xoptional__assembly__stepper-members.html new file mode 100644 index 000000000..f2065df70 --- /dev/null +++ b/classxt_1_1xoptional__assembly__stepper-members.html @@ -0,0 +1,141 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xoptional_assembly_stepper< D, is_const > Member List
+
+
+ +

This is the complete list of members for xt::xoptional_assembly_stepper< D, is_const >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + +
assembly_type typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
difference_type typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
flag_stepper typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
operator*() const (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
pointer typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
raw_flag_expression typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
raw_value_expression typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
reference typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
reset(size_type dim) (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
reset_back(size_type dim) (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
self_type typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
size_type typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
step(size_type dim) (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
step(size_type dim, size_type n) (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
step_back(size_type dim) (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
step_back(size_type dim, size_type n) (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
to_begin() (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
to_end(layout_type l) (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
value_stepper typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
value_type typedef (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >
xoptional_assembly_stepper(value_stepper vs, flag_stepper fs) noexcept (defined in xt::xoptional_assembly_stepper< D, is_const >)xt::xoptional_assembly_stepper< D, is_const >inline
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__stepper.html b/classxt_1_1xoptional__assembly__stepper.html new file mode 100644 index 000000000..9aaa25d09 --- /dev/null +++ b/classxt_1_1xoptional__assembly__stepper.html @@ -0,0 +1,687 @@ + + + + + + + +xtensor: xt::xoptional_assembly_stepper< D, is_const > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xoptional_assembly_stepper< D, is_const > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xoptional_assembly_stepper<D, is_const>
 
using assembly_type = typename D::assembly_type
 
using value_type = typename assembly_type::value_type
 
using reference
 
using pointer = std::conditional_t<is_const, typename assembly_type::const_pointer, typename assembly_type::pointer>
 
using size_type = typename assembly_type::size_type
 
using difference_type = typename assembly_type::difference_type
 
using raw_value_expression = typename assembly_type::raw_value_expression
 
using raw_flag_expression = typename assembly_type::raw_flag_expression
 
using value_stepper
 
using flag_stepper
 
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

Broadcasting
 xoptional_assembly_stepper (value_stepper vs, flag_stepper fs) noexcept
 
void step (size_type dim)
 
void step_back (size_type dim)
 
void step (size_type dim, size_type n)
 
void step_back (size_type dim, size_type n)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
reference operator* () const
 
+

Detailed Description

+
template<class D, bool is_const>
+class xt::xoptional_assembly_stepper< D, is_const >
+

Definition at line 276 of file xoptional_assembly_base.hpp.

+

Member Typedef Documentation

+ +

◆ assembly_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::assembly_type = typename D::assembly_type
+
+ +

Definition at line 281 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::difference_type = typename assembly_type::difference_type
+
+ +

Definition at line 287 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ flag_stepper

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::flag_stepper
+
+Initial value:
std::
+
conditional_t<is_const, typename raw_flag_expression::const_stepper, typename raw_flag_expression::stepper>
+
+

Definition at line 292 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::pointer = std::conditional_t<is_const, typename assembly_type::const_pointer, typename assembly_type::pointer>
+
+ +

Definition at line 285 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ raw_flag_expression

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::raw_flag_expression = typename assembly_type::raw_flag_expression
+
+ +

Definition at line 289 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ raw_value_expression

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::raw_value_expression = typename assembly_type::raw_value_expression
+
+ +

Definition at line 288 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::reference
+
+Initial value:
std::
+
conditional_t<is_const, typename assembly_type::const_reference, typename assembly_type::reference>
+
+

Definition at line 283 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::self_type = xoptional_assembly_stepper<D, is_const>
+
+ +

Definition at line 280 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::size_type = typename assembly_type::size_type
+
+ +

Definition at line 286 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ value_stepper

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::value_stepper
+
+Initial value:
std::
+
conditional_t<is_const, typename raw_value_expression::const_stepper, typename raw_value_expression::stepper>
+
+

Definition at line 290 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D, bool is_const>
+ + + + +
using xt::xoptional_assembly_stepper< D, is_const >::value_type = typename assembly_type::value_type
+
+ +

Definition at line 282 of file xoptional_assembly_base.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xoptional_assembly_stepper()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly_stepper< D, C >::xoptional_assembly_stepper (value_stepper vs,
flag_stepper fs )
+ 		+inlinenoexcept
+
+ +

Definition at line 980 of file xoptional_assembly_base.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_stepper< D, C >::operator* () const
+ 		+inline
+
+ +

Definition at line 1043 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 1015 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 1022 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ step() [1/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::step (size_type dim)
+ 		+inline
+
+ +

Definition at line 987 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ step() [2/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::step (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 1001 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ step_back() [1/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::step_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 994 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ step_back() [2/2]

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::step_back (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 1008 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::to_begin ()
+ 		+inline
+
+ +

Definition at line 1029 of file xoptional_assembly_base.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class D, bool C>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_stepper< D, C >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 1036 of file xoptional_assembly_base.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__storage-members.html b/classxt_1_1xoptional__assembly__storage-members.html new file mode 100644 index 000000000..abf84263b --- /dev/null +++ b/classxt_1_1xoptional__assembly__storage-members.html @@ -0,0 +1,172 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xoptional_assembly_storage< VE, FE > Member List
+
+
+ +

This is the complete list of members for xt::xoptional_assembly_storage< VE, FE >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
back() (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
back() const (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
begin() noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
begin() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
cbegin() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
cend() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
const_iterator typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
const_pointer typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
const_reference typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
const_reverse_iterator typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
crbegin() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
crend() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
data() noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
data() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
difference_type typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
empty() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
end() noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
end() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
flag_reference typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
flag_storage typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
front() (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
front() const (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
has_value() noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
has_value() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
is_flag_const (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >static
is_val_const (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >static
iterator typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
operator=(const xoptional_assembly_storage &) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
operator=(xoptional_assembly_storage &&) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
operator[](size_type i) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
operator[](size_type i) const (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
pointer typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
rbegin() noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
rbegin() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
reference typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
rend() noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
rend() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
resize(size_type size) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
reverse_iterator typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
self_type typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
size() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
size_type typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
swap(self_type &rhs) noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
val_reference typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
value() noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
value() const noexcept (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
value_storage typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
value_type typedef (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >
xoptional_assembly_storage(const VE1 &value_stor, const FE1 &flag_stor) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
xoptional_assembly_storage(VE1 &value_stor, FE1 &flag_stor) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
xoptional_assembly_storage(const xoptional_assembly_storage &) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
xoptional_assembly_storage(xoptional_assembly_storage &&) (defined in xt::xoptional_assembly_storage< VE, FE >)xt::xoptional_assembly_storage< VE, FE >inline
+
+ + + + diff --git a/classxt_1_1xoptional__assembly__storage.html b/classxt_1_1xoptional__assembly__storage.html new file mode 100644 index 000000000..68bcaa104 --- /dev/null +++ b/classxt_1_1xoptional__assembly__storage.html @@ -0,0 +1,1592 @@ + + + + + + + +xtensor: xt::xoptional_assembly_storage< VE, FE > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::xoptional_assembly_storage< VE, FE > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xoptional_assembly_storage<VE, FE>
 
using value_storage = std::remove_reference_t<VE>
 
using flag_storage = std::remove_reference_t<FE>
 
using value_type = xtl::xoptional<typename value_storage::value_type, typename flag_storage::value_type>
 
using val_reference
 
using flag_reference
 
using reference = xtl::xoptional<val_reference, flag_reference>
 
using const_reference = xtl::xoptional<typename value_storage::const_reference, typename flag_storage::const_reference>
 
using pointer = xtl::xclosure_pointer<reference>
 
using const_pointer = xtl::xclosure_pointer<const_reference>
 
using size_type = typename value_storage::size_type
 
using difference_type = typename value_storage::difference_type
 
using iterator = xoptional_assembly_linear_iterator<VE, FE, false>
 
using const_iterator = xoptional_assembly_linear_iterator<VE, FE, true>
 
using reverse_iterator = std::reverse_iterator<iterator>
 
using const_reverse_iterator = std::reverse_iterator<const_iterator>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class VE1, class FE1>
 xoptional_assembly_storage (const VE1 &value_stor, const FE1 &flag_stor)
 
template<class VE1, class FE1>
 xoptional_assembly_storage (VE1 &value_stor, FE1 &flag_stor)
 
 xoptional_assembly_storage (const xoptional_assembly_storage &)
 
xoptional_assembly_storage & operator= (const xoptional_assembly_storage &)
 
 xoptional_assembly_storage (xoptional_assembly_storage &&)
 
xoptional_assembly_storage & operator= (xoptional_assembly_storage &&)
 
bool empty () const noexcept
 
size_type size () const noexcept
 
void resize (size_type size)
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
pointer data () noexcept
 
const_pointer data () const noexcept
 
iterator begin () noexcept
 
iterator end () noexcept
 
const_iterator begin () const noexcept
 
const_iterator end () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
reverse_iterator rbegin () noexcept
 
reverse_iterator rend () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
const_reverse_iterator rend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
void swap (self_type &rhs) noexcept
 
value_storage & value () noexcept
 
const value_storage & value () const noexcept
 
flag_storage & has_value () noexcept
 
const flag_storage & has_value () const noexcept
 
+ + + + + +

+Static Public Attributes

static constexpr bool is_val_const = std::is_const<value_storage>::value
 
static constexpr bool is_flag_const = std::is_const<flag_storage>::value
 
+

Detailed Description

+
template<class VE, class FE>
+class xt::xoptional_assembly_storage< VE, FE >
+

Definition at line 27 of file xoptional_assembly_storage.hpp.

+

Member Typedef Documentation

+ +

◆ const_iterator

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::const_iterator = xoptional_assembly_linear_iterator<VE, FE, true>
+
+ +

Definition at line 54 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::const_pointer = xtl::xclosure_pointer<const_reference>
+
+ +

Definition at line 48 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::const_reference = xtl::xoptional<typename value_storage::const_reference, typename flag_storage::const_reference>
+
+ +

Definition at line 45 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::const_reverse_iterator = std::reverse_iterator<const_iterator>
+
+ +

Definition at line 56 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::difference_type = typename value_storage::difference_type
+
+ +

Definition at line 51 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ flag_reference

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::flag_reference
+
+Initial value:
std::
+
conditional_t<is_flag_const, typename flag_storage::const_reference, typename flag_storage::reference>
+
+

Definition at line 42 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ flag_storage

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::flag_storage = std::remove_reference_t<FE>
+
+ +

Definition at line 34 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::iterator = xoptional_assembly_linear_iterator<VE, FE, false>
+
+ +

Definition at line 53 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::pointer = xtl::xclosure_pointer<reference>
+
+ +

Definition at line 47 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::reference = xtl::xoptional<val_reference, flag_reference>
+
+ +

Definition at line 44 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::reverse_iterator = std::reverse_iterator<iterator>
+
+ +

Definition at line 55 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::self_type = xoptional_assembly_storage<VE, FE>
+
+ +

Definition at line 31 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::size_type = typename value_storage::size_type
+
+ +

Definition at line 50 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ val_reference

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::val_reference
+
+Initial value:
std::
+
conditional_t<is_val_const, typename value_storage::const_reference, typename value_storage::reference>
+
+

Definition at line 40 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ value_storage

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::value_storage = std::remove_reference_t<VE>
+
+ +

Definition at line 33 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class VE, class FE>
+ + + + +
using xt::xoptional_assembly_storage< VE, FE >::value_type = xtl::xoptional<typename value_storage::value_type, typename flag_storage::value_type>
+
+ +

Definition at line 36 of file xoptional_assembly_storage.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xoptional_assembly_storage() [1/4]

+ +
+
+
+template<class VE, class FE>
+
+template<class VE1, class FE1>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly_storage< VE, FE >::xoptional_assembly_storage (const VE1 & value_stor,
const FE1 & flag_stor )
+ 		+inline
+
+ +

Definition at line 221 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ xoptional_assembly_storage() [2/4]

+ +
+
+
+template<class VE, class FE>
+
+template<class VE1, class FE1>
+ + + + + +
+ + + + + + + + + + + +
xt::xoptional_assembly_storage< VE, FE >::xoptional_assembly_storage (VE1 & value_stor,
FE1 & flag_stor )
+ 		+inline
+
+ +

Definition at line 229 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ xoptional_assembly_storage() [3/4]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly_storage< VE, FE >::xoptional_assembly_storage (const xoptional_assembly_storage< VE, FE > & rhs)
+ 		+inline
+
+ +

Definition at line 236 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ xoptional_assembly_storage() [4/4]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
xt::xoptional_assembly_storage< VE, FE >::xoptional_assembly_storage (xoptional_assembly_storage< VE, FE > && rhs)
+ 		+inline
+
+ +

Definition at line 251 of file xoptional_assembly_storage.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ back() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::back ()
+ 		+inline
+
+ +

Definition at line 309 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ back() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::back () const
+ 		+inline
+
+ +

Definition at line 315 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ begin() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 345 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ begin() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 333 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ cbegin()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 357 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ cend()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 363 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ crbegin()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 393 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ crend()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 399 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::data () const
+ 		+inlinenoexcept
+
+ +

Definition at line 327 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::data ()
+ 		+inlinenoexcept
+
+ +

Definition at line 321 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ empty()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
bool xt::xoptional_assembly_storage< VE, FE >::empty () const
+ 		+inlinenoexcept
+
+ +

Definition at line 266 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ end() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 351 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ end() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 339 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ front() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::front ()
+ 		+inline
+
+ +

Definition at line 297 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ front() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::front () const
+ 		+inline
+
+ +

Definition at line 303 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ has_value() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::has_value () const
+ 		+inlinenoexcept
+
+ +

Definition at line 430 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ has_value() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::has_value ()
+ 		+inlinenoexcept
+
+ +

Definition at line 424 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::operator= (const xoptional_assembly_storage< VE, FE > & rhs)
+ 		+inline
+
+ +

Definition at line 243 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::operator= (xoptional_assembly_storage< VE, FE > && rhs)
+ 		+inline
+
+ +

Definition at line 258 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator[]() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::operator[] (size_type i)
+ 		+inline
+
+ +

Definition at line 285 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ operator[]() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::operator[] (size_type i) const
+ 		+inline
+
+ +

Definition at line 291 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ rbegin() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 381 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ rbegin() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::rbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 369 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ rend() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 387 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ rend() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::rend ()
+ 		+inlinenoexcept
+
+ +

Definition at line 375 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ resize()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_storage< VE, FE >::resize (size_type size)
+ 		+inline
+
+ +

Definition at line 278 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 272 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ swap()

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
void xt::xoptional_assembly_storage< VE, FE >::swap (self_type & rhs)
+ 		+inlinenoexcept
+
+ +

Definition at line 405 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ value() [1/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::value () const
+ 		+inlinenoexcept
+
+ +

Definition at line 418 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ value() [2/2]

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + + + + +
auto xt::xoptional_assembly_storage< VE, FE >::value ()
+ 		+inlinenoexcept
+
+ +

Definition at line 412 of file xoptional_assembly_storage.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ is_flag_const

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + +
bool xt::xoptional_assembly_storage< VE, FE >::is_flag_const = std::is_const<flag_storage>::value
+ 		+staticconstexpr
+
+ +

Definition at line 39 of file xoptional_assembly_storage.hpp.

+ +
+
+ +

◆ is_val_const

+ +
+
+
+template<class VE, class FE>
+ + + + + +
+ + + + +
bool xt::xoptional_assembly_storage< VE, FE >::is_val_const = std::is_const<value_storage>::value
+ 		+staticconstexpr
+
+ +

Definition at line 38 of file xoptional_assembly_storage.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xrange-members.html b/classxt_1_1xrange-members.html new file mode 100644 index 000000000..30d2a6690 --- /dev/null +++ b/classxt_1_1xrange-members.html @@ -0,0 +1,135 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xrange< T > Member List
+
+
+ +

This is the complete list of members for xt::xrange< T >, including all inherited members.

+ + + + + + + + + + + + + + + + +
contains(size_type i) const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
convert() const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
operator xrange< S >() const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
operator!=(const self_type &rhs) const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
operator()(size_type i) const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
operator==(const self_type &rhs) const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
revert_index(std::size_t i) const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
self_type typedef (defined in xt::xrange< T >)xt::xrange< T >
size() const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
size_type typedef (defined in xt::xrange< T >)xt::xrange< T >
step_size() const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
step_size(std::size_t i, std::size_t n=1) const noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
xrange (defined in xt::xrange< T >)xt::xrange< T >friend
xrange()=default (defined in xt::xrange< T >)xt::xrange< T >
xrange(size_type start_val, size_type stop_val) noexcept (defined in xt::xrange< T >)xt::xrange< T >inline
+
+ + + + diff --git a/classxt_1_1xrange.html b/classxt_1_1xrange.html new file mode 100644 index 000000000..a960d211d --- /dev/null +++ b/classxt_1_1xrange.html @@ -0,0 +1,596 @@ + + + + + + + +xtensor: xt::xrange< T > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xrange< T > Class Template Reference
+
+
+
+Inheritance diagram for xt::xrange< T >:
+
+
+ + +xt::xslice< xrange< T > > + +
+ + + + + + + + + +

+Public Types

using size_type = T
 
using self_type = xrange<T>
 
- Public Types inherited from xt::xslice< xrange< T > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xrange (size_type start_val, size_type stop_val) noexcept
 
template<std::convertible_to< T > S>
 operator xrange< S > () const noexcept
 
template<std::convertible_to< T > S>
xrange< S > convert () const noexcept
 
size_type operator() (size_type i) const noexcept
 
size_type size () const noexcept
 
size_type step_size () const noexcept
 
size_type step_size (std::size_t i, std::size_t n=1) const noexcept
 
size_type revert_index (std::size_t i) const noexcept
 
bool contains (size_type i) const noexcept
 
bool operator== (const self_type &rhs) const noexcept
 
bool operator!= (const self_type &rhs) const noexcept
 
- Public Member Functions inherited from xt::xslice< xrange< T > >
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xslice< xrange< T > >
+ xslice (const xslice &)=default
 
+ xslice (xslice &&)=default
 
+xslice & operator= (const xslice &)=default
 
+xslice & operator= (xslice &&)=default
 
+

Detailed Description

+
template<class T>
+class xt::xrange< T >
+

Definition at line 102 of file xslice.hpp.

+

Member Typedef Documentation

+ +

◆ self_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xrange< T >::self_type = xrange<T>
+
+ +

Definition at line 107 of file xslice.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xrange< T >::size_type = T
+
+ +

Definition at line 106 of file xslice.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xrange()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
xt::xrange< T >::xrange (size_type start_val,
size_type stop_val )
+ 		+inlinenoexcept
+
+ +

Definition at line 990 of file xslice.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ contains()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xrange< T >::contains (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1044 of file xslice.hpp.

+ +
+
+ +

◆ convert()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xrange< S > xt::xrange< T >::convert () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1008 of file xslice.hpp.

+ +
+
+ +

◆ operator xrange< S >()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xt::xrange< T >::operator xrange< S > () const
+ 		+inlinenoexcept
+
+ +

Definition at line 998 of file xslice.hpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xrange< T >::operator!= (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1056 of file xslice.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xrange< T >::operator() (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1014 of file xslice.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xrange< T >::operator== (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1050 of file xslice.hpp.

+ +
+
+ +

◆ revert_index()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xrange< T >::revert_index (std::size_t i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1038 of file xslice.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xrange< T >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1020 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [1/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xrange< T >::step_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1026 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [2/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xrange< T >::step_size (std::size_t i,
std::size_t n = 1 ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1032 of file xslice.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xrange

+ +
+
+
+template<class T>
+
+template<class S>
+ + + + + +
+ + + + +
friend class xrange
+ 		+friend
+
+ +

Definition at line 138 of file xslice.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xslice.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xrange.png b/classxt_1_1xrange.png new file mode 100644 index 000000000..ca501398b Binary files /dev/null and b/classxt_1_1xrange.png differ diff --git a/classxt_1_1xreducer-members.html b/classxt_1_1xreducer-members.html new file mode 100644 index 000000000..430ecf47c --- /dev/null +++ b/classxt_1_1xreducer-members.html @@ -0,0 +1,223 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xreducer< F, CT, X, O > Member List
+
+
+ +

This is the complete list of members for xt::xreducer< F, CT, X, O >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
at(Args... args) -> referencext::xaccessible< xreducer< F, CT, X, O > >inline
at(Args... args) -> referencext::xaccessible< xreducer< F, CT, X, O > >inline
axes_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
back() constxt::xaccessible< xreducer< F, CT, X, O > >
back()xt::xaccessible< xreducer< F, CT, X, O > >inline
back() constxt::xaccessible< xreducer< F, CT, X, O > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
bool_load_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xreducer< F, CT, X, O >inline
build_reducer(E &&e) const (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
build_reducer(E &&e, Func &&func, Opts &&opts) const (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
build_reducer(E &&e) const -> rebind_t< E > (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >inline
build_reducer(E &&e, Func &&func, Opts &&opts) const -> rebind_t< E, Func, Opts > (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
const_pointer typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
const_reference typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
const_stepper typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
contiguous_layout (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >static
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
xt::derived_cast() &noexceptxt::xexpression< xreducer< F, CT, X, O > >inline
xt::derived_cast() const &noexceptxt::xexpression< xreducer< F, CT, X, O > >inline
xt::derived_cast() &&noexceptxt::xexpression< xreducer< F, CT, X, O > >inline
difference_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
dim_mapping_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
dimension() const noexceptxt::xconst_accessible< xreducer< F, CT, X, O > >inline
element(It first, It last) const (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
element(It first, It last) const -> const_referencext::xreducer< F, CT, X, O >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
expression() const noexceptxt::xreducer< F, CT, X, O >inline
expression_tag typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
extension_base typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
front() constxt::xaccessible< xreducer< F, CT, X, O > >
front()xt::xaccessible< xreducer< F, CT, X, O > >inline
front() constxt::xaccessible< xreducer< F, CT, X, O > >inline
functors() const (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >inline
has_linear_assign(const S &strides) const noexceptxt::xreducer< F, CT, X, O >inline
in_bounds(Args... args) constxt::xconst_accessible< xreducer< F, CT, X, O > >inline
init_functor_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
inner_shape_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
inner_types typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
is_contiguous() const noexcept (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >inline
iterable_base typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
layout() const noexceptxt::xreducer< F, CT, X, O >inline
merge_functor_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
operator()(Args... args) const (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
operator()(Args... args) const -> const_referencext::xreducer< F, CT, X, O >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< xreducer< F, CT, X, O > >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< xreducer< F, CT, X, O > >inline
options() const (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >inline
periodic(Args... args) -> referencext::xaccessible< xreducer< F, CT, X, O > >inline
periodic(Args... args) -> referencext::xaccessible< xreducer< F, CT, X, O > >inline
pointer typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
rebind_t typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
reduce_functor_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
reference typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xreducer< F, CT, X, O > >inline
self_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
shape() const noexceptxt::xreducer< F, CT, X, O >inline
xt::xaccessible< xreducer< F, CT, X, O > >::shape(size_type index) constxt::xconst_accessible< xreducer< F, CT, X, O > >inline
shape_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
size() const noexcept(noexcept(derived_cast().shape()))xt::xconst_accessible< xreducer< F, CT, X, O > >inline
size_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
static_layout (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >static
stepper typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
stepper_begin(const S &shape) const noexcept (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >inline
stepper_end(const S &shape, layout_type) const noexcept (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >inline
substepper_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
unchecked(Args... args) const (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
unchecked(Args... args) const -> const_referencext::xreducer< F, CT, X, O >inline
value_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
xexpression_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
xreducer(Func &&func, CTA &&e, AX &&axes, OX &&options)xt::xreducer< F, CT, X, O >inline
xreducer_functors_type typedef (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >
xreducer_stepper< F, CT, X, O > (defined in xt::xreducer< F, CT, X, O >)xt::xreducer< F, CT, X, O >friend
+
+ + + + diff --git a/classxt_1_1xreducer.html b/classxt_1_1xreducer.html new file mode 100644 index 000000000..85148c4fa --- /dev/null +++ b/classxt_1_1xreducer.html @@ -0,0 +1,1907 @@ + + + + + + + +xtensor: xt::xreducer< F, CT, X, O > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xreducer< F, CT, X, O > Class Template Reference
+
+
+ +

Reducing function operating over specified axes. + More...

+ +

#include <xreducer.hpp>

+
+Inheritance diagram for xt::xreducer< F, CT, X, O >:
+
+
+ + +xt::xsharable_expression< xreducer< F, CT, X, O > > +xt::xconst_iterable< xreducer< F, CT, X, O > > +xt::xaccessible< xreducer< F, CT, X, O > > +xt::xexpression< xreducer< F, CT, X, O > > +xt::xconst_accessible< xreducer< F, CT, X, O > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xreducer<F, CT, X, O>
 
using inner_types = xcontainer_inner_types<self_type>
 
using reduce_functor_type = typename inner_types::reduce_functor_type
 
using init_functor_type = typename inner_types::init_functor_type
 
using merge_functor_type = typename inner_types::merge_functor_type
 
using xreducer_functors_type = xreducer_functors<reduce_functor_type, init_functor_type, merge_functor_type>
 
using xexpression_type = typename inner_types::xexpression_type
 
using axes_type = X
 
using extension_base = extension::xreducer_base_t<F, CT, X, O>
 
using expression_tag = typename extension_base::expression_tag
 
using substepper_type = typename inner_types::substepper_type
 
using value_type = typename inner_types::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = value_type*
 
using const_pointer = const value_type*
 
using size_type = typename inner_types::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using iterable_base = xconst_iterable<self_type>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using shape_type = inner_shape_type
 
using dim_mapping_type = typename select_dim_mapping_type<inner_shape_type>::type
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using bool_load_type = typename xexpression_type::bool_load_type
 
template<class E, class Func = F, class Opts = O>
using rebind_t = xreducer<Func, E, X, Opts>
 
- Public Types inherited from xt::xexpression< xreducer< F, CT, X, O > >
using derived_type
 
- Public Types inherited from xt::xconst_iterable< xreducer< F, CT, X, O > >
using derived_type
 
using iterable_types
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xaccessible< xreducer< F, CT, X, O > >
using base_type
 
using derived_type
 
using reference
 
using size_type
 
- Public Types inherited from xt::xconst_accessible< xreducer< F, CT, X, O > >
using derived_type
 
using inner_types
 
using reference
 
using const_reference
 
using size_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type) const noexcept
 
+template<class E>
rebind_t< E > build_reducer (E &&e) const
 
+template<class E, class Func, class Opts>
rebind_t< E, Func, Opts > build_reducer (E &&e, Func &&func, Opts &&opts) const
 
xreducer_functors_type functors () const
 
const O & options () const
 
Constructor
template<class Func, class CTA, class AX, class OX>
 xreducer (Func &&func, CTA &&e, AX &&axes, OX &&options)
 Constructs an xreducer expression applying the specified function to the given expression over the given axes.
 
Size and shape
const inner_shape_type & shape () const noexcept
 Returns the shape of the expression.
 
layout_type layout () const noexcept
 Returns the shape of the expression.
 
bool is_contiguous () const noexcept
 
Data
const xexpression_type & expression () const noexcept
 Returns a constant reference to the underlying expression of the reducer.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the reducer.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the reducer.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the reducer.
 
Broadcasting
template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the reducer to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xreducer can be linearly assigned to an expression with the specified strides.
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
template<class E>
auto build_reducer (E &&e) const -> rebind_t< E >
 
template<class E, class Func, class Opts>
auto build_reducer (E &&e, Func &&func, Opts &&opts) const -> rebind_t< E, Func, Opts >
 
- Public Member Functions inherited from xt::xexpression< xreducer< F, CT, X, O > >
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
- Public Member Functions inherited from xt::xconst_iterable< xreducer< F, CT, X, O > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_layout_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_layout_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xaccessible< xreducer< F, CT, X, O > >
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+const_reference operator[] (size_type i) const
 
+const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+const_reference periodic (Args... args) const
 
+reference at (Args... args)
 
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
+reference periodic (Args... args)
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+const_reference periodic (Args... args) const
 
reference front ()
 Returns a reference to the first element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
reference back ()
 Returns a reference to the last element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
- Public Member Functions inherited from xt::xconst_accessible< xreducer< F, CT, X, O > >
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+const_reference at (Args... args) const
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
+const_reference periodic (Args... args) const
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = layout_type::dynamic
 
static constexpr bool contiguous_layout = false
 
+ + + +

+Friends

class xreducer_stepper< F, CT, X, O >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xsharable_expression< xreducer< F, CT, X, O > >
+ xsharable_expression (const xsharable_expression &)=default
 
+ xsharable_expression (xsharable_expression &&)=default
 
+xsharable_expression & operator= (const xsharable_expression &)=default
 
+xsharable_expression & operator= (xsharable_expression &&)=default
 
- Protected Member Functions inherited from xt::xexpression< xreducer< F, CT, X, O > >
+ xexpression (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (const xexpression &)=default
 
+xexpression & operator= (xexpression &&)=default
 
const inner_shape_type & get_shape () const
 
- Protected Member Functions inherited from xt::xaccessible< xreducer< F, CT, X, O > >
+ xaccessible (const xaccessible &)=default
 
+ xaccessible (xaccessible &&)=default
 
+xaccessible & operator= (const xaccessible &)=default
 
+xaccessible & operator= (xaccessible &&)=default
 
- Protected Member Functions inherited from xt::xconst_accessible< xreducer< F, CT, X, O > >
+ xconst_accessible (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
+

Detailed Description

+
template<class F, class CT, class X, class O>
+class xt::xreducer< F, CT, X, O >

Reducing function operating over specified axes.

+

The xreducer class implements an xexpression applying a reducing function to an xexpression over the specified axes.

+
Template Parameters
+ + + + +
Fa tuple of functors (class xreducer_functors or compatible)
CTthe closure type of the xexpression to reduce
Xthe list of axes
+
+
+

The reducer's result_type is deduced from the result type of function F::reduce_functor_type when called with elements of the expression

Template Parameters
+ + +
CT.
+
+
+
See also
reduce
+ +

Definition at line 804 of file xreducer.hpp.

+

Member Typedef Documentation

+ +

◆ axes_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::axes_type = X
+
+ +

Definition at line 820 of file xreducer.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::bool_load_type = typename xexpression_type::bool_load_type
+
+ +

Definition at line 843 of file xreducer.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::const_pointer = const value_type*
+
+ +

Definition at line 830 of file xreducer.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 828 of file xreducer.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 842 of file xreducer.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 833 of file xreducer.hpp.

+ +
+
+ +

◆ dim_mapping_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::dim_mapping_type = typename select_dim_mapping_type<inner_shape_type>::type
+
+ +

Definition at line 839 of file xreducer.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 823 of file xreducer.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::extension_base = extension::xreducer_base_t<F, CT, X, O>
+
+ +

Definition at line 822 of file xreducer.hpp.

+ +
+
+ +

◆ init_functor_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::init_functor_type = typename inner_types::init_functor_type
+
+ +

Definition at line 815 of file xreducer.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 836 of file xreducer.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 812 of file xreducer.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::iterable_base = xconst_iterable<self_type>
+
+ +

Definition at line 835 of file xreducer.hpp.

+ +
+
+ +

◆ merge_functor_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::merge_functor_type = typename inner_types::merge_functor_type
+
+ +

Definition at line 816 of file xreducer.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::pointer = value_type*
+
+ +

Definition at line 829 of file xreducer.hpp.

+ +
+
+ +

◆ rebind_t

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class E, class Func = F, class Opts = O>
+ + + + +
using xt::xreducer< F, CT, X, O >::rebind_t = xreducer<Func, E, X, Opts>
+
+ +

Definition at line 877 of file xreducer.hpp.

+ +
+
+ +

◆ reduce_functor_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::reduce_functor_type = typename inner_types::reduce_functor_type
+
+ +

Definition at line 814 of file xreducer.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::reference = typename inner_types::reference
+
+ +

Definition at line 827 of file xreducer.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::self_type = xreducer<F, CT, X, O>
+
+ +

Definition at line 811 of file xreducer.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::shape_type = inner_shape_type
+
+ +

Definition at line 837 of file xreducer.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::size_type = typename inner_types::size_type
+
+ +

Definition at line 832 of file xreducer.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 841 of file xreducer.hpp.

+ +
+
+ +

◆ substepper_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::substepper_type = typename inner_types::substepper_type
+
+ +

Definition at line 825 of file xreducer.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::value_type = typename inner_types::value_type
+
+ +

Definition at line 826 of file xreducer.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::xexpression_type = typename inner_types::xexpression_type
+
+ +

Definition at line 819 of file xreducer.hpp.

+ +
+
+ +

◆ xreducer_functors_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer< F, CT, X, O >::xreducer_functors_type = xreducer_functors<reduce_functor_type, init_functor_type, merge_functor_type>
+
+ +

Definition at line 817 of file xreducer.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xreducer()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class Func, class CTA, class AX, class OX>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xreducer< F, CT, X, O >::xreducer (Func && func,
CTA && e,
AX && axes,
OX && options )
+ 		+inline
+
+ +

Constructs an xreducer expression applying the specified function to the given expression over the given axes.

+
Parameters
+ + + + + +
functhe function to apply
ethe expression to reduce
axesthe axes along which the reduction is performed
optionsreducer options controlling evaluation strategy and related settings
+
+
+ +

Definition at line 1406 of file xreducer.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ broadcast_shape()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xreducer< F, CT, X, O >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the reducer to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 1601 of file xreducer.hpp.

+ +
+
+ +

◆ build_reducer() [1/2]

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xreducer< F, CT, X, O >::build_reducer (E && e) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 1639 of file xreducer.hpp.

+ +
+
+ +

◆ build_reducer() [2/2]

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class E, class Func, class Opts>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xreducer< F, CT, X, O >::build_reducer (E && e,
Func && func,
Opts && opts ) const -> rebind_t<E, Func, Opts> +
+ 		+inline
+
+ +

Definition at line 1651 of file xreducer.hpp.

+ +
+
+ +

◆ element()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xreducer< F, CT, X, O >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the reducer.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the number of dimensions of the reducer.
+
+
+ +

Definition at line 1552 of file xreducer.hpp.

+ +
+
+ +

◆ expression()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::xreducer< F, CT, X, O >::expression () const
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the underlying expression of the reducer.

+ +

Definition at line 1582 of file xreducer.hpp.

+ +
+
+ +

◆ functors()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
xreducer_functors_type xt::xreducer< F, CT, X, O >::functors () const
+ 		+inline
+
+ +

Definition at line 885 of file xreducer.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xreducer< F, CT, X, O >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xreducer can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 1613 of file xreducer.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
bool xt::xreducer< F, CT, X, O >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1489 of file xreducer.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
layout_type xt::xreducer< F, CT, X, O >::layout () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the expression.

+ +

Definition at line 1483 of file xreducer.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xreducer< F, CT, X, O >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the reducer.

+
Parameters
+ + +
argsa list of indices specifying the position in the reducer. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the reducer.
+
+
+ +

Definition at line 1508 of file xreducer.hpp.

+ +
+
+ +

◆ options()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
const O & xt::xreducer< F, CT, X, O >::options () const
+ 		+inline
+
+ +

Definition at line 892 of file xreducer.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::xreducer< F, CT, X, O >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the expression.

+ +

Definition at line 1474 of file xreducer.hpp.

+ +
+
+ +

◆ stepper_begin()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xreducer< F, CT, X, O >::stepper_begin (const S & shape) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 1622 of file xreducer.hpp.

+ +
+
+ +

◆ stepper_end()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xreducer< F, CT, X, O >::stepper_end (const S & shape,
layout_type l ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 1630 of file xreducer.hpp.

+ +
+
+ +

◆ unchecked()

+ +
+
+
+template<class F, class CT, class X, class O>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xreducer< F, CT, X, O >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the reducer.

+
Parameters
+ + +
argsa list of indices specifying the position in the reducer. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the reducer, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 1537 of file xreducer.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xreducer_stepper< F, CT, X, O >

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + +
friend class xreducer_stepper< F, CT, X, O >
+ 		+friend
+
+ +

Definition at line 906 of file xreducer.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + +
bool xt::xreducer< F, CT, X, O >::contiguous_layout = false
+ 		+staticconstexpr
+
+ +

Definition at line 846 of file xreducer.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + +
layout_type xt::xreducer< F, CT, X, O >::static_layout = layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 845 of file xreducer.hpp.

+ +
+
+
The documentation for this class was generated from the following files:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xmime.hpp
    • +
  • /home/runner/work/xtensor/xtensor/include/xtensor/reducers/xreducer.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xreducer.js b/classxt_1_1xreducer.js new file mode 100644 index 000000000..485d42643 --- /dev/null +++ b/classxt_1_1xreducer.js @@ -0,0 +1,12 @@ +var classxt_1_1xreducer = +[ + [ "xreducer", "classxt_1_1xreducer.html#ac1a504813c1a2d91e1aa5c871bee7a77", null ], + [ "broadcast_shape", "classxt_1_1xreducer.html#a20c55f56bcedfe9f3e3662253a922073", null ], + [ "element", "classxt_1_1xreducer.html#aa6b950db4c421bef297b1b1d76047b23", null ], + [ "expression", "classxt_1_1xreducer.html#a35efc1a78c0ad4a52cef8dca2a472a83", null ], + [ "has_linear_assign", "classxt_1_1xreducer.html#a6dc809c4eefc124d5bfb4d579afea715", null ], + [ "layout", "classxt_1_1xreducer.html#aeee3a89a9dd452a00cfd55cbbfd2aa17", null ], + [ "operator()", "classxt_1_1xreducer.html#a979a86f103f655328d35e67fcc5bca7b", null ], + [ "shape", "classxt_1_1xreducer.html#aaf23386e8c796f997a2e80c71e57e74c", null ], + [ "unchecked", "classxt_1_1xreducer.html#a55be3ba3c0268968d7c6efef7621e3e4", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xreducer.png b/classxt_1_1xreducer.png new file mode 100644 index 000000000..7c8bc8745 Binary files /dev/null and b/classxt_1_1xreducer.png differ diff --git a/classxt_1_1xreducer__stepper-members.html b/classxt_1_1xreducer__stepper-members.html new file mode 100644 index 000000000..b9acaae86 --- /dev/null +++ b/classxt_1_1xreducer__stepper-members.html @@ -0,0 +1,140 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xreducer_stepper< F, CT, X, O > Member List
+
+
+ +

This is the complete list of members for xt::xreducer_stepper< F, CT, X, O >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
operator*() const (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
pointer typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
reference typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
reset(size_type dim) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
reset_back(size_type dim) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
self_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
shape_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
size_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
step(size_type dim) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
step(size_type dim, size_type n) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
step_back(size_type dim) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
step_back(size_type dim, size_type n) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
substepper_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
to_begin() (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
to_end(layout_type l) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
value_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
xexpression_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
xreducer_stepper(const xreducer_type &red, size_type offset, bool end=false, layout_type l=default_assignable_layout(xexpression_type::static_layout)) (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >inline
xreducer_type typedef (defined in xt::xreducer_stepper< F, CT, X, O >)xt::xreducer_stepper< F, CT, X, O >
+
+ + + + diff --git a/classxt_1_1xreducer__stepper.html b/classxt_1_1xreducer__stepper.html new file mode 100644 index 000000000..6e322941a --- /dev/null +++ b/classxt_1_1xreducer__stepper.html @@ -0,0 +1,669 @@ + + + + + + + +xtensor: xt::xreducer_stepper< F, CT, X, O > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xreducer_stepper< F, CT, X, O > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xreducer_stepper<F, CT, X, O>
 
using xreducer_type = xreducer<F, CT, X, O>
 
using value_type = typename xreducer_type::value_type
 
using reference = typename xreducer_type::value_type
 
using pointer = typename xreducer_type::const_pointer
 
using size_type = typename xreducer_type::size_type
 
using difference_type = typename xreducer_type::difference_type
 
using xexpression_type = typename xreducer_type::xexpression_type
 
using substepper_type = typename xexpression_type::const_stepper
 
using shape_type = typename xreducer_type::shape_type
 
+ + + + + + + + + + + + + + + + + + + + + +

Broadcasting

 xreducer_stepper (const xreducer_type &red, size_type offset, bool end=false, layout_type l=default_assignable_layout(xexpression_type::static_layout))
 
reference operator* () const
 
void step (size_type dim)
 
void step_back (size_type dim)
 
void step (size_type dim, size_type n)
 
void step_back (size_type dim, size_type n)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
+

Detailed Description

+
template<class F, class CT, class X, class O>
+class xt::xreducer_stepper< F, CT, X, O >
+

Definition at line 1086 of file xreducer.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::difference_type = typename xreducer_type::difference_type
+
+ +

Definition at line 1097 of file xreducer.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::pointer = typename xreducer_type::const_pointer
+
+ +

Definition at line 1095 of file xreducer.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::reference = typename xreducer_type::value_type
+
+ +

Definition at line 1094 of file xreducer.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::self_type = xreducer_stepper<F, CT, X, O>
+
+ +

Definition at line 1090 of file xreducer.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::shape_type = typename xreducer_type::shape_type
+
+ +

Definition at line 1101 of file xreducer.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::size_type = typename xreducer_type::size_type
+
+ +

Definition at line 1096 of file xreducer.hpp.

+ +
+
+ +

◆ substepper_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::substepper_type = typename xexpression_type::const_stepper
+
+ +

Definition at line 1100 of file xreducer.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::value_type = typename xreducer_type::value_type
+
+ +

Definition at line 1093 of file xreducer.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::xexpression_type = typename xreducer_type::xexpression_type
+
+ +

Definition at line 1099 of file xreducer.hpp.

+ +
+
+ +

◆ xreducer_type

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + +
using xt::xreducer_stepper< F, CT, X, O >::xreducer_type = xreducer<F, CT, X, O>
+
+ +

Definition at line 1091 of file xreducer.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xreducer_stepper()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xreducer_stepper< F, CT, X, O >::xreducer_stepper (const xreducer_type & red,
size_type offset,
bool end = false,
layout_type l = default_assignable_layout(xexpression_type::static_layout) )
+ 		+inline
+
+ +

Definition at line 1667 of file xreducer.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
auto xt::xreducer_stepper< F, CT, X, O >::operator* () const
+ 		+inline
+
+ +

Definition at line 1684 of file xreducer.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 1727 of file xreducer.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 1744 of file xreducer.hpp.

+ +
+
+ +

◆ step() [1/2]

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::step (size_type dim)
+ 		+inline
+
+ +

Definition at line 1691 of file xreducer.hpp.

+ +
+
+ +

◆ step() [2/2]

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::step (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 1709 of file xreducer.hpp.

+ +
+
+ +

◆ step_back() [1/2]

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::step_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 1700 of file xreducer.hpp.

+ +
+
+ +

◆ step_back() [2/2]

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::step_back (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 1718 of file xreducer.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::to_begin ()
+ 		+inline
+
+ +

Definition at line 1760 of file xreducer.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class F, class CT, class X, class O>
+ + + + + +
+ + + + + + + +
void xt::xreducer_stepper< F, CT, X, O >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 1766 of file xreducer.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/reducers/xreducer.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xrepeat-members.html b/classxt_1_1xrepeat-members.html new file mode 100644 index 000000000..62008e1da --- /dev/null +++ b/classxt_1_1xrepeat-members.html @@ -0,0 +1,209 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xrepeat< CT, R > Member List
+
+
+ +

This is the complete list of members for xt::xrepeat< CT, R >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
access(Arg arg, Args... args) const -> const_reference (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
access_impl(stepper &&s, Arg arg, Args... args) const -> const_reference (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
access_impl(stepper &&s) const -> const_reference (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
accessible_base typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
at(Args... args) const -> const_referencext::xconst_accessible< xrepeat< CT, R > >inline
at(Args... args) const -> const_referencext::xconst_accessible< xrepeat< CT, R > >inline
back() constxt::xconst_accessible< xrepeat< CT, R > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
begin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
bool_load_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xrepeat< CT, R >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
cbegin() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
cend() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
const_pointer typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
const_reference typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
const_stepper typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
container_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
contiguous_layout (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >static
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
crbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
crend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
xt::derived_cast() &noexceptxt::xexpression< xrepeat< CT, R > >inline
xt::xsharable_expression< xrepeat< CT, R > >::derived_cast() const &noexceptxt::xexpression< xrepeat< CT, R > >inline
xt::xsharable_expression< xrepeat< CT, R > >::derived_cast() &&noexceptxt::xexpression< xrepeat< CT, R > >inline
difference_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
dimension() const noexceptxt::xconst_accessible< xrepeat< CT, R > >inline
element(It first, It last) const (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
element(It first, It last) const -> const_referencext::xrepeat< CT, R >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
end() const noexcept -> const_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
expression() const noexceptxt::xrepeat< CT, R >inline
expression_tag typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
extension_base typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
front() constxt::xconst_accessible< xrepeat< CT, R > >inline
has_linear_assign(const S &strides) const noexceptxt::xrepeat< CT, R >inline
in_bounds(Args... args) constxt::xconst_accessible< xrepeat< CT, R > >inline
is_contiguous() const noexcept (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
iterable_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
layout() const noexceptxt::xrepeat< CT, R >inline
operator()(Args... args) const (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
operator()(Args... args) const -> const_referencext::xrepeat< CT, R >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xconst_accessible< xrepeat< CT, R > >inline
operator[](const S &index) const -> disable_integral_t< S, const_reference >xt::xconst_accessible< xrepeat< CT, R > >inline
periodic(Args... args) const -> const_referencext::xconst_accessible< xrepeat< CT, R > >inline
periodic(Args... args) const -> const_referencext::xconst_accessible< xrepeat< CT, R > >inline
pointer typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
rbegin() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
reference typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
rend() const noexcept -> const_reverse_layout_iterator< L >xt::xconst_iterable< xrepeat< CT, R > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xconst_iterable< xrepeat< CT, R > >inline
repeats_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
self_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
shape() const noexceptxt::xrepeat< CT, R >inline
shape(size_type index) constxt::xrepeat< CT, R >
shape_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
size() const noexcept(noexcept(derived_cast().shape()))xt::xrepeat< CT, R >
size_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
static_layout (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >static
stepper typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
stepper_begin() const (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
stepper_begin(const shape_type &s) const (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
stepper_end(layout_type l) const (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
stepper_end(const shape_type &s, layout_type l) const (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >inline
temporary_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
unchecked(Args... args) const (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
unchecked(Args... args) const -> const_referencext::xrepeat< CT, R >inline
value_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
xexpression_type typedef (defined in xt::xrepeat< CT, R >)xt::xrepeat< CT, R >
xrepeat(CTA &&e, R &&repeats, size_type axis)xt::xrepeat< CT, R >explicit
+
+ + + + diff --git a/classxt_1_1xrepeat.html b/classxt_1_1xrepeat.html new file mode 100644 index 000000000..c9a2ec150 --- /dev/null +++ b/classxt_1_1xrepeat.html @@ -0,0 +1,1644 @@ + + + + + + + +xtensor: xt::xrepeat< CT, R > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::xrepeat< CT, R > Class Template Reference
+
+
+ +

Expression with repeated values along an axis. + More...

+ +

#include <xrepeat.hpp>

+
+Inheritance diagram for xt::xrepeat< CT, R >:
+
+
+ + +xt::xconst_iterable< xrepeat< CT, R > > +xt::xconst_accessible< xrepeat< CT, R > > +xt::xsharable_expression< xrepeat< CT, R > > +xt::xexpression< xrepeat< CT, R > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xrepeat<CT, R>
 
using xexpression_type = std::decay_t<CT>
 
using accessible_base = xconst_accessible<self_type>
 
using extension_base = extension::xrepeat_base_t<CT, R>
 
using expression_tag = typename extension_base::expression_tag
 
using value_type = typename xexpression_type::value_type
 
using shape_type = typename xexpression_type::shape_type
 
using repeats_type = xtl::const_closure_type_t<R>
 
using container_type = xcontainer_inner_types<xrepeat<CT, R>>
 
using reference = typename container_type::reference
 
using const_reference = typename container_type::const_reference
 
using size_type = typename container_type::size_type
 
using temporary_type = typename container_type::temporary_type
 
using bool_load_type = typename xexpression_type::bool_load_type
 
using pointer = typename xexpression_type::pointer
 
using const_pointer = typename xexpression_type::const_pointer
 
using difference_type = typename xexpression_type::difference_type
 
using iterable_type = xiterable<xrepeat<CT, R>>
 
using stepper = typename iterable_type::stepper
 
using const_stepper = typename iterable_type::const_stepper
 
- Public Types inherited from xt::xconst_iterable< xrepeat< CT, R > >
using derived_type
 
using iterable_types
 
using inner_shape_type
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xconst_accessible< xrepeat< CT, R > >
using derived_type
 
using inner_types
 
using reference
 
using const_reference
 
using size_type
 
- Public Types inherited from xt::xexpression< xrepeat< CT, R > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class CTA>
 xrepeat (CTA &&e, R &&repeats, size_type axis)
 Constructs an xrepeat expression repeating the element of the specified xexpression.
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
const_reference element (It first, It last) const
 
+size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
+size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
Size and shape
const shape_type & shape () const noexcept
 Returns the shape of the expression.
 
layout_type layout () const noexcept
 Returns the layout_type of the expression.
 
bool is_contiguous () const noexcept
 
Data
const xexpression_type & expression () const noexcept
 Returns a constant reference to the underlying expression of the broadcast expression.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the view.
 
- Public Member Functions inherited from xt::xconst_iterable< xrepeat< CT, R > >
+const_layout_iterator< L > begin () const noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+const_layout_iterator< L > end () const noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+const_layout_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+const_layout_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > rend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+const_reverse_layout_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> const_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> const_reverse_layout_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto get_cbegin (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cbegin (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_cend (bool end_index) const noexcept -> const_layout_iterator< L >
 
auto get_cend (const S &shape, bool end_index) const noexcept -> const_broadcast_iterator< S, L >
 
auto get_stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto get_stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
- Public Member Functions inherited from xt::xconst_accessible< xrepeat< CT, R > >
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+const_reference at (Args... args) const
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
+const_reference periodic (Args... args) const
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
- Public Member Functions inherited from xt::xexpression< xrepeat< CT, R > >
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = xexpression_type::static_layout
 
static constexpr bool contiguous_layout = false
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the function to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xbroadcast can be linearly assigned to an expression with the specified strides.
 
const_stepper stepper_begin () const
 
const_stepper stepper_begin (const shape_type &s) const
 
const_stepper stepper_end (layout_type l) const
 
const_stepper stepper_end (const shape_type &s, layout_type l) const
 
template<class Arg, class... Args>
auto access (Arg arg, Args... args) const -> const_reference
 
template<std::size_t I, class Arg, class... Args>
auto access_impl (stepper &&s, Arg arg, Args... args) const -> const_reference
 
template<std::size_t I>
auto access_impl (stepper &&s) const -> const_reference
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

const inner_shape_type & get_shape () const
 
- Protected Member Functions inherited from xt::xconst_accessible< xrepeat< CT, R > >
+ xconst_accessible (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
- Protected Member Functions inherited from xt::xsharable_expression< xrepeat< CT, R > >
+ xsharable_expression (const xsharable_expression &)=default
 
+ xsharable_expression (xsharable_expression &&)=default
 
+xsharable_expression & operator= (const xsharable_expression &)=default
 
+xsharable_expression & operator= (xsharable_expression &&)=default
 
- Protected Member Functions inherited from xt::xexpression< xrepeat< CT, R > >
+ xexpression (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (const xexpression &)=default
 
+xexpression & operator= (xexpression &&)=default
 
+

Detailed Description

+
template<class CT, class R>
+class xt::xrepeat< CT, R >

Expression with repeated values along an axis.

+

The xrepeat class implements the repetition of the elements of an xexpression along a given axis. xrepeat is not meant to be used directly, but only with the repeat helper functions.

+
See also
repeat
+ +

Definition at line 96 of file xrepeat.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::accessible_base = xconst_accessible<self_type>
+
+ +

Definition at line 105 of file xrepeat.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::bool_load_type = typename xexpression_type::bool_load_type
+
+ +

Definition at line 122 of file xrepeat.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::const_pointer = typename xexpression_type::const_pointer
+
+ +

Definition at line 124 of file xrepeat.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::const_reference = typename container_type::const_reference
+
+ +

Definition at line 115 of file xrepeat.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::const_stepper = typename iterable_type::const_stepper
+
+ +

Definition at line 129 of file xrepeat.hpp.

+ +
+
+ +

◆ container_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::container_type = xcontainer_inner_types<xrepeat<CT, R>>
+
+ +

Definition at line 113 of file xrepeat.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 125 of file xrepeat.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 107 of file xrepeat.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::extension_base = extension::xrepeat_base_t<CT, R>
+
+ +

Definition at line 106 of file xrepeat.hpp.

+ +
+
+ +

◆ iterable_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::iterable_type = xiterable<xrepeat<CT, R>>
+
+ +

Definition at line 127 of file xrepeat.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::pointer = typename xexpression_type::pointer
+
+ +

Definition at line 123 of file xrepeat.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::reference = typename container_type::reference
+
+ +

Definition at line 114 of file xrepeat.hpp.

+ +
+
+ +

◆ repeats_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::repeats_type = xtl::const_closure_type_t<R>
+
+ +

Definition at line 111 of file xrepeat.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::self_type = xrepeat<CT, R>
+
+ +

Definition at line 103 of file xrepeat.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::shape_type = typename xexpression_type::shape_type
+
+ +

Definition at line 110 of file xrepeat.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::size_type = typename container_type::size_type
+
+ +

Definition at line 116 of file xrepeat.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::stepper = typename iterable_type::stepper
+
+ +

Definition at line 128 of file xrepeat.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::temporary_type = typename container_type::temporary_type
+
+ +

Definition at line 117 of file xrepeat.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::value_type = typename xexpression_type::value_type
+
+ +

Definition at line 109 of file xrepeat.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT, class R>
+ + + + +
using xt::xrepeat< CT, R >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 104 of file xrepeat.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xrepeat()

+ +
+
+
+template<class CT, class R>
+
+template<class CTA>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xrepeat< CT, R >::xrepeat (CTA && e,
R && repeats,
size_type axis )
+ 		+explicit
+
+ +

Constructs an xrepeat expression repeating the element of the specified xexpression.

+
Parameters
+ + + + +
ethe input expression
repeatsThe number of repetitions for each elements
axisThe axis along which to repeat the value
+
+
+ +

Definition at line 259 of file xrepeat.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ access()

+ +
+
+
+template<class CT, class R>
+
+template<class Arg, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xrepeat< CT, R >::access (Arg arg,
Args... args ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 417 of file xrepeat.hpp.

+ +
+
+ +

◆ access_impl() [1/2]

+ +
+
+
+template<class CT, class R>
+
+template<std::size_t I>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::access_impl (stepper && s) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 463 of file xrepeat.hpp.

+ +
+
+ +

◆ access_impl() [2/2]

+ +
+
+
+template<class CT, class R>
+
+template<std::size_t I, class Arg, class... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xrepeat< CT, R >::access_impl (stepper && s,
Arg arg,
Args... args ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 455 of file xrepeat.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class CT, class R>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xrepeat< CT, R >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the function to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 390 of file xrepeat.hpp.

+ +
+
+ +

◆ element()

+ +
+
+
+template<class CT, class R>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xrepeat< CT, R >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the view.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the the number of dimensions of the view..
+
+
+ +

Definition at line 353 of file xrepeat.hpp.

+ +
+
+ +

◆ expression()

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::expression () const
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the underlying expression of the broadcast expression.

+ +

Definition at line 371 of file xrepeat.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CT, class R>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xrepeat< CT, R >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xbroadcast can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 402 of file xrepeat.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + +
bool xt::xrepeat< CT, R >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 294 of file xrepeat.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::layout () const
+ 		+inlinenoexcept
+
+ +

Returns the layout_type of the expression.

+ +

Definition at line 288 of file xrepeat.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class CT, class R>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the function. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the expression.
+
+
+ +

Definition at line 313 of file xrepeat.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the expression.

+ +

Definition at line 279 of file xrepeat.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::stepper_begin () const
+ 		+inline
+
+ +

Definition at line 428 of file xrepeat.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::stepper_begin (const shape_type & s) const
+ 		+inline
+
+ +

Definition at line 434 of file xrepeat.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xrepeat< CT, R >::stepper_end (const shape_type & s,
layout_type l ) const
+ 		+inline
+
+ +

Definition at line 446 of file xrepeat.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::stepper_end (layout_type l) const
+ 		+inline
+
+ +

Definition at line 440 of file xrepeat.hpp.

+ +
+
+ +

◆ unchecked()

+ +
+
+
+template<class CT, class R>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat< CT, R >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the expression.

+
Parameters
+ + +
argsa list of indices specifying the position in the expression. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the expression, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 339 of file xrepeat.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + +
bool xt::xrepeat< CT, R >::contiguous_layout = false
+ 		+staticconstexpr
+
+ +

Definition at line 120 of file xrepeat.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CT, class R>
+ + + + + +
+ + + + +
layout_type xt::xrepeat< CT, R >::static_layout = xexpression_type::static_layout
+ 		+staticconstexpr
+
+ +

Definition at line 119 of file xrepeat.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xrepeat.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xrepeat.js b/classxt_1_1xrepeat.js new file mode 100644 index 000000000..20bac2f30 --- /dev/null +++ b/classxt_1_1xrepeat.js @@ -0,0 +1,14 @@ +var classxt_1_1xrepeat = +[ + [ "xrepeat", "classxt_1_1xrepeat.html#a8597732ef22eb32ab54d780d1410386f", null ], + [ "broadcast_shape", "classxt_1_1xrepeat.html#a2610f596c5e9b7475d30aa36132a93be", null ], + [ "element", "classxt_1_1xrepeat.html#a38462b0a1711572653036bb3f77e4d2a", null ], + [ "expression", "classxt_1_1xrepeat.html#a54a644b7c615e8f1bca91c0f4ac5a714", null ], + [ "has_linear_assign", "classxt_1_1xrepeat.html#a1cf9569d72c1fb3af6e2e29252b9f03b", null ], + [ "layout", "classxt_1_1xrepeat.html#a44b37d9a8b603737eec64e57ce108ad0", null ], + [ "operator()", "classxt_1_1xrepeat.html#aa896d82b715c106f2424266feabfe7d9", null ], + [ "shape", "classxt_1_1xrepeat.html#abbeb6ae19bc34035323c7577c65f0d84", null ], + [ "shape", "classxt_1_1xrepeat.html#ae7b5c2b34c43d49a8f2f82bd80ef30eb", null ], + [ "size", "classxt_1_1xrepeat.html#acf990ad65941e747a737622343bb43c2", null ], + [ "unchecked", "classxt_1_1xrepeat.html#af545974287e021de5253fcfd602d2f6a", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xrepeat.png b/classxt_1_1xrepeat.png new file mode 100644 index 000000000..5df3e7038 Binary files /dev/null and b/classxt_1_1xrepeat.png differ diff --git a/classxt_1_1xrepeat__stepper-members.html b/classxt_1_1xrepeat__stepper-members.html new file mode 100644 index 000000000..c7dcc3c4d --- /dev/null +++ b/classxt_1_1xrepeat__stepper-members.html @@ -0,0 +1,143 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xrepeat_stepper< S, R > Member List
+
+
+ +

This is the complete list of members for xt::xrepeat_stepper< S, R >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
operator*() const (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
pointer typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
reference typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
repeats_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
reset(size_type dim) (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
reset_back(size_type dim) (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
shape_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
simd_return_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
simd_value_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
size_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
step(size_type dim, size_type n=1) (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
step_back(size_type dim, size_type n=1) (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
step_leading() (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
step_simd() (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
storage_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
store_simd(const V &vec) (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
subiterator_traits typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
subiterator_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
to_begin() (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
to_end(layout_type l) (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >inline
value_type typedef (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
xrepeat_stepper(S &&s, const shape_type &shape, const repeats_type &repeats, size_type axis) (defined in xt::xrepeat_stepper< S, R >)xt::xrepeat_stepper< S, R >
+
+ + + + diff --git a/classxt_1_1xrepeat__stepper.html b/classxt_1_1xrepeat__stepper.html new file mode 100644 index 000000000..fab2e6186 --- /dev/null +++ b/classxt_1_1xrepeat__stepper.html @@ -0,0 +1,685 @@ + + + + + + + +xtensor: xt::xrepeat_stepper< S, R > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xrepeat_stepper< S, R > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using repeats_type = R
 
using storage_type = typename S::storage_type
 
using subiterator_type = typename S::subiterator_type
 
using subiterator_traits = typename S::subiterator_traits
 
using value_type = typename subiterator_traits::value_type
 
using reference = typename subiterator_traits::reference
 
using pointer = typename subiterator_traits::pointer
 
using difference_type = typename subiterator_traits::difference_type
 
using size_type = typename storage_type::size_type
 
using shape_type = typename storage_type::shape_type
 
using simd_value_type = xt_simd::simd_type<value_type>
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
+ + + + + + + +

+Public Member Functions

+template<class T>
simd_return_type< T > step_simd ()
 
+template<class V>
void store_simd (const V &vec)
 
+ + + + + + + + + + + + + + + + + + + +

Broadcasting

 xrepeat_stepper (S &&s, const shape_type &shape, const repeats_type &repeats, size_type axis)
 
reference operator* () const
 
void step (size_type dim, size_type n=1)
 
void step_back (size_type dim, size_type n=1)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
void step_leading ()
 
+

Detailed Description

+
template<class S, class R>
+class xt::xrepeat_stepper< S, R >
+

Definition at line 187 of file xrepeat.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::difference_type = typename subiterator_traits::difference_type
+
+ +

Definition at line 198 of file xrepeat.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::pointer = typename subiterator_traits::pointer
+
+ +

Definition at line 197 of file xrepeat.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::reference = typename subiterator_traits::reference
+
+ +

Definition at line 196 of file xrepeat.hpp.

+ +
+
+ +

◆ repeats_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::repeats_type = R
+
+ +

Definition at line 191 of file xrepeat.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::shape_type = typename storage_type::shape_type
+
+ +

Definition at line 200 of file xrepeat.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<class S, class R>
+
+template<class requested_type>
+ + + + +
using xt::xrepeat_stepper< S, R >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 204 of file xrepeat.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 201 of file xrepeat.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::size_type = typename storage_type::size_type
+
+ +

Definition at line 199 of file xrepeat.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::storage_type = typename S::storage_type
+
+ +

Definition at line 192 of file xrepeat.hpp.

+ +
+
+ +

◆ subiterator_traits

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::subiterator_traits = typename S::subiterator_traits
+
+ +

Definition at line 194 of file xrepeat.hpp.

+ +
+
+ +

◆ subiterator_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::subiterator_type = typename S::subiterator_type
+
+ +

Definition at line 193 of file xrepeat.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class S, class R>
+ + + + +
using xt::xrepeat_stepper< S, R >::value_type = typename subiterator_traits::value_type
+
+ +

Definition at line 195 of file xrepeat.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xrepeat_stepper()

+ +
+
+
+template<class S, class R>
+ + + + + + + + + + + + + + + + + + + + + +
xt::xrepeat_stepper< S, R >::xrepeat_stepper (S && s,
const shape_type & shape,
const repeats_type & repeats,
size_type axis )
+
+ +

Definition at line 473 of file xrepeat.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + +
auto xt::xrepeat_stepper< S, R >::operator* () const
+ 		+inline
+
+ +

Definition at line 485 of file xrepeat.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + +
void xt::xrepeat_stepper< S, R >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 541 of file xrepeat.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + +
void xt::xrepeat_stepper< S, R >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 553 of file xrepeat.hpp.

+ +
+
+ +

◆ step()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + + + + + +
void xt::xrepeat_stepper< S, R >::step (size_type dim,
size_type n = 1 )
+ 		+inline
+
+ +

Definition at line 491 of file xrepeat.hpp.

+ +
+
+ +

◆ step_back()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + + + + + +
void xt::xrepeat_stepper< S, R >::step_back (size_type dim,
size_type n = 1 )
+ 		+inline
+
+ +

Definition at line 516 of file xrepeat.hpp.

+ +
+
+ +

◆ step_leading()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + +
void xt::xrepeat_stepper< S, R >::step_leading ()
+ 		+inline
+
+ +

Definition at line 599 of file xrepeat.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + +
void xt::xrepeat_stepper< S, R >::to_begin ()
+ 		+inline
+
+ +

Definition at line 565 of file xrepeat.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class S, class R>
+ + + + + +
+ + + + + + + +
void xt::xrepeat_stepper< S, R >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 574 of file xrepeat.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xrepeat.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xscalar-members.html b/classxt_1_1xscalar-members.html new file mode 100644 index 000000000..ec824e990 --- /dev/null +++ b/classxt_1_1xscalar-members.html @@ -0,0 +1,276 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xscalar< CT > Member List
+
+
+ +

This is the complete list of members for xt::xscalar< CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
at(Args... args) (defined in xt::xscalar< CT >)xt::xscalar< CT >
back()xt::xscalar< CT >
xt::xaccessible< xscalar< CT > >::back() constxt::xaccessible< xscalar< CT > >private
begin() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
begin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
begin(const S &shape) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
begin(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
begin() noexcept -> iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
begin() const noexcept -> const_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
bool_load_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
broadcast_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
broadcast_shape(S &shape, bool reuse_cache=false) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
cbegin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
cbegin(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
cbegin() const noexcept -> const_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
cend() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
cend(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
cend() const noexcept -> const_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
const_broadcast_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_dummy_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_layout_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_pointer typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_reference typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_reverse_broadcast_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_reverse_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_reverse_layout_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
const_stepper typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
contiguous_layout (defined in xt::xscalar< CT >)xt::xscalar< CT >static
crbegin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
crbegin(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
crbegin() const noexcept -> const_reverse_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
crend() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
crend(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
crend() const noexcept -> const_reverse_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
data_element(size_type i) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
data_element(size_type i) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
xt::derived_cast() &noexceptxt::xexpression< xscalar< CT > >inline
xt::derived_cast() const &noexceptxt::xexpression< xscalar< CT > >inline
xt::derived_cast() &&noexceptxt::xexpression< xscalar< CT > >inline
difference_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
dummy_begin() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
dummy_begin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
dummy_end() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
dummy_end() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
dummy_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
element(It, It) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
element(It, It) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
element(It, It) noexcept -> reference (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
element(It, It) const noexcept -> const_reference (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
end() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
end() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
end(const S &shape) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
end(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
end() noexcept -> iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
end() const noexcept -> const_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
expression() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
expression() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
expression_tag typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
extension_base typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
flat(size_type i) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
flat(size_type i) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
front()xt::xscalar< CT >
xt::xaccessible< xscalar< CT > >::front() constxt::xaccessible< xscalar< CT > >private
has_linear_assign(const S &strides) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
inner_shape_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
inner_types typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
is_contiguous() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
iterable_base typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
layout() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
layout_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
linear_begin() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_begin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_cbegin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_cend() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_crbegin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_crend() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_end() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_end() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_rbegin() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_rbegin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_rend() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
linear_rend() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
load_simd(size_type i) const (defined in xt::xscalar< CT >)xt::xscalar< CT >
load_simd(size_type) const -> xt_simd::simd_return_type< value_type, requested_type > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
operator const value_type &() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
operator value_type &() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
operator()(Args...) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
operator()(Args...) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
operator()(Args...) noexcept -> reference (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
operator()(Args...) const noexcept -> const_reference (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
operator[](const S &index) (defined in xt::xscalar< CT >)xt::xscalar< CT >
operator[](std::initializer_list< I > index) (defined in xt::xscalar< CT >)xt::xscalar< CT >
operator[](size_type i) (defined in xt::xscalar< CT >)xt::xscalar< CT >
periodic(Args... args) (defined in xt::xscalar< CT >)xt::xscalar< CT >
pointer typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
rbegin() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rbegin() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rbegin(const S &shape) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rbegin(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rbegin() noexcept -> reverse_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
rbegin() const noexcept -> const_reverse_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
reference typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
rend() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rend() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rend(const S &shape) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rend(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
rend() noexcept -> reverse_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
rend() const noexcept -> const_reverse_iterator (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L > (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
reverse_broadcast_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
reverse_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
reverse_layout_iterator typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
self_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
shape() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
shape(size_type i) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
shape_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
simd_value_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
size() const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
size_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
static_layout (defined in xt::xscalar< CT >)xt::xscalar< CT >static
stepper typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
stepper_begin(const S &shape) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
stepper_begin(const S &shape) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
stepper_begin(const S &) noexcept -> stepper (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
stepper_begin(const S &) const noexcept -> const_stepper (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
stepper_end(const S &shape, layout_type l) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
stepper_end(const S &, layout_type) noexcept -> stepper (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
stepper_end(const S &, layout_type) const noexcept -> const_stepper (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
store_simd(size_type i, const simd &e) (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
unchecked(Args...) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
unchecked(Args...) const noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >
unchecked(Args...) noexcept -> reference (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
unchecked(Args...) const noexcept -> const_reference (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
value_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
xaccessible< self_type > (defined in xt::xscalar< CT >)xt::xscalar< CT >friend
xconst_accessible< self_type > (defined in xt::xscalar< CT >)xt::xscalar< CT >friend
xconst_iterable< self_type > (defined in xt::xscalar< CT >)xt::xscalar< CT >friend
xexpression_type typedef (defined in xt::xscalar< CT >)xt::xscalar< CT >
xiterable< self_type > (defined in xt::xscalar< CT >)xt::xscalar< CT >friend
xscalar() noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
xscalar(CT value) noexcept (defined in xt::xscalar< CT >)xt::xscalar< CT >inline
+
+ + + + diff --git a/classxt_1_1xscalar.html b/classxt_1_1xscalar.html new file mode 100644 index 000000000..acc354659 --- /dev/null +++ b/classxt_1_1xscalar.html @@ -0,0 +1,3548 @@ + + + + + + + +xtensor: xt::xscalar< CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xscalar< CT > Class Template Reference
+
+
+
+Inheritance diagram for xt::xscalar< CT >:
+
+
+ + +xt::xsharable_expression< xscalar< CT > > +xt::xiterable< xscalar< CT > > +xt::xaccessible< xscalar< CT > > +xt::xexpression< xscalar< CT > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xscalar<CT>
 
using xexpression_type = std::decay_t<CT>
 
using extension_base = extension::xscalar_base_t<CT>
 
using accessible_base = xaccessible<self_type>
 
using expression_tag = typename extension_base::expression_tag
 
using inner_types = xcontainer_inner_types<self_type>
 
using value_type = typename inner_types::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = value_type*
 
using const_pointer = const value_type*
 
using size_type = typename inner_types::size_type
 
using difference_type = std::ptrdiff_t
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = xt::bool_load_type<value_type>
 
using iterable_base = xiterable<self_type>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using shape_type = inner_shape_type
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
template<layout_type L>
using layout_iterator = typename iterable_base::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
 
using iterator = value_type*
 
using const_iterator = const value_type*
 
using reverse_iterator = std::reverse_iterator<iterator>
 
using const_reverse_iterator = std::reverse_iterator<const_iterator>
 
using dummy_iterator = xdummy_iterator<false, CT>
 
using const_dummy_iterator = xdummy_iterator<true, CT>
 
- Public Types inherited from xt::xexpression< xscalar< CT > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xscalar (CT value) noexcept
 
 operator value_type & () noexcept
 
 operator const value_type & () const noexcept
 
size_type size () const noexcept
 
const shape_type & shape () const noexcept
 
size_type shape (size_type i) const noexcept
 
layout_type layout () const noexcept
 
bool is_contiguous () const noexcept
 
+template<class... Args>
reference operator() (Args...) noexcept
 
+template<class... Args>
reference unchecked (Args...) noexcept
 
+template<class... Args>
const_reference operator() (Args...) const noexcept
 
+template<class... Args>
const_reference unchecked (Args...) const noexcept
 
+template<class It>
reference element (It, It) noexcept
 
+template<class It>
const_reference element (It, It) const noexcept
 
xexpression_type & expression () noexcept
 
const xexpression_type & expression () const noexcept
 
template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const noexcept
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
iterator begin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
iterator end () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_iterator begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_iterator end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_iterator cbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_iterator cend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_iterator rbegin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
reverse_iterator rend () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_iterator rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_iterator rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_iterator crbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
const_reverse_iterator crend () const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<class S, layout_type L = ::xt::layout_type::row_major>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
iterator linear_begin () noexcept
 
iterator linear_end () noexcept
 
const_iterator linear_begin () const noexcept
 
const_iterator linear_end () const noexcept
 
const_iterator linear_cbegin () const noexcept
 
const_iterator linear_cend () const noexcept
 
reverse_iterator linear_rbegin () noexcept
 
reverse_iterator linear_rend () noexcept
 
const_reverse_iterator linear_rbegin () const noexcept
 
const_reverse_iterator linear_rend () const noexcept
 
const_reverse_iterator linear_crbegin () const noexcept
 
const_reverse_iterator linear_crend () const noexcept
 
+template<class S>
stepper stepper_begin (const S &shape) noexcept
 
+template<class S>
stepper stepper_end (const S &shape, layout_type l) noexcept
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
dummy_iterator dummy_begin () noexcept
 
dummy_iterator dummy_end () noexcept
 
const_dummy_iterator dummy_begin () const noexcept
 
const_dummy_iterator dummy_end () const noexcept
 
reference data_element (size_type i) noexcept
 
const_reference data_element (size_type i) const noexcept
 
reference flat (size_type i) noexcept
 
const_reference flat (size_type i) const noexcept
 
template<class align, class simd = simd_value_type>
void store_simd (size_type i, const simd &e)
 
+template<class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
xt_simd::simd_return_type< value_type, requested_type > load_simd (size_type i) const
 
template<class... Args>
auto operator() (Args...) noexcept -> reference
 
template<class... Args>
auto unchecked (Args...) noexcept -> reference
 
template<class... Args>
auto operator() (Args...) const noexcept -> const_reference
 
template<class... Args>
auto unchecked (Args...) const noexcept -> const_reference
 
template<class It>
auto element (It, It) noexcept -> reference
 
template<class It>
auto element (It, It) const noexcept -> const_reference
 
template<layout_type L>
auto begin () noexcept -> iterator
 
template<layout_type L>
auto end () noexcept -> iterator
 
template<layout_type L>
auto begin () const noexcept -> const_iterator
 
template<layout_type L>
auto end () const noexcept -> const_iterator
 
template<layout_type L>
auto cbegin () const noexcept -> const_iterator
 
template<layout_type L>
auto cend () const noexcept -> const_iterator
 
template<layout_type L>
auto rbegin () noexcept -> reverse_iterator
 
template<layout_type L>
auto rend () noexcept -> reverse_iterator
 
template<layout_type L>
auto rbegin () const noexcept -> const_reverse_iterator
 
template<layout_type L>
auto rend () const noexcept -> const_reverse_iterator
 
template<layout_type L>
auto crbegin () const noexcept -> const_reverse_iterator
 
template<layout_type L>
auto crend () const noexcept -> const_reverse_iterator
 
template<class S, layout_type L>
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 
template<class S, layout_type L>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 
template<class S>
auto stepper_begin (const S &) noexcept -> stepper
 
template<class S>
auto stepper_end (const S &, layout_type) noexcept -> stepper
 
template<class S>
auto stepper_begin (const S &) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &, layout_type) const noexcept -> const_stepper
 
template<class align, class requested_type, std::size_t N>
auto load_simd (size_type) const -> xt_simd::simd_return_type< value_type, requested_type >
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
- Public Member Functions inherited from xt::xexpression< xscalar< CT > >
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = layout_type::any
 
static constexpr bool contiguous_layout = true
 
+ + + + + + + + + +

+Friends

class xconst_iterable< self_type >
 
class xiterable< self_type >
 
class xaccessible< self_type >
 
class xconst_accessible< self_type >
 
+ + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xsharable_expression< xscalar< CT > >
+ xsharable_expression (const xsharable_expression &)=default
 
+ xsharable_expression (xsharable_expression &&)=default
 
+xsharable_expression & operator= (const xsharable_expression &)=default
 
+xsharable_expression & operator= (xsharable_expression &&)=default
 
- Protected Member Functions inherited from xt::xexpression< xscalar< CT > >
+ xexpression (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (const xexpression &)=default
 
+xexpression & operator= (xexpression &&)=default
 
+

Detailed Description

+
template<class CT>
+class xt::xscalar< CT >
+

Definition at line 85 of file xscalar.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::accessible_base = xaccessible<self_type>
+
+ +

Definition at line 95 of file xscalar.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::bool_load_type = xt::bool_load_type<value_type>
+
+ +

Definition at line 107 of file xscalar.hpp.

+ +
+
+ +

◆ broadcast_iterator

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xscalar< CT >::broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
+
+ +

Definition at line 127 of file xscalar.hpp.

+ +
+
+ +

◆ const_broadcast_iterator

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xscalar< CT >::const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
+
+ +

Definition at line 129 of file xscalar.hpp.

+ +
+
+ +

◆ const_dummy_iterator

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::const_dummy_iterator = xdummy_iterator<true, CT>
+
+ +

Definition at line 142 of file xscalar.hpp.

+ +
+
+ +

◆ const_iterator

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::const_iterator = const value_type*
+
+ +

Definition at line 137 of file xscalar.hpp.

+ +
+
+ +

◆ const_layout_iterator

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + +
using xt::xscalar< CT >::const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
+
+ +

Definition at line 119 of file xscalar.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::const_pointer = const value_type*
+
+ +

Definition at line 103 of file xscalar.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 101 of file xscalar.hpp.

+ +
+
+ +

◆ const_reverse_broadcast_iterator

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xscalar< CT >::const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 134 of file xscalar.hpp.

+ +
+
+ +

◆ const_reverse_iterator

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::const_reverse_iterator = std::reverse_iterator<const_iterator>
+
+ +

Definition at line 139 of file xscalar.hpp.

+ +
+
+ +

◆ const_reverse_layout_iterator

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + +
using xt::xscalar< CT >::const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
+
+ +

Definition at line 124 of file xscalar.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 114 of file xscalar.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::difference_type = std::ptrdiff_t
+
+ +

Definition at line 105 of file xscalar.hpp.

+ +
+
+ +

◆ dummy_iterator

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::dummy_iterator = xdummy_iterator<false, CT>
+
+ +

Definition at line 141 of file xscalar.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 96 of file xscalar.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::extension_base = extension::xscalar_base_t<CT>
+
+ +

Definition at line 94 of file xscalar.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 110 of file xscalar.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 97 of file xscalar.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::iterable_base = xiterable<self_type>
+
+ +

Definition at line 109 of file xscalar.hpp.

+ +
+
+ +

◆ iterator

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::iterator = value_type*
+
+ +

Definition at line 136 of file xscalar.hpp.

+ +
+
+ +

◆ layout_iterator

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + +
using xt::xscalar< CT >::layout_iterator = typename iterable_base::template layout_iterator<L>
+
+ +

Definition at line 117 of file xscalar.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::pointer = value_type*
+
+ +

Definition at line 102 of file xscalar.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::reference = typename inner_types::reference
+
+ +

Definition at line 100 of file xscalar.hpp.

+ +
+
+ +

◆ reverse_broadcast_iterator

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + +
using xt::xscalar< CT >::reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
+
+ +

Definition at line 132 of file xscalar.hpp.

+ +
+
+ +

◆ reverse_iterator

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::reverse_iterator = std::reverse_iterator<iterator>
+
+ +

Definition at line 138 of file xscalar.hpp.

+ +
+
+ +

◆ reverse_layout_iterator

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + +
using xt::xscalar< CT >::reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
+
+ +

Definition at line 122 of file xscalar.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::self_type = xscalar<CT>
+
+ +

Definition at line 92 of file xscalar.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::shape_type = inner_shape_type
+
+ +

Definition at line 111 of file xscalar.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 106 of file xscalar.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::size_type = typename inner_types::size_type
+
+ +

Definition at line 104 of file xscalar.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 113 of file xscalar.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::value_type = typename inner_types::value_type
+
+ +

Definition at line 99 of file xscalar.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT>
+ + + + +
using xt::xscalar< CT >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 93 of file xscalar.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xscalar() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
xt::xscalar< CT >::xscalar ()
+ 		+inlinenoexcept
+
+ +

Definition at line 498 of file xscalar.hpp.

+ +
+
+ +

◆ xscalar() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
xt::xscalar< CT >::xscalar (CT value)
+ 		+inlinenoexcept
+
+ +

Definition at line 504 of file xscalar.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ begin() [1/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::begin () const -> const_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 638 of file xscalar.hpp.

+ +
+
+ +

◆ begin() [2/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::begin () -> iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 624 of file xscalar.hpp.

+ +
+
+ +

◆ begin() [3/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::begin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 726 of file xscalar.hpp.

+ +
+
+ +

◆ begin() [4/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::begin (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 712 of file xscalar.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class CT>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xscalar< CT >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 610 of file xscalar.hpp.

+ +
+
+ +

◆ cbegin() [1/2]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::cbegin () const -> const_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 652 of file xscalar.hpp.

+ +
+
+ +

◆ cbegin() [2/2]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::cbegin (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 740 of file xscalar.hpp.

+ +
+
+ +

◆ cend() [1/2]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::cend () const -> const_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 659 of file xscalar.hpp.

+ +
+
+ +

◆ cend() [2/2]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::cend (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 747 of file xscalar.hpp.

+ +
+
+ +

◆ crbegin() [1/2]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::crbegin () const -> const_reverse_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 694 of file xscalar.hpp.

+ +
+
+ +

◆ crbegin() [2/2]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::crbegin (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 782 of file xscalar.hpp.

+ +
+
+ +

◆ crend() [1/2]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::crend () const -> const_reverse_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 701 of file xscalar.hpp.

+ +
+
+ +

◆ crend() [2/2]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::crend (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 789 of file xscalar.hpp.

+ +
+
+ +

◆ data_element() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::data_element (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 925 of file xscalar.hpp.

+ +
+
+ +

◆ data_element() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::data_element (size_type i)
+ 		+inlinenoexcept
+
+ +

Definition at line 919 of file xscalar.hpp.

+ +
+
+ +

◆ dummy_begin() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::dummy_begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 907 of file xscalar.hpp.

+ +
+
+ +

◆ dummy_begin() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::dummy_begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 895 of file xscalar.hpp.

+ +
+
+ +

◆ dummy_end() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::dummy_end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 913 of file xscalar.hpp.

+ +
+
+ +

◆ dummy_end() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::dummy_end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 901 of file xscalar.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class CT>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xscalar< CT >::element (It ,
It  ) const -> const_reference +
+ 		+inlinenoexcept
+
+ +

Definition at line 591 of file xscalar.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class CT>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xscalar< CT >::element (It ,
It  ) -> reference +
+ 		+inlinenoexcept
+
+ +

Definition at line 584 of file xscalar.hpp.

+ +
+
+ +

◆ end() [1/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::end () const -> const_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 645 of file xscalar.hpp.

+ +
+
+ +

◆ end() [2/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::end () -> iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 631 of file xscalar.hpp.

+ +
+
+ +

◆ end() [3/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::end (const S & shape) const -> const_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 733 of file xscalar.hpp.

+ +
+
+ +

◆ end() [4/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::end (const S & shape) -> broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 719 of file xscalar.hpp.

+ +
+
+ +

◆ expression() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::expression () const
+ 		+inlinenoexcept
+
+ +

Definition at line 603 of file xscalar.hpp.

+ +
+
+ +

◆ expression() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::expression ()
+ 		+inlinenoexcept
+
+ +

Definition at line 597 of file xscalar.hpp.

+ +
+
+ +

◆ flat() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::flat (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 937 of file xscalar.hpp.

+ +
+
+ +

◆ flat() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::flat (size_type i)
+ 		+inlinenoexcept
+
+ +

Definition at line 931 of file xscalar.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CT>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xscalar< CT >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Definition at line 617 of file xscalar.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
bool xt::xscalar< CT >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 547 of file xscalar.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
layout_type xt::xscalar< CT >::layout () const
+ 		+inlinenoexcept
+
+ +

Definition at line 541 of file xscalar.hpp.

+ +
+
+ +

◆ linear_begin() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_begin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 807 of file xscalar.hpp.

+ +
+
+ +

◆ linear_begin() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 795 of file xscalar.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_cbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 819 of file xscalar.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_cend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 825 of file xscalar.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_crbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 855 of file xscalar.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_crend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 861 of file xscalar.hpp.

+ +
+
+ +

◆ linear_end() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_end () const
+ 		+inlinenoexcept
+
+ +

Definition at line 813 of file xscalar.hpp.

+ +
+
+ +

◆ linear_end() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_end ()
+ 		+inlinenoexcept
+
+ +

Definition at line 801 of file xscalar.hpp.

+ +
+
+ +

◆ linear_rbegin() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_rbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 843 of file xscalar.hpp.

+ +
+
+ +

◆ linear_rbegin() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_rbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 831 of file xscalar.hpp.

+ +
+
+ +

◆ linear_rend() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_rend () const
+ 		+inlinenoexcept
+
+ +

Definition at line 849 of file xscalar.hpp.

+ +
+
+ +

◆ linear_rend() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::linear_rend ()
+ 		+inlinenoexcept
+
+ +

Definition at line 837 of file xscalar.hpp.

+ +
+
+ +

◆ load_simd()

+ +
+
+
+template<class CT>
+
+template<class align, class requested_type, std::size_t N>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::load_simd (size_type ) const -> xt_simd::simd_return_type<value_type, requested_type> +
+ 		+inline
+
+ +

Definition at line 951 of file xscalar.hpp.

+ +
+
+ +

◆ operator const value_type &()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
xt::xscalar< CT >::operator const value_type & () const
+ 		+inlinenoexcept
+
+ +

Definition at line 516 of file xscalar.hpp.

+ +
+
+ +

◆ operator value_type &()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
xt::xscalar< CT >::operator value_type & ()
+ 		+inlinenoexcept
+
+ +

Definition at line 510 of file xscalar.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<class CT>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::operator() (Args... ) const -> const_reference +
+ 		+inlinenoexcept
+
+ +

Definition at line 569 of file xscalar.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<class CT>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::operator() (Args... ) -> reference +
+ 		+inlinenoexcept
+
+ +

Definition at line 554 of file xscalar.hpp.

+ +
+
+ +

◆ rbegin() [1/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rbegin () const -> const_reverse_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 680 of file xscalar.hpp.

+ +
+
+ +

◆ rbegin() [2/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rbegin () -> reverse_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 666 of file xscalar.hpp.

+ +
+
+ +

◆ rbegin() [3/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rbegin (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 768 of file xscalar.hpp.

+ +
+
+ +

◆ rbegin() [4/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rbegin (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 754 of file xscalar.hpp.

+ +
+
+ +

◆ rend() [1/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rend () const -> const_reverse_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 687 of file xscalar.hpp.

+ +
+
+ +

◆ rend() [2/4]

+ +
+
+
+template<class CT>
+
+template<layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rend () -> reverse_iterator +
+ 		+inlinenoexcept
+
+ +

Definition at line 673 of file xscalar.hpp.

+ +
+
+ +

◆ rend() [3/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rend (const S & shape) const -> const_reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 775 of file xscalar.hpp.

+ +
+
+ +

◆ rend() [4/4]

+ +
+
+
+template<class CT>
+
+template<class S, layout_type L>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::rend (const S & shape) -> reverse_broadcast_iterator<S, L> +
+ 		+inlinenoexcept
+
+ +

Definition at line 761 of file xscalar.hpp.

+ +
+
+ +

◆ shape() [1/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::shape () const
+ 		+inlinenoexcept
+
+ +

Definition at line 528 of file xscalar.hpp.

+ +
+
+ +

◆ shape() [2/2]

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::shape (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 535 of file xscalar.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 522 of file xscalar.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class CT>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::stepper_begin (const S & ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 882 of file xscalar.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class CT>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::stepper_begin (const S & ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 868 of file xscalar.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class CT>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xscalar< CT >::stepper_end (const S & ,
layout_type  ) const -> const_stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 889 of file xscalar.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class CT>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xscalar< CT >::stepper_end (const S & ,
layout_type  ) -> stepper +
+ 		+inlinenoexcept
+
+ +

Definition at line 875 of file xscalar.hpp.

+ +
+
+ +

◆ store_simd()

+ +
+
+
+template<class CT>
+
+template<class align, class simd>
+ + + + + +
+ + + + + + + + + + + +
void xt::xscalar< CT >::store_simd (size_type i,
const simd & e )
+ 		+inline
+
+ +

Definition at line 944 of file xscalar.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class CT>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::unchecked (Args... ) const -> const_reference +
+ 		+inlinenoexcept
+
+ +

Definition at line 577 of file xscalar.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class CT>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xscalar< CT >::unchecked (Args... ) -> reference +
+ 		+inlinenoexcept
+
+ +

Definition at line 562 of file xscalar.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< self_type >

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + +
friend class xaccessible< self_type >
+ 		+friend
+
+ +

Definition at line 295 of file xscalar.hpp.

+ +
+
+ +

◆ xconst_accessible< self_type >

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + +
friend class xconst_accessible< self_type >
+ 		+friend
+
+ +

Definition at line 295 of file xscalar.hpp.

+ +
+
+ +

◆ xconst_iterable< self_type >

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + +
friend class xconst_iterable< self_type >
+ 		+friend
+
+ +

Definition at line 295 of file xscalar.hpp.

+ +
+
+ +

◆ xiterable< self_type >

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + +
friend class xiterable< self_type >
+ 		+friend
+
+ +

Definition at line 295 of file xscalar.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + +
bool xt::xscalar< CT >::contiguous_layout = true
+ 		+staticconstexpr
+
+ +

Definition at line 145 of file xscalar.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CT>
+ + + + + +
+ + + + +
layout_type xt::xscalar< CT >::static_layout = layout_type::any
+ 		+staticconstexpr
+
+ +

Definition at line 144 of file xscalar.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xscalar.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xscalar.js b/classxt_1_1xscalar.js new file mode 100644 index 000000000..88cca0bb7 --- /dev/null +++ b/classxt_1_1xscalar.js @@ -0,0 +1,5 @@ +var classxt_1_1xscalar = +[ + [ "back", "classxt_1_1xscalar.html#a13a096e0045b2375006fec3bcd1c8d1c", null ], + [ "front", "classxt_1_1xscalar.html#a13ab25eb31d4b48cb01b7bc38d27e8e0", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xscalar.png b/classxt_1_1xscalar.png new file mode 100644 index 000000000..77a310003 Binary files /dev/null and b/classxt_1_1xscalar.png differ diff --git a/classxt_1_1xscalar__stepper-members.html b/classxt_1_1xscalar__stepper-members.html new file mode 100644 index 000000000..b5f065f1f --- /dev/null +++ b/classxt_1_1xscalar__stepper-members.html @@ -0,0 +1,140 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xscalar_stepper< is_const, CT > Member List
+
+
+ +

This is the complete list of members for xt::xscalar_stepper< is_const, CT >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
operator*() const noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
pointer typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
reference typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
reset(size_type dim) noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
reset_back(size_type dim) noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
self_type typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
shape_type typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
simd_return_type typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
size_type typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
step(size_type dim, size_type n=1) noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
step_back(size_type dim, size_type n=1) noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
step_leading() (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
step_simd() (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
step_simd() -> simd_return_type< T > (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
storage_type typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
to_begin() noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
to_end(layout_type l) noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
value_type typedef (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >
xscalar_stepper(storage_type *c) noexcept (defined in xt::xscalar_stepper< is_const, CT >)xt::xscalar_stepper< is_const, CT >inline
+
+ + + + diff --git a/classxt_1_1xscalar__stepper.html b/classxt_1_1xscalar__stepper.html new file mode 100644 index 000000000..18b6016e3 --- /dev/null +++ b/classxt_1_1xscalar__stepper.html @@ -0,0 +1,650 @@ + + + + + + + +xtensor: xt::xscalar_stepper< is_const, CT > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xscalar_stepper< is_const, CT > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xscalar_stepper<is_const, CT>
 
using storage_type = std::conditional_t<is_const, const xscalar<CT>, xscalar<CT>>
 
using value_type = typename storage_type::value_type
 
using reference
 
using pointer = std::conditional_t<is_const, typename storage_type::const_pointer, typename storage_type::pointer>
 
using size_type = typename storage_type::size_type
 
using difference_type = typename storage_type::difference_type
 
using shape_type = typename storage_type::shape_type
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xscalar_stepper (storage_type *c) noexcept
 
reference operator* () const noexcept
 
void step (size_type dim, size_type n=1) noexcept
 
void step_back (size_type dim, size_type n=1) noexcept
 
void reset (size_type dim) noexcept
 
void reset_back (size_type dim) noexcept
 
void to_begin () noexcept
 
void to_end (layout_type l) noexcept
 
+template<class T>
simd_return_type< T > step_simd ()
 
void step_leading ()
 
template<class T>
auto step_simd () -> simd_return_type< T >
 
+

Detailed Description

+
template<bool is_const, class CT>
+class xt::xscalar_stepper< is_const, CT >
+

Definition at line 353 of file xscalar.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::difference_type = typename storage_type::difference_type
+
+ +

Definition at line 365 of file xscalar.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::pointer = std::conditional_t<is_const, typename storage_type::const_pointer, typename storage_type::pointer>
+
+ +

Definition at line 363 of file xscalar.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::reference
+
+Initial value:
std::
+
conditional_t<is_const, typename storage_type::const_reference, typename storage_type::reference>
+
+

Definition at line 361 of file xscalar.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::self_type = xscalar_stepper<is_const, CT>
+
+ +

Definition at line 357 of file xscalar.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::shape_type = typename storage_type::shape_type
+
+ +

Definition at line 366 of file xscalar.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<bool is_const, class CT>
+
+template<class requested_type>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 369 of file xscalar.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::size_type = typename storage_type::size_type
+
+ +

Definition at line 364 of file xscalar.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::storage_type = std::conditional_t<is_const, const xscalar<CT>, xscalar<CT>>
+
+ +

Definition at line 358 of file xscalar.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<bool is_const, class CT>
+ + + + +
using xt::xscalar_stepper< is_const, CT >::value_type = typename storage_type::value_type
+
+ +

Definition at line 360 of file xscalar.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xscalar_stepper()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
xt::xscalar_stepper< is_const, CT >::xscalar_stepper (storage_type * c)
+ 		+inlinenoexcept
+
+ +

Definition at line 974 of file xscalar.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
auto xt::xscalar_stepper< is_const, CT >::operator* () const
+ 		+inlinenoexcept
+
+ +

Definition at line 980 of file xscalar.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
void xt::xscalar_stepper< is_const, CT >::reset (size_type dim)
+ 		+inlinenoexcept
+
+ +

Definition at line 996 of file xscalar.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
void xt::xscalar_stepper< is_const, CT >::reset_back (size_type dim)
+ 		+inlinenoexcept
+
+ +

Definition at line 1001 of file xscalar.hpp.

+ +
+
+ +

◆ step()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + + + + + +
void xt::xscalar_stepper< is_const, CT >::step (size_type dim,
size_type n = 1 )
+ 		+inlinenoexcept
+
+ +

Definition at line 986 of file xscalar.hpp.

+ +
+
+ +

◆ step_back()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + + + + + +
void xt::xscalar_stepper< is_const, CT >::step_back (size_type dim,
size_type n = 1 )
+ 		+inlinenoexcept
+
+ +

Definition at line 991 of file xscalar.hpp.

+ +
+
+ +

◆ step_leading()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
void xt::xscalar_stepper< is_const, CT >::step_leading ()
+ 		+inline
+
+ +

Definition at line 1023 of file xscalar.hpp.

+ +
+
+ +

◆ step_simd()

+ +
+
+
+template<bool is_const, class CT>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xscalar_stepper< is_const, CT >::step_simd () -> simd_return_type<T> +
+ 		+inline
+
+ +

Definition at line 1017 of file xscalar.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
void xt::xscalar_stepper< is_const, CT >::to_begin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1006 of file xscalar.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<bool is_const, class CT>
+ + + + + +
+ + + + + + + +
void xt::xscalar_stepper< is_const, CT >::to_end (layout_type l)
+ 		+inlinenoexcept
+
+ +

Definition at line 1011 of file xscalar.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xscalar.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xsemantic__base-members.html b/classxt_1_1xsemantic__base-members.html new file mode 100644 index 000000000..322c8e125 --- /dev/null +++ b/classxt_1_1xsemantic__base-members.html @@ -0,0 +1,181 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xsemantic_base< D > Member List
+
+
+ +

This is the complete list of members for xt::xsemantic_base< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
base_type typedef (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_or_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_xor_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
derived_type typedef (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
minus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
modulus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
multiplies_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator%=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator&=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator*=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator+=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator-=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator/=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator=(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(const xexpression< E > &e) -> derived_type & (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >inline
operator^=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator|=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
plus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
temporary_type typedef (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
~xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
+
+ + + + diff --git a/classxt_1_1xsemantic__base.html b/classxt_1_1xsemantic__base.html new file mode 100644 index 000000000..e46bf8782 --- /dev/null +++ b/classxt_1_1xsemantic__base.html @@ -0,0 +1,1561 @@ + + + + + + + +xtensor: xt::xsemantic_base< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xsemantic_base< D > Class Template Reference
+
+
+ +

Base interface for assignable xexpressions. + More...

+ +

#include <xsemantic.hpp>

+
+Inheritance diagram for xt::xsemantic_base< D >:
+
+
+ + +xt::xchunked_semantic< self_type > +xt::xcontainer_semantic< self_type > +xt::xview_semantic< self_type > +xt::xview_semantic< xmasked_view< CTD, CTM > > +xt::xchunked_semantic< D > +xt::xcontainer_semantic< D > +xt::xview_semantic< D > +xt::xmasked_view< CTD, CTM > +xt::xarray_adaptor< value_container &, L, SC > +xt::xarray_adaptor< flag_container &, L, SC > +xt::xarray_adaptor< const value_container &, L, SC > +xt::xarray_adaptor< const flag_container &, L, SC > +xt::xarray_adaptor< EC, L, SC, xoptional_expression_tag > +xt::xarray_container< temporary_container_t< storage_type >, L, SC, Tag > +xt::xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > +xt::xarray_container< xtl::xoptional_vector< T, A, BC >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true >, xoptional_expression_tag > +xt::xarray_container< EC, L, SC, xoptional_expression_tag > +xt::xfixed_container< typename storage_type::value_type, S, L, SH, Tag > +xt::xfixed_container< T, FSH, L, Sharable > +xt::xoptional_assembly< raw_value_expression, raw_flag_expression > +xt::xtensor_adaptor< value_container &, N, L > +xt::xtensor_adaptor< flag_container &, N, L > +xt::xtensor_adaptor< const value_container &, N, L > +xt::xtensor_adaptor< const flag_container &, N, L > +xt::xtensor_adaptor< EC, N, L, xoptional_expression_tag > +xt::xtensor_container< temporary_container_t< storage_type >, N, L, Tag > +xt::xtensor_container< uvector< T, A >, N, L > +xt::xtensor_container< xtl::xoptional_vector< T, A, BC >, N, L, xoptional_expression_tag > +xt::xtensor_container< std::vector< T, A >, 2, layout_type::row_major > +xt::xtensor_container< EC, N, L, xoptional_expression_tag > +xt::xdynamic_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xdynamic_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xdynamic_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xdynamic_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xdynamic_view< CT, S, L, FST > +xt::xdynamic_view< E, S, L, typename FST::template rebind_t< E > > +xt::xfunctor_view< F, uvt > +xt::xfunctor_view< F, ucvt > +xt::xfunctor_view< F, E > +xt::xindex_view< uvt, I > +xt::xindex_view< uft, I > +xt::xindex_view< ucvt, I > +xt::xindex_view< ucft, I > +xt::xindex_view< E, I > +xt::xstrided_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xstrided_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xstrided_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xstrided_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xstrided_view< CT, shape_type > +xt::xstrided_view< CT, S, L, FST > +xt::xstrided_view< E, S, L, typename FST::template rebind_t< E > > +xt::xtensor_view< EC, N, L, xoptional_expression_tag > +xt::xview< uvt, S... > +xt::xview< uft, S... > +xt::xview< ucvt, S... > +xt::xview< ucft, S... > +xt::xview< UnderlyingContainer, Slices... > +xt::xview< E, S... > +xt::xdynamic_view< CT, S, L, FST > +xt::xstrided_view< CT, S, L, FST > + +
+ + + + + + + + +

+Public Types

using base_type = select_expression_base_t<D>
 
using derived_type = typename base_type::derived_type
 
using temporary_type = typename xcontainer_inner_types<D>::temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
disable_xexpression< E, derived_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator^= (const E &)
 
+template<class E>
derived_type & operator+= (const xexpression< E > &)
 
+template<class E>
derived_type & operator-= (const xexpression< E > &)
 
+template<class E>
derived_type & operator*= (const xexpression< E > &)
 
+template<class E>
derived_type & operator/= (const xexpression< E > &)
 
+template<class E>
derived_type & operator%= (const xexpression< E > &)
 
+template<class E>
derived_type & operator&= (const xexpression< E > &)
 
+template<class E>
derived_type & operator|= (const xexpression< E > &)
 
+template<class E>
derived_type & operator^= (const xexpression< E > &)
 
+template<class E>
derived_type & assign (const xexpression< E > &)
 
+template<class E>
derived_type & plus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & minus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & multiplies_assign (const xexpression< E > &)
 
+template<class E>
derived_type & divides_assign (const xexpression< E > &)
 
+template<class E>
derived_type & modulus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_and_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_or_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_xor_assign (const xexpression< E > &)
 
Computed assignement
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
template<class E>
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
Assign functions
template<class E>
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
template<class E>
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
template<class E>
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
template<class E>
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
template<class E>
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + + + + +

+Protected Member Functions

+ xsemantic_base (const xsemantic_base &)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class D>
+class xt::xsemantic_base< D >

Base interface for assignable xexpressions.

+

The xsemantic_base class defines the interface for assignable xexpressions.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xsemantic_base provides the interface.
+
+
+ +

Definition at line 57 of file xsemantic.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xsemantic_base< D >::base_type = select_expression_base_t<D>
+
+ +

Definition at line 61 of file xsemantic.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xsemantic_base< D >::derived_type = typename base_type::derived_type
+
+ +

Definition at line 62 of file xsemantic.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xsemantic_base< D >::temporary_type = typename xcontainer_inner_types<D>::temporary_type
+
+ +

Definition at line 64 of file xsemantic.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Assigns the xexpression e to *this.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression to assign.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 511 of file xsemantic.hpp.

+ +
+
+ +

◆ bit_and_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::bit_and_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the bitwise and of e to *this.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression to add.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 589 of file xsemantic.hpp.

+ +
+
+ +

◆ bit_or_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::bit_or_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the bitwise or of e to *this.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression to add.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 602 of file xsemantic.hpp.

+ +
+
+ +

◆ bit_xor_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::bit_xor_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the bitwise xor of e to *this.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression to add.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 615 of file xsemantic.hpp.

+ +
+
+ +

◆ divides_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::divides_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Divides *this by the xexpression e.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 563 of file xsemantic.hpp.

+ +
+
+ +

◆ minus_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::minus_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Subtracts the xexpression e to *this.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression to subtract.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 537 of file xsemantic.hpp.

+ +
+
+ +

◆ modulus_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::modulus_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the remainder of *this after division by the xexpression e.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 576 of file xsemantic.hpp.

+ +
+
+ +

◆ multiplies_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::multiplies_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Multiplies *this with the xexpression e.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 550 of file xsemantic.hpp.

+ +
+
+ +

◆ operator%=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator%= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Computes the remainder of *this after division by the scalar e.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 360 of file xsemantic.hpp.

+ +
+
+ +

◆ operator%=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator%= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the remainder of *this after division by the xexpression e.

+
Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 456 of file xsemantic.hpp.

+ +
+
+ +

◆ operator&=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator&= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Computes the bitwise and of *this and the scalar e and assigns it to *this.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 372 of file xsemantic.hpp.

+ +
+
+ +

◆ operator&=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator&= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the bitwise and of *this and the xexpression e and assigns it to *this.

+
Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 468 of file xsemantic.hpp.

+ +
+
+ +

◆ operator*=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator*= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Multiplies *this with the scalar e.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 336 of file xsemantic.hpp.

+ +
+
+ +

◆ operator*=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator*= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Multiplies *this with the xexpression e.

+
Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 432 of file xsemantic.hpp.

+ +
+
+ +

◆ operator+=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator+= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Adds the scalar e to *this.

+
Parameters
+ + +
ethe scalar to add.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 312 of file xsemantic.hpp.

+ +
+
+ +

◆ operator+=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator+= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Adds the xexpression e to *this.

+
Parameters
+ + +
ethe xexpression to add.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 408 of file xsemantic.hpp.

+ +
+
+ +

◆ operator-=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator-= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Subtracts the scalar e from *this.

+
Parameters
+ + +
ethe scalar to subtract.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 324 of file xsemantic.hpp.

+ +
+
+ +

◆ operator-=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator-= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Subtracts the xexpression e from *this.

+
Parameters
+ + +
ethe xexpression to subtract.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 420 of file xsemantic.hpp.

+ +
+
+ +

◆ operator/=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator/= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Divides *this by the scalar e.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 348 of file xsemantic.hpp.

+ +
+
+ +

◆ operator/=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator/= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Divides *this by the xexpression e.

+
Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 444 of file xsemantic.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 622 of file xsemantic.hpp.

+ +
+
+ +

◆ operator^=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator^= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Computes the bitwise xor of *this and the scalar e and assigns it to *this.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 396 of file xsemantic.hpp.

+ +
+
+ +

◆ operator^=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator^= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the bitwise xor of *this and the xexpression e and assigns it to *this.

+
Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 492 of file xsemantic.hpp.

+ +
+
+ +

◆ operator|=() [1/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator|= (const E & e) -> disable_xexpression<E, derived_type&> +
+ 		+inline
+
+ +

Computes the bitwise or of *this and the scalar e and assigns it to *this.

+
Parameters
+ + +
ethe scalar involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 384 of file xsemantic.hpp.

+ +
+
+ +

◆ operator|=() [2/2]

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::operator|= (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Computes the bitwise or of *this and the xexpression e and assigns it to *this.

+
Parameters
+ + +
ethe xexpression involved in the operation.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 480 of file xsemantic.hpp.

+ +
+
+ +

◆ plus_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xsemantic_base< D >::plus_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Adds the xexpression e to *this.

+

Ensures no temporary will be used to perform the assignment.

Parameters
+ + +
ethe xexpression to add.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 524 of file xsemantic.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xsemantic.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xsemantic__base.js b/classxt_1_1xsemantic__base.js new file mode 100644 index 000000000..e6b90270a --- /dev/null +++ b/classxt_1_1xsemantic__base.js @@ -0,0 +1,28 @@ +var classxt_1_1xsemantic__base = +[ + [ "assign", "classxt_1_1xsemantic__base.html#aa4abcce752e16fea81c590cfdb48d099", null ], + [ "bit_and_assign", "classxt_1_1xsemantic__base.html#a491f436cebf5ae09254782e8e39e07e4", null ], + [ "bit_or_assign", "classxt_1_1xsemantic__base.html#a8f36e2f2e9869cb21ccb197f234838ec", null ], + [ "bit_xor_assign", "classxt_1_1xsemantic__base.html#a2ecc711c54c031f9fae4f959ba54c756", null ], + [ "divides_assign", "classxt_1_1xsemantic__base.html#a8390681df5ceb96cc3fe307bcb6f5878", null ], + [ "minus_assign", "classxt_1_1xsemantic__base.html#a9ae9f40db494b08455a84b3ba24e87e2", null ], + [ "modulus_assign", "classxt_1_1xsemantic__base.html#a30eeb2e83b810139f5111c161055e041", null ], + [ "multiplies_assign", "classxt_1_1xsemantic__base.html#aafe434601607910fc1d8e95dde649bff", null ], + [ "operator%=", "classxt_1_1xsemantic__base.html#a097cecfc7ed32171204a465c057b21aa", null ], + [ "operator%=", "classxt_1_1xsemantic__base.html#afc0cf14e98f80e1a266aed5ab59d3a26", null ], + [ "operator&=", "classxt_1_1xsemantic__base.html#a9e53cf500ff97971980632a01242e40f", null ], + [ "operator&=", "classxt_1_1xsemantic__base.html#aa64e63246393baa97cda0409dfe880f9", null ], + [ "operator*=", "classxt_1_1xsemantic__base.html#abc6dededcc7548c86d0e680723332507", null ], + [ "operator*=", "classxt_1_1xsemantic__base.html#aaec30e9ec0a24602c707935671e72798", null ], + [ "operator+=", "classxt_1_1xsemantic__base.html#a8d5c560eb7c807fb0806864fb0b46c50", null ], + [ "operator+=", "classxt_1_1xsemantic__base.html#a9e31dbd09cdb7b7676d33243732f3ac7", null ], + [ "operator-=", "classxt_1_1xsemantic__base.html#afa46b608eb0ee224aa7592404ba01b20", null ], + [ "operator-=", "classxt_1_1xsemantic__base.html#aa9edf1d0dba25f33a6f1955dfe333d66", null ], + [ "operator/=", "classxt_1_1xsemantic__base.html#af008542eab3a41140cfe12dca74232ee", null ], + [ "operator/=", "classxt_1_1xsemantic__base.html#a2ff7796563ea73e3aff6ce17ff2c1f42", null ], + [ "operator^=", "classxt_1_1xsemantic__base.html#a7c74b14f291bccf501760aa166cd7bd6", null ], + [ "operator^=", "classxt_1_1xsemantic__base.html#a61d5bbbb065e48c74db69c4276673a34", null ], + [ "operator|=", "classxt_1_1xsemantic__base.html#a5fe0e38a7065e67565d46179727fe399", null ], + [ "operator|=", "classxt_1_1xsemantic__base.html#ab09ec4698094a4a1efbaa1ccbb609d42", null ], + [ "plus_assign", "classxt_1_1xsemantic__base.html#aabefbeb56a74c2098c0fe976227ebdc8", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xsemantic__base.png b/classxt_1_1xsemantic__base.png new file mode 100644 index 000000000..2c04d1e3a Binary files /dev/null and b/classxt_1_1xsemantic__base.png differ diff --git a/classxt_1_1xsharable__expression-members.html b/classxt_1_1xsharable__expression-members.html new file mode 100644 index 000000000..27e7705d9 --- /dev/null +++ b/classxt_1_1xsharable__expression-members.html @@ -0,0 +1,136 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xsharable_expression< D > Member List
+
+
+ +

This is the complete list of members for xt::xsharable_expression< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + +
derived_cast() &noexceptxt::xexpression< D >inline
derived_cast() const &noexceptxt::xexpression< D >inline
derived_cast() &&noexceptxt::xexpression< D >inline
derived_type typedef (defined in xt::xexpression< D >)xt::xexpression< D >
operator=(const xsharable_expression &)=default (defined in xt::xsharable_expression< D >)xt::xsharable_expression< D >protected
operator=(xsharable_expression &&)=default (defined in xt::xsharable_expression< D >)xt::xsharable_expression< D >protected
operator=(const xexpression &)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
operator=(xexpression &&)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
xexpression()=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
xexpression(const xexpression &)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
xexpression(xexpression &&)=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
xsharable_expression() (defined in xt::xsharable_expression< D >)xt::xsharable_expression< D >inlineprotected
xsharable_expression(const xsharable_expression &)=default (defined in xt::xsharable_expression< D >)xt::xsharable_expression< D >protected
xsharable_expression(xsharable_expression &&)=default (defined in xt::xsharable_expression< D >)xt::xsharable_expression< D >protected
~xexpression()=default (defined in xt::xexpression< D >)xt::xexpression< D >protected
~xsharable_expression()=default (defined in xt::xsharable_expression< D >)xt::xsharable_expression< D >protected
+
+ + + + diff --git a/classxt_1_1xsharable__expression.html b/classxt_1_1xsharable__expression.html new file mode 100644 index 000000000..7bdd23448 --- /dev/null +++ b/classxt_1_1xsharable__expression.html @@ -0,0 +1,226 @@ + + + + + + + +xtensor: xt::xsharable_expression< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Protected Member Functions | +List of all members
+
xt::xsharable_expression< D > Class Template Reference
+
+
+
+Inheritance diagram for xt::xsharable_expression< D >:
+
+
+ + +xt::xexpression< D > +xt::xbroadcast< E, X > +xt::xgenerator< OF, OR, S > +xt::xgenerator< value_functor, value_closure, S > +xt::xgenerator< flag_functor, flag_closure, S > +xt::xreducer< Func, E, X, Opts > +xt::xscalar< xtl::closure_type_t< E > > +xt::xscalar< xtl::const_closure_type_t< E > > +xt::xscalar< T > +xt::xscalar< bool > +xt::xscalar< std::conditional_t< is_const, const_value_closure, value_closure > > +xt::xscalar< std::conditional_t< is_const, const_flag_closure, flag_closure > > +xt::xscalar< const_value_closure > +xt::xscalar< const_flag_closure > + +
+ + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

+ xsharable_expression (const xsharable_expression &)=default
 
+xsharable_expression & operator= (const xsharable_expression &)=default
 
+ xsharable_expression (xsharable_expression &&)=default
 
+xsharable_expression & operator= (xsharable_expression &&)=default
 
Downcast functions
- Protected Member Functions inherited from xt::xexpression< D >
+ xexpression (const xexpression &)=default
 
+xexpression & operator= (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (xexpression &&)=default
 
+ + + + + + + + + + + + + + +

+Additional Inherited Members

- Public Types inherited from xt::xexpression< D >
using derived_type = D
 
- Public Member Functions inherited from xt::xexpression< D >
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
+

Detailed Description

+
template<class D>
+class xt::xsharable_expression< D >
+

Definition at line 83 of file xexpression.hpp.

+

Constructor & Destructor Documentation

+ +

◆ xsharable_expression()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
xt::xsharable_expression< D >::xsharable_expression ()
+ 		+inlineprotected
+
+ +

Definition at line 145 of file xexpression.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xsharable__expression.png b/classxt_1_1xsharable__expression.png new file mode 100644 index 000000000..0af8d58a9 Binary files /dev/null and b/classxt_1_1xsharable__expression.png differ diff --git a/classxt_1_1xshared__expression-members.html b/classxt_1_1xshared__expression-members.html new file mode 100644 index 000000000..91b39cab4 --- /dev/null +++ b/classxt_1_1xshared__expression-members.html @@ -0,0 +1,207 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xshared_expression< E > Member List
+
+
+ +

This is the complete list of members for xt::xshared_expression< E >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
backstrides() const (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
backstrides_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
base_class typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
begin(const S &shape) noexcept -> decltype(std::declval< E >().template begin< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
begin() noexcept -> decltype(std::declval< E >().template begin< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
begin() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template begin< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
begin(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template begin< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
bool_load_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
broadcast_shape(S &shape, bool reuse_cache=false) const (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
cbegin() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cbegin< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
cbegin(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cbegin< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
cend() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cend< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
cend(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cend< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
const_linear_iterator typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
const_pointer typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
const_reference typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
const_stepper typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
contiguous_layout (defined in xt::xshared_expression< E >)xt::xshared_expression< E >static
crbegin() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crbegin< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
crbegin(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crbegin< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
crend() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crend< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
crend(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crend< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
data() noexcept (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
data() const noexcept (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
data_offset() const noexcept (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
derived_cast() &noexceptxt::xexpression< xshared_expression< E > >
derived_cast() const &noexceptxt::xexpression< xshared_expression< E > >
derived_cast() &&noexceptxt::xexpression< xshared_expression< E > >
derived_cast() &noexceptxt::xexpression< xshared_expression< E > >inline
derived_cast() const &noexceptxt::xexpression< xshared_expression< E > >inline
derived_cast() &&noexceptxt::xexpression< xshared_expression< E > >inline
difference_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
dimension() const -> decltype(std::declval< xtl::constify_t< E > >().dimension()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
element(It first, It last) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
element(It first, It last) const (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
end(const S &shape) noexcept -> decltype(std::declval< E >().template end< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
end() noexcept -> decltype(std::declval< E >().template end< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
end() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template end< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
end(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template end< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
has_linear_assign(const S &strides) const noexcept (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
inner_backstrides_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
inner_shape_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
inner_strides_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
is_contiguous() const -> decltype(std::declval< xtl::constify_t< E > >().is_contiguous()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
layout() const -> decltype(std::declval< xtl::constify_t< E > >().layout()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_begin() -> decltype(std::declval< E >().linear_begin()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_begin() const -> decltype(std::declval< xtl::constify_t< E > >().linear_begin()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_cbegin() const -> decltype(std::declval< xtl::constify_t< E > >().linear_cbegin()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_cend() const -> decltype(std::declval< xtl::constify_t< E > >().linear_cend()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_crbegin() const -> decltype(std::declval< xtl::constify_t< E > >().linear_crbegin()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_crend() const -> decltype(std::declval< xtl::constify_t< E > >().linear_crend()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_end() -> decltype(std::declval< E >().linear_end()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_end() const -> decltype(std::declval< xtl::constify_t< E > >().linear_end()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_iterator typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
linear_rbegin() -> decltype(std::declval< E >().linear_rbegin()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_rbegin() const -> decltype(std::declval< xtl::constify_t< E > >().linear_rbegin()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_rend() -> decltype(std::declval< E >().linear_rend()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
linear_rend() const -> decltype(std::declval< xtl::constify_t< E > >().linear_rend()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
operator()(Args... args) -> decltype(std::declval< E >()(args...)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
pointer typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
rbegin(const S &shape) noexcept -> decltype(std::declval< E >().template rbegin< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
rbegin() noexcept -> decltype(std::declval< E >().template rbegin< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
rbegin() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rbegin< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
rbegin(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rbegin< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
reference typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
rend(const S &shape) noexcept -> decltype(std::declval< E >().template rend< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
rend() noexcept -> decltype(std::declval< E >().template rend< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
rend() const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rend< L >()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
rend(const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rend< L >(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
shape() const -> decltype(std::declval< xtl::constify_t< E > >().shape()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
shape_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
size() const -> decltype(std::declval< xtl::constify_t< E > >().size()) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
size_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
static_layout (defined in xt::xshared_expression< E >)xt::xshared_expression< E >static
stepper typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
stepper_begin(const S &shape) noexcept -> decltype(std::declval< E >().stepper_begin(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
stepper_begin(const S &shape) const noexcept -> decltype(std::declval< const E >().stepper_begin(shape)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
stepper_end(const S &shape, layout_type l) noexcept -> decltype(std::declval< E >().stepper_end(shape, l)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
stepper_end(const S &shape, layout_type l) const noexcept -> decltype(std::declval< const E >().stepper_end(shape, l)) (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
storage() noexcept (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
storage() const noexcept (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
storage_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
strides() const (defined in xt::xshared_expression< E >)xt::xshared_expression< E >inline
strides_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
use_count() const noexceptxt::xshared_expression< E >inline
value_type typedef (defined in xt::xshared_expression< E >)xt::xshared_expression< E >
xshared_expression(const std::shared_ptr< E > &ptr)xt::xshared_expression< E >inlineexplicit
+
+ + + + diff --git a/classxt_1_1xshared__expression.html b/classxt_1_1xshared__expression.html new file mode 100644 index 000000000..bbc741981 --- /dev/null +++ b/classxt_1_1xshared__expression.html @@ -0,0 +1,2683 @@ + + + + + + + +xtensor: xt::xshared_expression< E > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +List of all members
+
xt::xshared_expression< E > Class Template Reference
+
+
+ +

Shared xexpressions. + More...

+ +

#include <xexpression.hpp>

+
+Inheritance diagram for xt::xshared_expression< E >:
+
+
+ + +xt::xexpression< xshared_expression< E > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using base_class = xexpression<xshared_expression<E>>
 
using value_type = typename E::value_type
 
using reference = typename E::reference
 
using const_reference = typename E::const_reference
 
using pointer = typename E::pointer
 
using const_pointer = typename E::const_pointer
 
using size_type = typename E::size_type
 
using difference_type = typename E::difference_type
 
using inner_shape_type = typename E::inner_shape_type
 
using shape_type = typename E::shape_type
 
using strides_type
 
using backstrides_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using storage_type = xtl::mpl::eval_if_t<has_storage_type<E>, detail::expr_storage_type<E>, make_invalid_type<>>
 
using stepper = typename E::stepper
 
using const_stepper = typename E::const_stepper
 
using linear_iterator = typename E::linear_iterator
 
using const_linear_iterator = typename E::const_linear_iterator
 
using bool_load_type = typename E::bool_load_type
 
- Public Types inherited from xt::xexpression< xshared_expression< E > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

template<class... Args>
auto operator() (Args... args) -> decltype(std::declval< E >()(args...))
 
auto shape () const -> decltype(std::declval< xtl::constify_t< E > >().shape())
 
auto dimension () const -> decltype(std::declval< xtl::constify_t< E > >().dimension())
 
auto size () const -> decltype(std::declval< xtl::constify_t< E > >().size())
 
auto layout () const -> decltype(std::declval< xtl::constify_t< E > >().layout())
 
auto is_contiguous () const -> decltype(std::declval< xtl::constify_t< E > >().is_contiguous())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto begin (const S &shape) noexcept -> decltype(std::declval< E >().template begin< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto begin () noexcept -> decltype(std::declval< E >().template begin< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto end (const S &shape) noexcept -> decltype(std::declval< E >().template end< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto end () noexcept -> decltype(std::declval< E >().template end< L >())
 
template<layout_type L = ::xt::layout_type::row_major>
auto begin () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template begin< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto begin (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template begin< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto end () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template end< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto end (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template end< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto cbegin () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cbegin< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto cbegin (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cbegin< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto cend () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cend< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto cend (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template cend< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto rbegin (const S &shape) noexcept -> decltype(std::declval< E >().template rbegin< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto rbegin () noexcept -> decltype(std::declval< E >().template rbegin< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto rend (const S &shape) noexcept -> decltype(std::declval< E >().template rend< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto rend () noexcept -> decltype(std::declval< E >().template rend< L >())
 
template<layout_type L = ::xt::layout_type::row_major>
auto rbegin () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rbegin< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto rbegin (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rbegin< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto rend () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rend< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto rend (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template rend< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto crbegin () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crbegin< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto crbegin (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crbegin< L >(shape))
 
template<layout_type L = ::xt::layout_type::row_major>
auto crend () const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crend< L >())
 
template<layout_type L = ::xt::layout_type::row_major, class S>
auto crend (const S &shape) const noexcept -> decltype(std::declval< xtl::constify_t< E > >().template crend< L >(shape))
 
auto linear_begin () -> decltype(std::declval< E >().linear_begin())
 
auto linear_end () -> decltype(std::declval< E >().linear_end())
 
auto linear_begin () const -> decltype(std::declval< xtl::constify_t< E > >().linear_begin())
 
auto linear_end () const -> decltype(std::declval< xtl::constify_t< E > >().linear_end())
 
auto linear_cbegin () const -> decltype(std::declval< xtl::constify_t< E > >().linear_cbegin())
 
auto linear_cend () const -> decltype(std::declval< xtl::constify_t< E > >().linear_cend())
 
auto linear_rbegin () -> decltype(std::declval< E >().linear_rbegin())
 
auto linear_rend () -> decltype(std::declval< E >().linear_rend())
 
auto linear_rbegin () const -> decltype(std::declval< xtl::constify_t< E > >().linear_rbegin())
 
auto linear_rend () const -> decltype(std::declval< xtl::constify_t< E > >().linear_rend())
 
auto linear_crbegin () const -> decltype(std::declval< xtl::constify_t< E > >().linear_crbegin())
 
auto linear_crend () const -> decltype(std::declval< xtl::constify_t< E > >().linear_crend())
 
template<class T = E>
std::enable_if_t< has_strides< T >::value, const inner_strides_type & > strides () const
 
template<class T = E>
std::enable_if_t< has_strides< T >::value, const inner_strides_type & > backstrides () const
 
template<class T = E>
std::enable_if_t< has_data_interface< T >::value, pointer > data () noexcept
 
template<class T = E>
std::enable_if_t< has_data_interface< T >::value, pointer > data () const noexcept
 
template<class T = E>
std::enable_if_t< has_data_interface< T >::value, size_type > data_offset () const noexcept
 
template<class T = E>
std::enable_if_t< has_data_interface< T >::value, typename T::storage_type & > storage () noexcept
 
template<class T = E>
std::enable_if_t< has_data_interface< T >::value, const typename T::storage_type & > storage () const noexcept
 
template<class It>
reference element (It first, It last)
 
template<class It>
const_reference element (It first, It last) const
 
template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 
template<class S>
auto stepper_begin (const S &shape) noexcept -> decltype(std::declval< E >().stepper_begin(shape))
 
template<class S>
auto stepper_end (const S &shape, layout_type l) noexcept -> decltype(std::declval< E >().stepper_end(shape, l))
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> decltype(std::declval< const E >().stepper_begin(shape))
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> decltype(std::declval< const E >().stepper_end(shape, l))
 
Downcast functions
 xshared_expression (const std::shared_ptr< E > &ptr)
 Constructor for xshared expression (note: usually the free function make_xshared is recommended).
 
long use_count () const noexcept
 Return the number of times this expression is referenced.
 
- Public Member Functions inherited from xt::xexpression< xshared_expression< E > >
+derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
+const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
+derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type & derived_cast () &noexcept
 Returns a reference to the actual derived type of the xexpression.
 
const derived_type & derived_cast () const &noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
derived_type derived_cast () &&noexcept
 Returns a constant reference to the actual derived type of the xexpression.
 
+ + + + + +

+Static Public Attributes

static constexpr layout_type static_layout = E::static_layout
 
static constexpr bool contiguous_layout = static_layout != layout_type::dynamic
 
+ + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xexpression< xshared_expression< E > >
+ xexpression (const xexpression &)=default
 
+xexpression & operator= (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (xexpression &&)=default
 
+ xexpression (const xexpression &)=default
 
+ xexpression (xexpression &&)=default
 
+xexpression & operator= (const xexpression &)=default
 
+xexpression & operator= (xexpression &&)=default
 
+

Detailed Description

+
template<class E>
+class xt::xshared_expression< E >

Shared xexpressions.

+

Due to C++ lifetime constraints it's sometimes necessary to create shared expressions (akin to a shared pointer).

+

For example, when a temporary expression needs to be used twice in another expression, shared expressions can come to the rescue:

+
template <class E>
+
auto cos_plus_sin(xexpression<E>&& expr)
+
{
+
// THIS IS WRONG: forwarding rvalue twice not permitted!
+
// return xt::sin(std::forward<E>(expr)) + xt::cos(std::forward<E>(expr));
+
// THIS IS WRONG TOO: because second `expr` is taken as reference (which will be invalid)
+
// return xt::sin(std::forward<E>(expr)) + xt::cos(expr)
+
auto shared_expr = xt::make_xshared(std::forward<E>(expr));
+
auto result = xt::sin(shared_expr) + xt::cos(shared_expr);
+
std::cout << shared_expr.use_count() << std::endl; // Will print 3 because used twice in expression
+
return result; // all valid because expr lifetime managed by xshared_expression / shared_ptr.
+
}
+
xt::cos
auto cos(E &&e) noexcept -> detail::xfunction_type_t< math::cos_fun, E >
Cosine function.
Definition xmath.hpp:1307
+
xt::sin
auto sin(E &&e) noexcept -> detail::xfunction_type_t< math::sin_fun, E >
Sine function.
Definition xmath.hpp:1292
+
xt::make_xshared
xshared_expression< E > make_xshared(xexpression< E > &&expr)
Helper function to create shared expression from any xexpression.
Definition xexpression.hpp:731
+
+

Definition at line 509 of file xexpression.hpp.

+

Member Typedef Documentation

+ +

◆ backstrides_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::backstrides_type
+
+Initial value:
xtl::mpl::
+
eval_if_t<has_strides<E>, detail::expr_backstrides_type<E>, get_strides_type<shape_type>>
+
xt::get_strides_type
Definition xutils.hpp:961
+
+

Definition at line 528 of file xexpression.hpp.

+ +
+
+ +

◆ base_class

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::base_class = xexpression<xshared_expression<E>>
+
+ +

Definition at line 513 of file xexpression.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::bool_load_type = typename E::bool_load_type
+
+ +

Definition at line 542 of file xexpression.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::const_linear_iterator = typename E::const_linear_iterator
+
+ +

Definition at line 540 of file xexpression.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::const_pointer = typename E::const_pointer
+
+ +

Definition at line 519 of file xexpression.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::const_reference = typename E::const_reference
+
+ +

Definition at line 517 of file xexpression.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::const_stepper = typename E::const_stepper
+
+ +

Definition at line 537 of file xexpression.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::difference_type = typename E::difference_type
+
+ +

Definition at line 521 of file xexpression.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::inner_backstrides_type
+
+Initial value:
xtl::mpl::
+
eval_if_t<has_strides<E>, detail::expr_inner_backstrides_type<E>, get_strides_type<shape_type>>
+
+

Definition at line 532 of file xexpression.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::inner_shape_type = typename E::inner_shape_type
+
+ +

Definition at line 523 of file xexpression.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::inner_strides_type
+
+Initial value:
xtl::mpl::
+
eval_if_t<has_strides<E>, detail::expr_inner_strides_type<E>, get_strides_type<shape_type>>
+
+

Definition at line 530 of file xexpression.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::linear_iterator = typename E::linear_iterator
+
+ +

Definition at line 539 of file xexpression.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::pointer = typename E::pointer
+
+ +

Definition at line 518 of file xexpression.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::reference = typename E::reference
+
+ +

Definition at line 516 of file xexpression.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::shape_type = typename E::shape_type
+
+ +

Definition at line 524 of file xexpression.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::size_type = typename E::size_type
+
+ +

Definition at line 520 of file xexpression.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::stepper = typename E::stepper
+
+ +

Definition at line 536 of file xexpression.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::storage_type = xtl::mpl::eval_if_t<has_storage_type<E>, detail::expr_storage_type<E>, make_invalid_type<>>
+
+ +

Definition at line 534 of file xexpression.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::strides_type
+
+Initial value:
xtl::mpl::
+
eval_if_t<has_strides<E>, detail::expr_strides_type<E>, get_strides_type<shape_type>>
+
+

Definition at line 526 of file xexpression.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class E>
+ + + + +
using xt::xshared_expression< E >::value_type = typename E::value_type
+
+ +

Definition at line 515 of file xexpression.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xshared_expression()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
xt::xshared_expression< E >::xshared_expression (const std::shared_ptr< E > & ptr)
+ 		+inlineexplicit
+
+ +

Constructor for xshared expression (note: usually the free function make_xshared is recommended).

+
Parameters
+ + +
ptrshared ptr that contains the expression
+
+
+
See also
make_xshared
+ +

Definition at line 696 of file xexpression.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ backstrides()

+ +
+
+
+template<class E>
+
+template<class T = E>
+ + + + + +
+ + + + + + + +
std::enable_if_t< has_strides< T >::value, const inner_strides_type & > xt::xshared_expression< E >::backstrides () const
+ 		+inline
+
+ +

Definition at line 597 of file xexpression.hpp.

+ +
+
+ +

◆ begin() [1/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::begin () const -> decltype(std::declval<xtl::constify_t<E>>().template begin<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 564 of file xexpression.hpp.

+ +
+
+ +

◆ begin() [2/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::begin () -> decltype(std::declval<E>().template begin<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 562 of file xexpression.hpp.

+ +
+
+ +

◆ begin() [3/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::begin (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template begin<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 564 of file xexpression.hpp.

+ +
+
+ +

◆ begin() [4/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::begin (const S & shape) -> decltype(std::declval<E>().template begin<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 562 of file xexpression.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class E>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xshared_expression< E >::broadcast_shape (S & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Definition at line 645 of file xexpression.hpp.

+ +
+
+ +

◆ cbegin() [1/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::cbegin () const -> decltype(std::declval<xtl::constify_t<E>>().template cbegin<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 566 of file xexpression.hpp.

+ +
+
+ +

◆ cbegin() [2/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::cbegin (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template cbegin<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 566 of file xexpression.hpp.

+ +
+
+ +

◆ cend() [1/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::cend () const -> decltype(std::declval<xtl::constify_t<E>>().template cend<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 567 of file xexpression.hpp.

+ +
+
+ +

◆ cend() [2/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::cend (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template cend<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 567 of file xexpression.hpp.

+ +
+
+ +

◆ crbegin() [1/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::crbegin () const -> decltype(std::declval<xtl::constify_t<E>>().template crbegin<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 573 of file xexpression.hpp.

+ +
+
+ +

◆ crbegin() [2/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::crbegin (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template crbegin<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 573 of file xexpression.hpp.

+ +
+
+ +

◆ crend() [1/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::crend () const -> decltype(std::declval<xtl::constify_t<E>>().template crend<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 574 of file xexpression.hpp.

+ +
+
+ +

◆ crend() [2/2]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::crend (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template crend<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 574 of file xexpression.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class E>
+
+template<class T = E>
+ + + + + +
+ + + + + + + +
std::enable_if_t< has_data_interface< T >::value, pointer > xt::xshared_expression< E >::data () const
+ 		+inlinenoexcept
+
+ +

Definition at line 609 of file xexpression.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class E>
+
+template<class T = E>
+ + + + + +
+ + + + + + + +
std::enable_if_t< has_data_interface< T >::value, pointer > xt::xshared_expression< E >::data ()
+ 		+inlinenoexcept
+
+ +

Definition at line 603 of file xexpression.hpp.

+ +
+
+ +

◆ data_offset()

+ +
+
+
+template<class E>
+
+template<class T = E>
+ + + + + +
+ + + + + + + +
std::enable_if_t< has_data_interface< T >::value, size_type > xt::xshared_expression< E >::data_offset () const
+ 		+inlinenoexcept
+
+ +

Definition at line 615 of file xexpression.hpp.

+ +
+
+ +

◆ dimension()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::dimension () const -> decltype(std::declval<xtl::constify_t<E>>().dimension())
+ 		+inline
+
+ +

Definition at line 557 of file xexpression.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class E>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
reference xt::xshared_expression< E >::element (It first,
It last )
+ 		+inline
+
+ +

Definition at line 633 of file xexpression.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class E>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
const_reference xt::xshared_expression< E >::element (It first,
It last ) const
+ 		+inline
+
+ +

Definition at line 639 of file xexpression.hpp.

+ +
+
+ +

◆ end() [1/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::end () const -> decltype(std::declval<xtl::constify_t<E>>().template end<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 565 of file xexpression.hpp.

+ +
+
+ +

◆ end() [2/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::end () -> decltype(std::declval<E>().template end<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 563 of file xexpression.hpp.

+ +
+
+ +

◆ end() [3/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::end (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template end<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 565 of file xexpression.hpp.

+ +
+
+ +

◆ end() [4/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::end (const S & shape) -> decltype(std::declval<E>().template end<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 563 of file xexpression.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class E>
+
+template<class S>
+ + + + + +
+ + + + + + + +
bool xt::xshared_expression< E >::has_linear_assign (const S & strides) const
+ 		+inlinenoexcept
+
+ +

Definition at line 651 of file xexpression.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::is_contiguous () const -> decltype(std::declval<xtl::constify_t<E>>().is_contiguous())
+ 		+inline
+
+ +

Definition at line 560 of file xexpression.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::layout () const -> decltype(std::declval<xtl::constify_t<E>>().layout())
+ 		+inline
+
+ +

Definition at line 559 of file xexpression.hpp.

+ +
+
+ +

◆ linear_begin() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_begin () -> decltype(std::declval<E>().linear_begin())
+ 		+inline
+
+ +

Definition at line 576 of file xexpression.hpp.

+ +
+
+ +

◆ linear_begin() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_begin () const -> decltype(std::declval<xtl::constify_t<E>>().linear_begin())
+ 		+inline
+
+ +

Definition at line 578 of file xexpression.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_cbegin () const -> decltype(std::declval<xtl::constify_t<E>>().linear_cbegin())
+ 		+inline
+
+ +

Definition at line 580 of file xexpression.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_cend () const -> decltype(std::declval<xtl::constify_t<E>>().linear_cend())
+ 		+inline
+
+ +

Definition at line 581 of file xexpression.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_crbegin () const -> decltype(std::declval<xtl::constify_t<E>>().linear_crbegin())
+ 		+inline
+
+ +

Definition at line 587 of file xexpression.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_crend () const -> decltype(std::declval<xtl::constify_t<E>>().linear_crend())
+ 		+inline
+
+ +

Definition at line 588 of file xexpression.hpp.

+ +
+
+ +

◆ linear_end() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_end () -> decltype(std::declval<E>().linear_end())
+ 		+inline
+
+ +

Definition at line 577 of file xexpression.hpp.

+ +
+
+ +

◆ linear_end() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_end () const -> decltype(std::declval<xtl::constify_t<E>>().linear_end())
+ 		+inline
+
+ +

Definition at line 579 of file xexpression.hpp.

+ +
+
+ +

◆ linear_rbegin() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_rbegin () -> decltype(std::declval<E>().linear_rbegin())
+ 		+inline
+
+ +

Definition at line 583 of file xexpression.hpp.

+ +
+
+ +

◆ linear_rbegin() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_rbegin () const -> decltype(std::declval<xtl::constify_t<E>>().linear_rbegin())
+ 		+inline
+
+ +

Definition at line 585 of file xexpression.hpp.

+ +
+
+ +

◆ linear_rend() [1/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_rend () -> decltype(std::declval<E>().linear_rend())
+ 		+inline
+
+ +

Definition at line 584 of file xexpression.hpp.

+ +
+
+ +

◆ linear_rend() [2/2]

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::linear_rend () const -> decltype(std::declval<xtl::constify_t<E>>().linear_rend())
+ 		+inline
+
+ +

Definition at line 586 of file xexpression.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class E>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::operator() (Args... args) -> decltype(std::declval<E>()(args...)) +
+ 		+inline
+
+ +

Definition at line 551 of file xexpression.hpp.

+ +
+
+ +

◆ rbegin() [1/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rbegin () const -> decltype(std::declval<xtl::constify_t<E>>().template rbegin<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 571 of file xexpression.hpp.

+ +
+
+ +

◆ rbegin() [2/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rbegin () -> decltype(std::declval<E>().template rbegin<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 569 of file xexpression.hpp.

+ +
+
+ +

◆ rbegin() [3/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rbegin (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template rbegin<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 571 of file xexpression.hpp.

+ +
+
+ +

◆ rbegin() [4/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rbegin (const S & shape) -> decltype(std::declval<E>().template rbegin<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 569 of file xexpression.hpp.

+ +
+
+ +

◆ rend() [1/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rend () const -> decltype(std::declval<xtl::constify_t<E>>().template rend<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 572 of file xexpression.hpp.

+ +
+
+ +

◆ rend() [2/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rend () -> decltype(std::declval<E>().template rend<L>())
+ 		+inlinenoexcept
+
+ +

Definition at line 570 of file xexpression.hpp.

+ +
+
+ +

◆ rend() [3/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rend (const S & shape) const -> decltype(std::declval<xtl::constify_t<E>>().template rend<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 572 of file xexpression.hpp.

+ +
+
+ +

◆ rend() [4/4]

+ +
+
+
+template<class E>
+
+template<layout_type L = ::xt::layout_type::row_major, class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::rend (const S & shape) -> decltype(std::declval<E>().template rend<L>(shape))
+ 		+inlinenoexcept
+
+ +

Definition at line 570 of file xexpression.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::shape () const -> decltype(std::declval<xtl::constify_t<E>>().shape())
+ 		+inline
+
+ +

Definition at line 556 of file xexpression.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::size () const -> decltype(std::declval<xtl::constify_t<E>>().size())
+ 		+inline
+
+ +

Definition at line 558 of file xexpression.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class E>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::stepper_begin (const S & shape) const -> decltype(std::declval<const E>().stepper_begin(shape)) +
+ 		+inlinenoexcept
+
+ +

Definition at line 670 of file xexpression.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class E>
+
+template<class S>
+ + + + + +
+ + + + + + + +
auto xt::xshared_expression< E >::stepper_begin (const S & shape) -> decltype(std::declval<E>().stepper_begin(shape)) +
+ 		+inlinenoexcept
+
+ +

Definition at line 657 of file xexpression.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class E>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xshared_expression< E >::stepper_end (const S & shape,
layout_type l ) const -> decltype(std::declval<const E>().stepper_end(shape, l)) +
+ 		+inlinenoexcept
+
+ +

Definition at line 677 of file xexpression.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class E>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xshared_expression< E >::stepper_end (const S & shape,
layout_type l ) -> decltype(std::declval<E>().stepper_end(shape, l)) +
+ 		+inlinenoexcept
+
+ +

Definition at line 663 of file xexpression.hpp.

+ +
+
+ +

◆ storage() [1/2]

+ +
+
+
+template<class E>
+
+template<class T = E>
+ + + + + +
+ + + + + + + +
std::enable_if_t< has_data_interface< T >::value, const typename T::storage_type & > xt::xshared_expression< E >::storage () const
+ 		+inlinenoexcept
+
+ +

Definition at line 627 of file xexpression.hpp.

+ +
+
+ +

◆ storage() [2/2]

+ +
+
+
+template<class E>
+
+template<class T = E>
+ + + + + +
+ + + + + + + +
std::enable_if_t< has_data_interface< T >::value, typename T::storage_type & > xt::xshared_expression< E >::storage ()
+ 		+inlinenoexcept
+
+ +

Definition at line 621 of file xexpression.hpp.

+ +
+
+ +

◆ strides()

+ +
+
+
+template<class E>
+
+template<class T = E>
+ + + + + +
+ + + + + + + +
std::enable_if_t< has_strides< T >::value, const inner_strides_type & > xt::xshared_expression< E >::strides () const
+ 		+inline
+
+ +

Definition at line 591 of file xexpression.hpp.

+ +
+
+ +

◆ use_count()

+ +
+
+
+template<class E>
+ + + + + +
+ + + + + + + +
long xt::xshared_expression< E >::use_count () const
+ 		+inlinenoexcept
+
+ +

Return the number of times this expression is referenced.

+

Internally calls the use_count() function of the std::shared_ptr.

+ +

Definition at line 706 of file xexpression.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class E>
+ + + + + +
+ + + + +
bool xt::xshared_expression< E >::contiguous_layout = static_layout != layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 545 of file xexpression.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class E>
+ + + + + +
+ + + + +
layout_type xt::xshared_expression< E >::static_layout = E::static_layout
+ 		+staticconstexpr
+
+ +

Definition at line 544 of file xexpression.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xshared__expression.js b/classxt_1_1xshared__expression.js new file mode 100644 index 000000000..b92fe9afb --- /dev/null +++ b/classxt_1_1xshared__expression.js @@ -0,0 +1,5 @@ +var classxt_1_1xshared__expression = +[ + [ "xshared_expression", "classxt_1_1xshared__expression.html#a0eee9f39b506cc2e83b9b4c6dda150cf", null ], + [ "use_count", "classxt_1_1xshared__expression.html#ade23a460bdd1eb6102372076493f719e", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xshared__expression.png b/classxt_1_1xshared__expression.png new file mode 100644 index 000000000..7b65ffa0c Binary files /dev/null and b/classxt_1_1xshared__expression.png differ diff --git a/classxt_1_1xslice-members.html b/classxt_1_1xslice-members.html new file mode 100644 index 000000000..f15310224 --- /dev/null +++ b/classxt_1_1xslice-members.html @@ -0,0 +1,129 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xslice< D > Member List
+
+
+ +

This is the complete list of members for xt::xslice< D >, including all inherited members.

+ + + + + + + + + + +
derived_cast() noexcept (defined in xt::xslice< D >)xt::xslice< D >inline
derived_cast() const noexcept (defined in xt::xslice< D >)xt::xslice< D >inline
derived_type typedef (defined in xt::xslice< D >)xt::xslice< D >
operator=(const xslice &)=default (defined in xt::xslice< D >)xt::xslice< D >protected
operator=(xslice &&)=default (defined in xt::xslice< D >)xt::xslice< D >protected
xslice()=default (defined in xt::xslice< D >)xt::xslice< D >protected
xslice(const xslice &)=default (defined in xt::xslice< D >)xt::xslice< D >protected
xslice(xslice &&)=default (defined in xt::xslice< D >)xt::xslice< D >protected
~xslice()=default (defined in xt::xslice< D >)xt::xslice< D >protected
+
+ + + + diff --git a/classxt_1_1xslice.html b/classxt_1_1xslice.html new file mode 100644 index 000000000..b8d28ba52 --- /dev/null +++ b/classxt_1_1xslice.html @@ -0,0 +1,246 @@ + + + + + + + +xtensor: xt::xslice< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xslice< D > Class Template Reference
+
+
+
+Inheritance diagram for xt::xslice< D >:
+
+
+ + +xt::xall< typename E::size_type > +xt::xnewaxis< typename E::size_type > + +
+ + + + +

+Public Types

using derived_type = D
 
+ + + + + +

+Public Member Functions

derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + +

+Protected Member Functions

+ xslice (const xslice &)=default
 
+xslice & operator= (const xslice &)=default
 
+ xslice (xslice &&)=default
 
+xslice & operator= (xslice &&)=default
 
+

Detailed Description

+
template<class D>
+class xt::xslice< D >
+

Definition at line 42 of file xslice.hpp.

+

Member Typedef Documentation

+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xslice< D >::derived_type = D
+
+ +

Definition at line 46 of file xslice.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ derived_cast() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xslice< D >::derived_cast () const
+ 		+inlinenoexcept
+
+ +

Definition at line 980 of file xslice.hpp.

+ +
+
+ +

◆ derived_cast() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xslice< D >::derived_cast ()
+ 		+inlinenoexcept
+
+ +

Definition at line 974 of file xslice.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xslice.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xslice.png b/classxt_1_1xslice.png new file mode 100644 index 000000000..a578bf0f5 Binary files /dev/null and b/classxt_1_1xslice.png differ diff --git a/classxt_1_1xstepped__range-members.html b/classxt_1_1xstepped__range-members.html new file mode 100644 index 000000000..18a2198ba --- /dev/null +++ b/classxt_1_1xstepped__range-members.html @@ -0,0 +1,135 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xstepped_range< T > Member List
+
+
+ +

This is the complete list of members for xt::xstepped_range< T >, including all inherited members.

+ + + + + + + + + + + + + + + + +
contains(size_type i) const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
convert() const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
operator xstepped_range< S >() const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
operator!=(const self_type &rhs) const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
operator()(size_type i) const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
operator==(const self_type &rhs) const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
revert_index(std::size_t i) const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
self_type typedef (defined in xt::xstepped_range< T >)xt::xstepped_range< T >
size() const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
size_type typedef (defined in xt::xstepped_range< T >)xt::xstepped_range< T >
step_size() const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
step_size(std::size_t i, std::size_t n=1) const noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
xstepped_range (defined in xt::xstepped_range< T >)xt::xstepped_range< T >friend
xstepped_range()=default (defined in xt::xstepped_range< T >)xt::xstepped_range< T >
xstepped_range(size_type start_val, size_type stop_val, size_type step) noexcept (defined in xt::xstepped_range< T >)xt::xstepped_range< T >inline
+
+ + + + diff --git a/classxt_1_1xstepped__range.html b/classxt_1_1xstepped__range.html new file mode 100644 index 000000000..61c21a180 --- /dev/null +++ b/classxt_1_1xstepped__range.html @@ -0,0 +1,601 @@ + + + + + + + +xtensor: xt::xstepped_range< T > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xstepped_range< T > Class Template Reference
+
+
+
+Inheritance diagram for xt::xstepped_range< T >:
+
+
+ + +xt::xslice< xstepped_range< T > > + +
+ + + + + + + + + +

+Public Types

using size_type = T
 
using self_type = xstepped_range<T>
 
- Public Types inherited from xt::xslice< xstepped_range< T > >
using derived_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xstepped_range (size_type start_val, size_type stop_val, size_type step) noexcept
 
template<std::convertible_to< T > S>
 operator xstepped_range< S > () const noexcept
 
template<std::convertible_to< T > S>
xstepped_range< S > convert () const noexcept
 
size_type operator() (size_type i) const noexcept
 
size_type size () const noexcept
 
size_type step_size () const noexcept
 
size_type step_size (std::size_t i, std::size_t n=1) const noexcept
 
size_type revert_index (std::size_t i) const noexcept
 
bool contains (size_type i) const noexcept
 
bool operator== (const self_type &rhs) const noexcept
 
bool operator!= (const self_type &rhs) const noexcept
 
- Public Member Functions inherited from xt::xslice< xstepped_range< T > >
derived_type & derived_cast () noexcept
 
const derived_type & derived_cast () const noexcept
 
+ + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xslice< xstepped_range< T > >
+ xslice (const xslice &)=default
 
+ xslice (xslice &&)=default
 
+xslice & operator= (const xslice &)=default
 
+xslice & operator= (xslice &&)=default
 
+

Detailed Description

+
template<class T>
+class xt::xstepped_range< T >
+

Definition at line 146 of file xslice.hpp.

+

Member Typedef Documentation

+ +

◆ self_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xstepped_range< T >::self_type = xstepped_range<T>
+
+ +

Definition at line 151 of file xslice.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class T>
+ + + + +
using xt::xstepped_range< T >::size_type = T
+
+ +

Definition at line 150 of file xslice.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xstepped_range()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xstepped_range< T >::xstepped_range (size_type start_val,
size_type stop_val,
size_type step )
+ 		+inlinenoexcept
+
+ +

Definition at line 1066 of file xslice.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ contains()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xstepped_range< T >::contains (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1124 of file xslice.hpp.

+ +
+
+ +

◆ convert()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xstepped_range< S > xt::xstepped_range< T >::convert () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1088 of file xslice.hpp.

+ +
+
+ +

◆ operator xstepped_range< S >()

+ +
+
+
+template<class T>
+
+template<std::convertible_to< T > S>
+ + + + + +
+ + + + + + + +
xt::xstepped_range< T >::operator xstepped_range< S > () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1077 of file xslice.hpp.

+ +
+
+ +

◆ operator!=()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xstepped_range< T >::operator!= (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1136 of file xslice.hpp.

+ +
+
+ +

◆ operator()()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xstepped_range< T >::operator() (size_type i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1094 of file xslice.hpp.

+ +
+
+ +

◆ operator==()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
bool xt::xstepped_range< T >::operator== (const self_type & rhs) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1130 of file xslice.hpp.

+ +
+
+ +

◆ revert_index()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xstepped_range< T >::revert_index (std::size_t i) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1118 of file xslice.hpp.

+ +
+
+ +

◆ size()

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xstepped_range< T >::size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1100 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [1/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xstepped_range< T >::step_size () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1106 of file xslice.hpp.

+ +
+
+ +

◆ step_size() [2/2]

+ +
+
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xstepped_range< T >::step_size (std::size_t i,
std::size_t n = 1 ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1112 of file xslice.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xstepped_range

+ +
+
+
+template<class T>
+
+template<class S>
+ + + + + +
+ + + + +
friend class xstepped_range
+ 		+friend
+
+ +

Definition at line 183 of file xslice.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xslice.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xstepped__range.png b/classxt_1_1xstepped__range.png new file mode 100644 index 000000000..b267143b4 Binary files /dev/null and b/classxt_1_1xstepped__range.png differ diff --git a/classxt_1_1xstepper-members.html b/classxt_1_1xstepper-members.html new file mode 100644 index 000000000..959997b14 --- /dev/null +++ b/classxt_1_1xstepper-members.html @@ -0,0 +1,144 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xstepper< C > Member List
+
+
+ +

This is the complete list of members for xt::xstepper< C >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
operator*() const (defined in xt::xstepper< C >)xt::xstepper< C >inline
pointer typedef (defined in xt::xstepper< C >)xt::xstepper< C >
reference typedef (defined in xt::xstepper< C >)xt::xstepper< C >
reset(size_type dim) (defined in xt::xstepper< C >)xt::xstepper< C >inline
reset_back(size_type dim) (defined in xt::xstepper< C >)xt::xstepper< C >inline
shape_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
simd_return_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
simd_value_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
size_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
step(size_type dim, size_type n=1) (defined in xt::xstepper< C >)xt::xstepper< C >inline
step_back(size_type dim, size_type n=1) (defined in xt::xstepper< C >)xt::xstepper< C >inline
step_leading() (defined in xt::xstepper< C >)xt::xstepper< C >
step_simd() (defined in xt::xstepper< C >)xt::xstepper< C >
step_simd() -> simd_return_type< T > (defined in xt::xstepper< C >)xt::xstepper< C >inline
storage_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
store_simd(const R &vec) (defined in xt::xstepper< C >)xt::xstepper< C >inline
subiterator_traits typedef (defined in xt::xstepper< C >)xt::xstepper< C >
subiterator_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
to_begin() (defined in xt::xstepper< C >)xt::xstepper< C >inline
to_end(layout_type l) (defined in xt::xstepper< C >)xt::xstepper< C >inline
value_type typedef (defined in xt::xstepper< C >)xt::xstepper< C >
xstepper()=default (defined in xt::xstepper< C >)xt::xstepper< C >
xstepper(storage_type *c, subiterator_type it, size_type offset) noexcept (defined in xt::xstepper< C >)xt::xstepper< C >inline
+
+ + + + diff --git a/classxt_1_1xstepper.html b/classxt_1_1xstepper.html new file mode 100644 index 000000000..67c11a545 --- /dev/null +++ b/classxt_1_1xstepper.html @@ -0,0 +1,723 @@ + + + + + + + +xtensor: xt::xstepper< C > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xstepper< C > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using storage_type = C
 
using subiterator_type = get_stepper_iterator<C>
 
using subiterator_traits = std::iterator_traits<subiterator_type>
 
using value_type = typename subiterator_traits::value_type
 
using reference = typename subiterator_traits::reference
 
using pointer = typename subiterator_traits::pointer
 
using difference_type = typename subiterator_traits::difference_type
 
using size_type = typename storage_type::size_type
 
using shape_type = typename storage_type::shape_type
 
using simd_value_type = xt_simd::simd_type<value_type>
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

 xstepper (storage_type *c, subiterator_type it, size_type offset) noexcept
 
reference operator* () const
 
void step (size_type dim, size_type n=1)
 
void step_back (size_type dim, size_type n=1)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
+template<class T>
simd_return_type< T > step_simd ()
 
void step_leading ()
 
template<class R>
void store_simd (const R &vec)
 
template<class T>
auto step_simd () -> simd_return_type< T >
 
+

Detailed Description

+
template<class C>
+class xt::xstepper< C >
+

Definition at line 105 of file xiterator.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::difference_type = typename subiterator_traits::difference_type
+
+ +

Definition at line 115 of file xiterator.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::pointer = typename subiterator_traits::pointer
+
+ +

Definition at line 114 of file xiterator.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::reference = typename subiterator_traits::reference
+
+ +

Definition at line 113 of file xiterator.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::shape_type = typename storage_type::shape_type
+
+ +

Definition at line 117 of file xiterator.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<class C>
+
+template<class requested_type>
+ + + + +
using xt::xstepper< C >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 121 of file xiterator.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 118 of file xiterator.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::size_type = typename storage_type::size_type
+
+ +

Definition at line 116 of file xiterator.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::storage_type = C
+
+ +

Definition at line 109 of file xiterator.hpp.

+ +
+
+ +

◆ subiterator_traits

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::subiterator_traits = std::iterator_traits<subiterator_type>
+
+ +

Definition at line 111 of file xiterator.hpp.

+ +
+
+ +

◆ subiterator_type

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::subiterator_type = get_stepper_iterator<C>
+
+ +

Definition at line 110 of file xiterator.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class C>
+ + + + +
using xt::xstepper< C >::value_type = typename subiterator_traits::value_type
+
+ +

Definition at line 112 of file xiterator.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xstepper()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xstepper< C >::xstepper (storage_type * c,
subiterator_type it,
size_type offset )
+ 		+inlinenoexcept
+
+ +

Definition at line 476 of file xiterator.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + +
auto xt::xstepper< C >::operator* () const
+ 		+inline
+
+ +

Definition at line 484 of file xiterator.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + +
void xt::xstepper< C >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 510 of file xiterator.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + +
void xt::xstepper< C >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 519 of file xiterator.hpp.

+ +
+
+ +

◆ step()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + + + + + +
void xt::xstepper< C >::step (size_type dim,
size_type n = 1 )
+ 		+inline
+
+ +

Definition at line 490 of file xiterator.hpp.

+ +
+
+ +

◆ step_back()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + + + + + +
void xt::xstepper< C >::step_back (size_type dim,
size_type n = 1 )
+ 		+inline
+
+ +

Definition at line 500 of file xiterator.hpp.

+ +
+
+ +

◆ step_leading()

+ +
+
+
+template<class C>
+ + + + + + + +
void xt::xstepper< C >::step_leading ()
+
+ +

Definition at line 584 of file xiterator.hpp.

+ +
+
+ +

◆ step_simd()

+ +
+
+
+template<class C>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xstepper< C >::step_simd () -> simd_return_type<T> +
+ 		+inline
+
+ +

Definition at line 566 of file xiterator.hpp.

+ +
+
+ +

◆ store_simd()

+ +
+
+
+template<class C>
+
+template<class R>
+ + + + + +
+ + + + + + + +
void xt::xstepper< C >::store_simd (const R & vec)
+ 		+inline
+
+ +

Definition at line 576 of file xiterator.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + +
void xt::xstepper< C >::to_begin ()
+ 		+inline
+
+ +

Definition at line 528 of file xiterator.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<class C>
+ + + + + +
+ + + + + + + +
void xt::xstepper< C >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 534 of file xiterator.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xiterator.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xstrided__container-members.html b/classxt_1_1xstrided__container-members.html new file mode 100644 index 000000000..74e1d8dcd --- /dev/null +++ b/classxt_1_1xstrided__container-members.html @@ -0,0 +1,321 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xstrided_container< D > Member List
+
+
+ +

This is the complete list of members for xt::xstrided_container< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
accessible_base typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
allocator_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
at(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
back()xt::xcontainer< D >inline
backstrides() const noexceptxt::xcontainer< D >
backstrides_impl() noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
backstrides_impl() const noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
backstrides_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
base_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
begin() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< D >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
bool_load_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< D >inline
cbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
cend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
const_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_container_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_pointer typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
const_reference typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
const_reverse_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
const_reverse_linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
const_stepper typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
container_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
contiguous_layout (defined in xt::xcontainer< D >)xt::xcontainer< D >static
crbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
crend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
data() noexceptxt::xcontainer< D >inline
data() const noexceptxt::xcontainer< D >inline
data_alignment typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
data_element(size_type i) (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
data_element(size_type i) const (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
data_offset() const noexceptxt::xcontainer< D >inline
data_xbegin() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
data_xbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
data_xend(layout_type l, size_type offset) noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
data_xend(layout_type l, size_type offset) const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_cast() &noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_cast() const &noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_cast() &&noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inlineprotected
derived_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
difference_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
dimension() const noexceptxt::xcontainer< D >
element(It first, It last) (defined in xt::xcontainer< D >)xt::xcontainer< D >
element(It first, It last) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
element(It first, It last) -> referencext::xcontainer< D >inline
element(It first, It last) const -> const_referencext::xcontainer< D >inline
end() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< D >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< D >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
fill(const T &value)xt::xcontainer< D >inline
flat(size_type i)xt::xcontainer< D >inline
flat(size_type i) constxt::xcontainer< D >inline
front()xt::xcontainer< D >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< D >inline
inner_backstrides_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
inner_shape_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
inner_strides_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
inner_types typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
is_contiguous() const noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inline
iterable_base typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
layout() const noexceptxt::xstrided_container< D >inline
layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
linear_begin() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_begin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_cbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_cend() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_crbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_crend() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_end() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_end() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
linear_rbegin() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_rbegin() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_rend() noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_rend() const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
linear_traits typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
load_simd(size_type i) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
load_simd(size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type > (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
mutable_layout() noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
operator()(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator()(Args... args) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator()(Args... args) -> referencext::xcontainer< D >inline
operator()(Args... args) const -> const_referencext::xcontainer< D >inline
operator=(const xstrided_container &)=default (defined in xt::xstrided_container< D >)xt::xstrided_container< D >protected
operator=(xstrided_container &&)=default (defined in xt::xstrided_container< D >)xt::xstrided_container< D >protected
operator=(const xcontainer &)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
operator=(xcontainer &&)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
operator=(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
operator=(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
operator=(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator=(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator[](const S &index) (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator[](std::initializer_list< I > index) (defined in xt::xcontainer< D >)xt::xcontainer< D >
operator[](size_type i) (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
periodic(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
pointer typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
rbegin() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
reference typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
rend() noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend() const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend(const S &shape) noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend(const S &shape) const noexcept (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< D >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< D >inline
reshape(S &&shape, layout_type layout=base_type::static_layout) &xt::xstrided_container< D >inline
reshape(std::initializer_list< T > shape, layout_type layout=base_type::static_layout) & (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inline
reshape_impl(S &&shape, std::true_type, layout_type layout=base_type::static_layout) (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
reshape_impl(S &&shape, std::false_type, layout_type layout=base_type::static_layout) (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
resize(S &&shape, bool force=false)xt::xstrided_container< D >inline
resize(S &&shape, layout_type l)xt::xstrided_container< D >inline
resize(S &&shape, const strides_type &strides)xt::xstrided_container< D >inline
reverse_broadcast_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_layout_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
reverse_linear_iterator typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
select_const_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_const_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_iterator_impl typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
select_reverse_iterator typedef (defined in xt::xcontiguous_iterable< D >)xt::xcontiguous_iterable< D >
shape() const noexceptxt::xcontainer< D >
shape_impl() noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
shape_impl() const noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
shape_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
simd_return_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
simd_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
simd_value_type typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
size() const noexceptxt::xcontainer< D >inline
size_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
static_layout (defined in xt::xcontainer< D >)xt::xcontainer< D >static
stepper typedef (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_begin(const S &shape) noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_begin(const S &shape) const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_begin(const S &shape) noexcept -> stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
stepper_begin(const S &shape) const noexcept -> const_stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
stepper_end(const S &shape, layout_type l) noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_end(const S &shape, layout_type l) const noexcept (defined in xt::xcontainer< D >)xt::xcontainer< D >
stepper_end(const S &shape, layout_type l) noexcept -> stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
stepper_end(const S &shape, layout_type l) const noexcept -> const_stepper (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
storage() noexceptxt::xcontainer< D >inline
storage() const noexceptxt::xcontainer< D >inline
storage_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
store_simd(size_type i, const simd &e) (defined in xt::xcontainer< D >)xt::xcontainer< D >inline
strides() const noexceptxt::xcontainer< D >
strides_impl() noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
strides_impl() const noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
strides_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
unchecked(Args... args) (defined in xt::xcontainer< D >)xt::xcontainer< D >
unchecked(Args... args) const (defined in xt::xcontainer< D >)xt::xcontainer< D >
unchecked(Args... args) -> referencext::xcontainer< D >inline
unchecked(Args... args) const -> const_referencext::xcontainer< D >inline
value_type typedef (defined in xt::xstrided_container< D >)xt::xstrided_container< D >
xcontainer()=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
xcontainer(const xcontainer &)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
xcontainer(xcontainer &&)=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
xstrided_container() noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineprotected
xstrided_container(const xstrided_container &)=default (defined in xt::xstrided_container< D >)xt::xstrided_container< D >protected
xstrided_container(xstrided_container &&)=default (defined in xt::xstrided_container< D >)xt::xstrided_container< D >protected
xstrided_container(inner_shape_type &&, inner_strides_type &&) noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineexplicitprotected
xstrided_container(inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept (defined in xt::xstrided_container< D >)xt::xstrided_container< D >inlineexplicitprotected
~xcontainer()=default (defined in xt::xcontainer< D >)xt::xcontainer< D >protected
~xstrided_container()=default (defined in xt::xstrided_container< D >)xt::xstrided_container< D >protected
+
+ + + + diff --git a/classxt_1_1xstrided__container.html b/classxt_1_1xstrided__container.html new file mode 100644 index 000000000..1e44c6db8 --- /dev/null +++ b/classxt_1_1xstrided__container.html @@ -0,0 +1,1726 @@ + + + + + + + +xtensor: xt::xstrided_container< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Protected Member Functions | +List of all members
+
xt::xstrided_container< D > Class Template Reference
+
+
+ +

Partial implementation of xcontainer that embeds the strides and the shape. + More...

+ +

#include <xcontainer.hpp>

+
+Inheritance diagram for xt::xstrided_container< D >:
+
+
+ + +xt::xcontainer< D > +xt::xcontiguous_iterable< D > +xt::xaccessible< D > +xt::xiterable< D > +xt::xarray_adaptor< value_container &, L, SC > +xt::xarray_adaptor< flag_container &, L, SC > +xt::xarray_adaptor< const value_container &, L, SC > +xt::xarray_adaptor< const flag_container &, L, SC > +xt::xarray_adaptor< EC, L, SC, xoptional_expression_tag > +xt::xarray_container< temporary_container_t< storage_type >, L, SC, Tag > +xt::xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > +xt::xarray_container< xtl::xoptional_vector< T, A, BC >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true >, xoptional_expression_tag > +xt::xarray_container< EC, L, SC, xoptional_expression_tag > +xt::xtensor_adaptor< value_container &, N, L > +xt::xtensor_adaptor< flag_container &, N, L > +xt::xtensor_adaptor< const value_container &, N, L > +xt::xtensor_adaptor< const flag_container &, N, L > +xt::xtensor_adaptor< EC, N, L, xoptional_expression_tag > +xt::xtensor_container< temporary_container_t< storage_type >, N, L, Tag > +xt::xtensor_container< uvector< T, A >, N, L > +xt::xtensor_container< xtl::xoptional_vector< T, A, BC >, N, L, xoptional_expression_tag > +xt::xtensor_container< std::vector< T, A >, 2, layout_type::row_major > +xt::xtensor_container< EC, N, L, xoptional_expression_tag > +xt::xtensor_view< EC, N, L, xoptional_expression_tag > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using base_type = xcontainer<D>
 
using storage_type = typename base_type::storage_type
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using size_type = typename base_type::size_type
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using inner_shape_type = typename base_type::inner_shape_type
 
using inner_strides_type = typename base_type::inner_strides_type
 
using inner_backstrides_type = typename base_type::inner_backstrides_type
 
- Public Types inherited from xt::xcontainer< D >
using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using storage_type = typename inner_types::storage_type
 
using allocator_type = allocator_type_t<std::decay_t<storage_type>>
 
using value_type = typename storage_type::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer = typename storage_type::pointer
 
using const_pointer = typename storage_type::const_pointer
 
using size_type = typename inner_types::size_type
 
using difference_type = typename storage_type::difference_type
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = xt::bool_load_type<value_type>
 
using shape_type = typename inner_types::shape_type
 
using strides_type = typename inner_types::strides_type
 
using backstrides_type = typename inner_types::backstrides_type
 
using inner_shape_type = typename inner_types::inner_shape_type
 
using inner_strides_type = typename inner_types::inner_strides_type
 
using inner_backstrides_type = typename inner_types::inner_backstrides_type
 
using iterable_base = xcontiguous_iterable<D>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using accessible_base = xaccessible<D>
 
using data_alignment = xt_simd::container_alignment_t<storage_type>
 
using simd_type = xt_simd::simd_type<value_type>
 
using linear_iterator = typename iterable_base::linear_iterator
 
using const_linear_iterator = typename iterable_base::const_linear_iterator
 
using reverse_linear_iterator = typename iterable_base::reverse_linear_iterator
 
using const_reverse_linear_iterator = typename iterable_base::const_reverse_linear_iterator
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
using container_iterator = linear_iterator
 
using const_container_iterator = const_linear_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< D >
using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using iterable_base = xiterable<D>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
template<layout_type L>
using layout_iterator = typename iterable_base::template layout_iterator<L>
 
template<layout_type L>
using const_layout_iterator = typename iterable_base::template const_layout_iterator<L>
 
template<layout_type L>
using reverse_layout_iterator = typename iterable_base::template reverse_layout_iterator<L>
 
template<layout_type L>
using const_reverse_layout_iterator = typename iterable_base::template const_reverse_layout_iterator<L>
 
template<class S, layout_type L>
using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_broadcast_iterator = typename iterable_base::template const_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using reverse_broadcast_iterator = typename iterable_base::template reverse_broadcast_iterator<S, L>
 
template<class S, layout_type L>
using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>
 
using linear_traits = detail::linear_iterator_traits<D>
 
using linear_iterator = typename linear_traits::linear_iterator
 
using const_linear_iterator = typename linear_traits::const_linear_iterator
 
using reverse_linear_iterator = typename linear_traits::reverse_linear_iterator
 
using const_reverse_linear_iterator = typename linear_traits::const_reverse_linear_iterator
 
template<layout_type L, class It1, class It2>
using select_iterator_impl = std::conditional_t<L == static_layout, It1, It2>
 
template<layout_type L>
using select_iterator = select_iterator_impl<L, linear_iterator, layout_iterator<L>>
 
template<layout_type L>
using select_const_iterator = select_iterator_impl<L, const_linear_iterator, const_layout_iterator<L>>
 
template<layout_type L>
using select_reverse_iterator = select_iterator_impl<L, reverse_linear_iterator, reverse_layout_iterator<L>>
 
template<layout_type L>
using select_const_reverse_iterator
 
using iterator = select_iterator< ::xt::layout_type::row_major >
 
using const_iterator = select_const_iterator< ::xt::layout_type::row_major >
 
using reverse_iterator = select_reverse_iterator< ::xt::layout_type::row_major >
 
using const_reverse_iterator = select_const_reverse_iterator< ::xt::layout_type::row_major >
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

+ xstrided_container (const xstrided_container &)=default
 
+xstrided_container & operator= (const xstrided_container &)=default
 
+ xstrided_container (xstrided_container &&)=default
 
+xstrided_container & operator= (xstrided_container &&)=default
 
- Protected Member Functions inherited from xt::xcontainer< D >
+ xcontainer (const xcontainer &)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class S = shape_type>
void resize (S &&shape, bool force=false)
 Resizes the container.
 
template<class S = shape_type>
void resize (S &&shape, layout_type l)
 Resizes the container.
 
template<class S = shape_type>
void resize (S &&shape, const strides_type &strides)
 Resizes the container.
 
template<class S = shape_type>
auto & reshape (S &&shape, layout_type layout=base_type::static_layout) &
 Reshapes the container and keeps old elements.
 
template<class T>
auto & reshape (std::initializer_list< T > shape, layout_type layout=base_type::static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&) noexcept
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept
 
inner_shape_type & shape_impl () noexcept
 
const inner_shape_type & shape_impl () const noexcept
 
inner_strides_type & strides_impl () noexcept
 
const inner_strides_type & strides_impl () const noexcept
 
inner_backstrides_type & backstrides_impl () noexcept
 
const inner_backstrides_type & backstrides_impl () const noexcept
 
template<class S = shape_type>
void reshape_impl (S &&shape, std::true_type, layout_type layout=base_type::static_layout)
 
template<class S = shape_type>
void reshape_impl (S &&shape, std::false_type, layout_type layout=base_type::static_layout)
 
layout_type & mutable_layout () noexcept
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Public Member Functions inherited from xt::xcontainer< D >
+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
reference element (It first, It last)
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class S>
stepper stepper_begin (const S &shape) noexcept
 
+template<class S>
stepper stepper_end (const S &shape, layout_type l) noexcept
 
+template<class S>
const_stepper stepper_begin (const S &shape) const noexcept
 
+template<class S>
const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+template<class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+template<class... Args>
reference at (Args... args)
 
+template<class S>
disable_integral_t< S, reference > operator[] (const S &index)
 
+template<class I>
reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+template<class... Args>
reference periodic (Args... args)
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
template<class T>
void fill (const T &value)
 Fills the container with the given value.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
template<class... Args>
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
template<class... Args>
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
template<class It>
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
template<class S>
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
template<class S>
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
template<class align, class simd>
void store_simd (size_type i, const simd &e)
 
linear_iterator linear_begin () noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
template<class S>
auto stepper_begin (const S &shape) noexcept -> stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
template<class S>
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
template<class S>
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
template<class alignment, class requested_type, std::size_t N>
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
- Public Member Functions inherited from xt::xcontiguous_iterable< D >
+template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L > begin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_iterator< L > end () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > begin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > end () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > cbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_iterator< L > cend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L > rbegin () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_reverse_iterator< L > rend () noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > rbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > rend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > crbegin () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major>
select_const_reverse_iterator< L > crend () const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
broadcast_iterator< S, L > end (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+template<layout_type L = ::xt::layout_type::row_major, class S>
const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
template<layout_type L>
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L>
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L>
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L>
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L>
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L>
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L>
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
template<layout_type L, class S>
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
template<layout_type L, class S>
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
template<layout_type L, class S>
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Static Public Attributes inherited from xt::xcontainer< D >
static constexpr layout_type static_layout = inner_types::layout
 
static constexpr bool contiguous_layout = static_layout != layout_type::dynamic
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< D >
static constexpr layout_type static_layout = inner_types::layout
 
+

Detailed Description

+
template<class D>
+class xt::xstrided_container< D >

Partial implementation of xcontainer that embeds the strides and the shape.

+

The xstrided_container class is a partial implementation of the xcontainer interface that embed the strides and the shape of the multidimensional container. It does not embed the data container, this responsibility is delegated to the inheriting classes.

+
Template Parameters
+ + +
DThe derived type, i.e. the inheriting class for which xstrided_container provides the partial imlpementation of xcontainer.
+
+
+ +

Definition at line 258 of file xcontainer.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::base_type = xcontainer<D>
+
+ +

Definition at line 262 of file xcontainer.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 268 of file xcontainer.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 266 of file xcontainer.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::inner_backstrides_type = typename base_type::inner_backstrides_type
+
+ +

Definition at line 274 of file xcontainer.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::inner_shape_type = typename base_type::inner_shape_type
+
+ +

Definition at line 272 of file xcontainer.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::inner_strides_type = typename base_type::inner_strides_type
+
+ +

Definition at line 273 of file xcontainer.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::pointer = typename base_type::pointer
+
+ +

Definition at line 267 of file xcontainer.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::reference = typename base_type::reference
+
+ +

Definition at line 265 of file xcontainer.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 270 of file xcontainer.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::size_type = typename base_type::size_type
+
+ +

Definition at line 269 of file xcontainer.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 263 of file xcontainer.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 271 of file xcontainer.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_container< D >::value_type = typename base_type::value_type
+
+ +

Definition at line 264 of file xcontainer.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xstrided_container() [1/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
xt::xstrided_container< D >::xstrided_container ()
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 849 of file xcontainer.hpp.

+ +
+
+ +

◆ xstrided_container() [2/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + +
xt::xstrided_container< D >::xstrided_container (inner_shape_type && shape,
inner_strides_type && strides )
+ 		+inlineexplicitprotectednoexcept
+
+ +

Definition at line 858 of file xcontainer.hpp.

+ +
+
+ +

◆ xstrided_container() [3/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + +
xt::xstrided_container< D >::xstrided_container (inner_shape_type && shape,
inner_strides_type && strides,
inner_backstrides_type && backstrides,
layout_type && layout )
+ 		+inlineexplicitprotectednoexcept
+
+ +

Definition at line 868 of file xcontainer.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ backstrides_impl() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_container< D >::backstrides_impl () const
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 913 of file xcontainer.hpp.

+ +
+
+ +

◆ backstrides_impl() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_container< D >::backstrides_impl ()
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 907 of file xcontainer.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
bool xt::xstrided_container< D >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 929 of file xcontainer.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
layout_type xt::xstrided_container< D >::layout () const
+ 		+inlinenoexcept
+
+ +

Return the layout_type of the container.

+
Returns
layout_type of the container
+ +

Definition at line 923 of file xcontainer.hpp.

+ +
+
+ +

◆ mutable_layout()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_container< D >::mutable_layout ()
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 1184 of file xcontainer.hpp.

+ +
+
+ +

◆ reshape() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
auto & xt::xstrided_container< D >::reshape (S && shape,
layout_type layout = base_type::static_layout ) &
+ 		+inline
+
+ +

Reshapes the container and keeps old elements.

+

The shape argument can have one of its value equal to -1, in this case the value is inferred from the number of elements in the container and the remaining values in the shape.

xt::xarray<int> a = { 1, 2, 3, 4, 5, 6, 7, 8 };
+
a.reshape({-1, 4});
+
//a.shape() is {2, 4}
+
xt::xstrided_container::reshape
auto & reshape(S &&shape, layout_type layout=base_type::static_layout) &
Reshapes the container and keeps old elements.
Definition xcontainer.hpp:1092
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
Parameters
+ + + +
shapethe new shape (has to have same number of elements as the original container)
layoutthe layout to compute the strides (defaults to static layout of the container, or for a container with dynamic layout to XTENSOR_DEFAULT_LAYOUT)
+
+
+ +

Definition at line 1092 of file xcontainer.hpp.

+ +
+
+ +

◆ reshape() [2/2]

+ +
+
+
+template<class D>
+
+template<class T>
+ + + + + +
+ + + + + + + + + + + +
auto & xt::xstrided_container< D >::reshape (std::initializer_list< T > shape,
layout_type layout = base_type::static_layout ) &
+ 		+inline
+
+ +

Definition at line 1104 of file xcontainer.hpp.

+ +
+
+ +

◆ reshape_impl() [1/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + + + + + + +
void xt::xstrided_container< D >::reshape_impl (S && shape,
std::false_type ,
layout_type layout = base_type::static_layout )
+ 		+inlineprotected
+
+ +

Definition at line 1116 of file xcontainer.hpp.

+ +
+
+ +

◆ reshape_impl() [2/2]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + + + + + + +
void xt::xstrided_container< D >::reshape_impl (S && shape,
std::true_type ,
layout_type layout = base_type::static_layout )
+ 		+inlineprotected
+
+ +

Definition at line 1143 of file xcontainer.hpp.

+ +
+
+ +

◆ resize() [1/3]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xstrided_container< D >::resize (S && shape,
bool force = false )
+ 		+inline
+
+ +

Resizes the container.

+
Warning
Contrary to STL containers like std::vector, resize does NOT preserve the container elements.
+
Parameters
+ + + +
shapethe new shape
forceforce reshaping, even if the shape stays the same (default: false)
+
+
+ +

Definition at line 998 of file xcontainer.hpp.

+ +
+
+ +

◆ resize() [2/3]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xstrided_container< D >::resize (S && shape,
const strides_type & strides )
+ 		+inline
+
+ +

Resizes the container.

+
Warning
Contrary to STL containers like std::vector, resize does NOT preserve the container elements.
+
Parameters
+ + + +
shapethe new shape
stridesthe new strides
+
+
+ +

Definition at line 1056 of file xcontainer.hpp.

+ +
+
+ +

◆ resize() [3/3]

+ +
+
+
+template<class D>
+
+template<class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xstrided_container< D >::resize (S && shape,
layout_type l )
+ 		+inline
+
+ +

Resizes the container.

+
Warning
Contrary to STL containers like std::vector, resize does NOT preserve the container elements.
+
Parameters
+ + + +
shapethe new shape
lthe new layout_type
+
+
+ +

Definition at line 1030 of file xcontainer.hpp.

+ +
+
+ +

◆ shape_impl() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_container< D >::shape_impl () const
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 889 of file xcontainer.hpp.

+ +
+
+ +

◆ shape_impl() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_container< D >::shape_impl ()
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 883 of file xcontainer.hpp.

+ +
+
+ +

◆ strides_impl() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_container< D >::strides_impl () const
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 901 of file xcontainer.hpp.

+ +
+
+ +

◆ strides_impl() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_container< D >::strides_impl ()
+ 		+inlineprotectednoexcept
+
+ +

Definition at line 895 of file xcontainer.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xcontainer.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xstrided__container.js b/classxt_1_1xstrided__container.js new file mode 100644 index 000000000..d04c8971a --- /dev/null +++ b/classxt_1_1xstrided__container.js @@ -0,0 +1,8 @@ +var classxt_1_1xstrided__container = +[ + [ "layout", "classxt_1_1xstrided__container.html#a475028ed0b0719aebc55afe8fc00728e", null ], + [ "reshape", "classxt_1_1xstrided__container.html#ade4f89e605eb5ade6b47507eb411702b", null ], + [ "resize", "classxt_1_1xstrided__container.html#af38c6e8082f27cfbaa445767c14c0110", null ], + [ "resize", "classxt_1_1xstrided__container.html#a9853404ceb5a3d42430c43508abb671b", null ], + [ "resize", "classxt_1_1xstrided__container.html#ac157fa05a058950206b21ed403d969fe", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xstrided__container.png b/classxt_1_1xstrided__container.png new file mode 100644 index 000000000..45636002e Binary files /dev/null and b/classxt_1_1xstrided__container.png differ diff --git a/classxt_1_1xstrided__view-members.html b/classxt_1_1xstrided__view-members.html new file mode 100644 index 000000000..ff99edb8b --- /dev/null +++ b/classxt_1_1xstrided__view-members.html @@ -0,0 +1,307 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xstrided_view< CT, S, L, FST > Member List
+
+
+ +

This is the complete list of members for xt::xstrided_view< CT, S, L, FST >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
assign_temporary(temporary_type &&)xt::xview_semantic< D >inline
assign_xexpression(const xexpression< E > &e) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
assign_xexpression(const xexpression< E > &e) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
backstrides() const noexceptxt::xstrided_view< CT, S, L, FST >
backstrides_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
base_index_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
base_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
bit_and_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_or_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_xor_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bool_load_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
broadcast_shape(O &shape, bool reuse_cache=false) constxt::xstrided_view< CT, S, L, FST >
build_view(E &&e) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
build_view(E &&e) const -> rebind_t< E > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
computed_assign(const xexpression< E > &e) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
computed_assign(const xexpression< E > &e) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
const_container_iterator typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
const_linear_iterator typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
const_pointer typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
const_reference typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
const_reverse_linear_iterator typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
const_stepper typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
container_iterator typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
contiguous_layout (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >static
data() noexceptxt::xstrided_view< CT, S, L, FST >
data() const noexceptxt::xstrided_view< CT, S, L, FST >
data_alignment typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
data_element(size_type i) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
data_element(size_type i) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
data_offset() const noexceptxt::xstrided_view< CT, S, L, FST >
derived_type typedef (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
derived_type typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >private
difference_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
divides_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
element(It first, It last) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
element(It first, It last) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
expression() noexceptxt::xstrided_view< CT, S, L, FST >
expression() const noexceptxt::xstrided_view< CT, S, L, FST >
expression_tag typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
extension_base typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
fill(const T &value)xt::xstrided_view< CT, S, L, FST >inline
flat(size_type i) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
flat(size_type i) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
has_linear_assign(const O &strides) const noexceptxt::xstrided_view< CT, S, L, FST >
inner_backstrides_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
inner_shape_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
inner_storage_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
inner_strides_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
is_const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >static
is_contiguous() const noexcept (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
iterable_base typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
layout() const noexceptxt::xstrided_view< CT, S, L, FST >
linear_begin() (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_begin() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_cbegin() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_cend() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_crbegin() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_crend() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_end() (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_end() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_iterator typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
linear_rbegin() (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_rbegin() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_rend() (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
linear_rend() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
load_simd(size_type i) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
load_simd(size_type i) const -> simd_return_type< requested_type > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
minus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
modulus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
multiplies_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator%=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator&=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator()() (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
operator()() const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
operator()(Args... args) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
operator()(Args... args) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
operator*=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator+=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator-=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator/=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator=(const self_type &) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
operator=(const xexpression< E > &e) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
operator=(const E &e) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
operator=(const xexpression< E > &e) -> self_type &xt::xstrided_view< CT, S, L, FST >inline
operator=(const E &e) -> disable_xexpression< E, self_type > & (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
operator=(const xview_semantic &)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
operator=(xview_semantic &&)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
operator=(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator=(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >private
operator=(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >private
operator=(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >private
operator^=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator|=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
plus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
pointer typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
provides_simd_interface (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >static
rebind_t typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
reference typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
reverse_linear_iterator typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
scalar_computed_assign(const E &e, F &&f) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
scalar_computed_assign(const E &e, F &&f) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
self_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
semantic_base typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
shape() const noexceptxt::xstrided_view< CT, S, L, FST >
xt::xaccessible::shape(size_type index) constxt::xconst_accessible< D >inlineprivate
shape_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
simd_return_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
simd_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
simd_value_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
size_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
static_layout (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >static
stepper typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_begin(const ST &shape) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_begin(const ST &shape) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_begin(const ST &shape) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_begin(const ST &shape) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_begin(const ST &shape) -> disable_indexed_stepper_t< STEP > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
stepper_begin(const ST &shape) const -> disable_indexed_stepper_t< STEP > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
stepper_end(const ST &shape, layout_type l) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_end(const ST &shape, layout_type l) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_end(const ST &shape, layout_type l) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_end(const ST &shape, layout_type l) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
stepper_end(const ST &shape, layout_type l) -> disable_indexed_stepper_t< STEP > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
stepper_end(const ST &shape, layout_type l) const -> disable_indexed_stepper_t< STEP > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
storage() noexceptxt::xstrided_view< CT, S, L, FST >
storage() const noexceptxt::xstrided_view< CT, S, L, FST >
storage_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
store_simd(size_type i, const simd &e) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >inline
strides() const noexceptxt::xstrided_view< CT, S, L, FST >
strides_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
temporary_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
unchecked(Args... args) (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
unchecked(Args... args) const (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
value_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
xaccessible< self_type > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >friend
xaxis_iterator (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >friend
xaxis_slice_iterator (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >friend
xconst_accessible< self_type > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >friend
xexpression_type typedef (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xstepper (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >friend
xstrided_view(CTA &&e, SA &&shape, strides_type &&strides, std::size_t offset, layout_type layout) noexceptxt::xstrided_view< CT, S, L, FST >inline
xstrided_view(const xstrided_view &rhs)=default (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >
xview_semantic()=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic(const xview_semantic &)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic(xview_semantic &&)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic< self_type > (defined in xt::xstrided_view< CT, S, L, FST >)xt::xstrided_view< CT, S, L, FST >friend
~xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
~xview_semantic()=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
+
+ + + + diff --git a/classxt_1_1xstrided__view.html b/classxt_1_1xstrided__view.html new file mode 100644 index 000000000..648253d66 --- /dev/null +++ b/classxt_1_1xstrided__view.html @@ -0,0 +1,2747 @@ + + + + + + + +xtensor: xt::xstrided_view< CT, S, L, FST > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xstrided_view< CT, S, L, FST > Class Template Reference
+
+
+ +

View of an xexpression using strides. + More...

+ +

#include <xstrided_view.hpp>

+
+Inheritance diagram for xt::xstrided_view< CT, S, L, FST >:
+
+
+ + +xt::xview_semantic< D > +xt::xstrided_view_base< D > +xt::xsemantic_base< D > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xstrided_view<CT, S, L, FST>
 
using base_type = xstrided_view_base<self_type>
 
using semantic_base = xview_semantic<self_type>
 
using extension_base = extension::xstrided_view_base_t<CT, S, L, FST>
 
using expression_tag = typename extension_base::expression_tag
 
using xexpression_type = typename base_type::xexpression_type
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using size_type = typename base_type::size_type
 
using difference_type = typename base_type::difference_type
 
using inner_storage_type = typename base_type::inner_storage_type
 
using storage_type = typename base_type::storage_type
 
using linear_iterator = typename storage_type::iterator
 
using const_linear_iterator = typename storage_type::const_iterator
 
using reverse_linear_iterator = std::reverse_iterator<linear_iterator>
 
using const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>
 
using iterable_base = select_iterable_base_t<L, xexpression_type::static_layout, self_type>
 
using inner_shape_type = typename base_type::inner_shape_type
 
using inner_strides_type = typename base_type::inner_strides_type
 
using inner_backstrides_type = typename base_type::inner_backstrides_type
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
 
using base_index_type = xindex_type_t<shape_type>
 
using data_alignment = xt_simd::container_alignment_t<storage_type>
 
using simd_type = xt_simd::simd_type<value_type>
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = typename base_type::bool_load_type
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
using container_iterator
 
using const_container_iterator = typename storage_type::const_iterator
 
template<class E>
using rebind_t = xstrided_view<E, S, L, typename FST::template rebind_t<E>>
 
- Public Types inherited from xt::xview_semantic< D >
using base_type = xsemantic_base<D>
 
using derived_type = D
 
using temporary_type = typename base_type::temporary_type
 
- Public Types inherited from xt::xsemantic_base< D >
using base_type = select_expression_base_t<D>
 
using derived_type = typename base_type::derived_type
 
using temporary_type = typename xcontainer_inner_types<D>::temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xstrided_view (const xstrided_view &rhs)=default
 
+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
+template<class ST, class STEP = stepper>
disable_indexed_stepper_t< STEP > stepper_begin (const ST &shape)
 
+template<class ST, class STEP = stepper>
disable_indexed_stepper_t< STEP > stepper_end (const ST &shape, layout_type l)
 
+template<class ST, class STEP = stepper>
enable_indexed_stepper_t< STEP > stepper_begin (const ST &shape)
 
+template<class ST, class STEP = stepper>
enable_indexed_stepper_t< STEP > stepper_end (const ST &shape, layout_type l)
 
+template<class ST, class STEP = const_stepper>
disable_indexed_stepper_t< STEP > stepper_begin (const ST &shape) const
 
+template<class ST, class STEP = const_stepper>
disable_indexed_stepper_t< STEP > stepper_end (const ST &shape, layout_type l) const
 
+template<class ST, class STEP = const_stepper>
enable_indexed_stepper_t< STEP > stepper_begin (const ST &shape) const
 
+template<class ST, class STEP = const_stepper>
enable_indexed_stepper_t< STEP > stepper_end (const ST &shape, layout_type l) const
 
+template<class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size>
+requires provides_simd_interface
simd_return_type< requested_type > load_simd (size_type i) const
 
+template<class E>
rebind_t< E > build_view (E &&e) const
 
+const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the xtrided_view_base.
 
+bool is_contiguous () const noexcept
 
+layout_type layout () const noexcept
 Returns the layout of the xtrided_view_base.
 
+const inner_shape_type & shape () const noexcept
 Returns the shape of the xtrided_view_base.
 
+const inner_strides_type & strides () const noexcept
 Returns the strides of the xtrided_view_base.
 
+reference operator() ()
 
+const_reference operator() () const
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
+size_type data_offset () const noexcept
 Returns the offset to the first element in the view.
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
+const xexpression_type & expression () const noexcept
 Returns a constant reference to the underlying expression of the view.
 
+storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the view.
 
+const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the view.
 
bool broadcast_shape (O &shape, bool reuse_cache=false) const
 Broadcast the shape of the view to the specified parameter.
 
bool has_linear_assign (const O &strides) const noexcept
 Checks whether the xstrided_view_base can be linearly assigned to an expression with the specified strides.
 
Constructor
template<class CTA, class SA>
 xstrided_view (CTA &&e, SA &&shape, strides_type &&strides, std::size_t offset, layout_type layout) noexcept
 Constructs an xstrided_view.
 
self_type & operator= (const self_type &)
 
- Public Member Functions inherited from xt::xview_semantic< D >
+template<class E>
derived_type & assign_xexpression (const xexpression< E > &e)
 
+template<class E>
derived_type & computed_assign (const xexpression< E > &e)
 
+template<class E, class F>
derived_type & scalar_computed_assign (const E &e, F &&f)
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
template<class E>
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
template<class E>
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
template<class E, class F>
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
template<class E>
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< D >
+template<class E>
disable_xexpression< E, derived_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator^= (const E &)
 
+template<class E>
derived_type & operator+= (const xexpression< E > &)
 
+template<class E>
derived_type & operator-= (const xexpression< E > &)
 
+template<class E>
derived_type & operator*= (const xexpression< E > &)
 
+template<class E>
derived_type & operator/= (const xexpression< E > &)
 
+template<class E>
derived_type & operator%= (const xexpression< E > &)
 
+template<class E>
derived_type & operator&= (const xexpression< E > &)
 
+template<class E>
derived_type & operator|= (const xexpression< E > &)
 
+template<class E>
derived_type & operator^= (const xexpression< E > &)
 
+template<class E>
derived_type & assign (const xexpression< E > &)
 
+template<class E>
derived_type & plus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & minus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & multiplies_assign (const xexpression< E > &)
 
+template<class E>
derived_type & divides_assign (const xexpression< E > &)
 
+template<class E>
derived_type & modulus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_and_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_or_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_xor_assign (const xexpression< E > &)
 
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
template<class E>
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
template<class E>
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
template<class E>
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
template<class E>
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
template<class E>
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + +

+Static Public Attributes

static constexpr bool provides_simd_interface
 
static constexpr bool is_const
 
static constexpr bool contiguous_layout
 
static constexpr layout_type static_layout
 
+ + + + + + + + + + + + + + + + +

+Friends

template<class C>
class xstepper
 
class xview_semantic< self_type >
 
class xaccessible< self_type >
 
class xconst_accessible< self_type >
 
template<class D>
class xaxis_iterator
 
template<class D>
class xaxis_slice_iterator
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Data

template<class T>
void fill (const T &value)
 Fills the view with the given value.
 
linear_iterator linear_begin ()
 
linear_iterator linear_end ()
 
const_linear_iterator linear_begin () const
 
const_linear_iterator linear_end () const
 
const_linear_iterator linear_cbegin () const
 
const_linear_iterator linear_cend () const
 
reverse_linear_iterator linear_rbegin ()
 
reverse_linear_iterator linear_rend ()
 
const_reverse_linear_iterator linear_rbegin () const
 
const_reverse_linear_iterator linear_rend () const
 
const_reverse_linear_iterator linear_crbegin () const
 
const_reverse_linear_iterator linear_crend () const
 
template<class align, class simd>
+requires provides_simd_interface
void store_simd (size_type i, const simd &e)
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 
const_reference flat (size_type i) const
 
template<class ST, class STEP>
auto stepper_begin (const ST &shape) -> disable_indexed_stepper_t< STEP >
 
template<class ST, class STEP>
auto stepper_end (const ST &shape, layout_type l) -> disable_indexed_stepper_t< STEP >
 
template<class ST, class STEP>
auto stepper_begin (const ST &shape) const -> disable_indexed_stepper_t< STEP >
 
template<class ST, class STEP>
auto stepper_end (const ST &shape, layout_type l) const -> disable_indexed_stepper_t< STEP >
 
template<class alignment, class requested_type, std::size_t N>
+requires provides_simd_interface
auto load_simd (size_type i) const -> simd_return_type< requested_type >
 
template<class E>
auto build_view (E &&e) const -> rebind_t< E >
 
+ + + + + + + + +

Extended copy semantic

template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type > &
 
+ + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xview_semantic< D >
+ xview_semantic (const xview_semantic &)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< D >
+ xsemantic_base (const xsemantic_base &)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+class xt::xstrided_view< CT, S, L, FST >

View of an xexpression using strides.

+

The xstrided_view class implements a view utilizing an initial offset and strides.

+
Template Parameters
+ + + + + +
CTthe closure type of the xexpression type underlying this view
Lthe layout of the strided view
Sthe strides type of the strided view
FSTthe flat storage type used for the strided view
+
+
+
See also
strided_view, transpose
+ +

Definition at line 128 of file xstrided_view.hpp.

+

Member Typedef Documentation

+ +

◆ backstrides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 166 of file xstrided_view.hpp.

+ +
+
+ +

◆ base_index_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::base_index_type = xindex_type_t<shape_type>
+
+ +

Definition at line 175 of file xstrided_view.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::base_type = xstrided_view_base<self_type>
+
+ +

Definition at line 137 of file xstrided_view.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::bool_load_type = typename base_type::bool_load_type
+
+ +

Definition at line 180 of file xstrided_view.hpp.

+ +
+
+ +

◆ const_container_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::const_container_iterator = typename storage_type::const_iterator
+
+ +

Definition at line 275 of file xstrided_view.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::const_linear_iterator = typename storage_type::const_iterator
+
+ +

Definition at line 156 of file xstrided_view.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 149 of file xstrided_view.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 147 of file xstrided_view.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>
+
+ +

Definition at line 158 of file xstrided_view.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 169 of file xstrided_view.hpp.

+ +
+
+ +

◆ container_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::container_iterator
+
+Initial value:
std::
+
conditional_t<is_const, typename storage_type::const_iterator, typename storage_type::iterator>
+
+

Definition at line 273 of file xstrided_view.hpp.

+ +
+
+ +

◆ data_alignment

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::data_alignment = xt_simd::container_alignment_t<storage_type>
+
+ +

Definition at line 177 of file xstrided_view.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::difference_type = typename base_type::difference_type
+
+ +

Definition at line 151 of file xstrided_view.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 140 of file xstrided_view.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::extension_base = extension::xstrided_view_base_t<CT, S, L, FST>
+
+ +

Definition at line 139 of file xstrided_view.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::inner_backstrides_type = typename base_type::inner_backstrides_type
+
+ +

Definition at line 163 of file xstrided_view.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::inner_shape_type = typename base_type::inner_shape_type
+
+ +

Definition at line 161 of file xstrided_view.hpp.

+ +
+
+ +

◆ inner_storage_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::inner_storage_type = typename base_type::inner_storage_type
+
+ +

Definition at line 153 of file xstrided_view.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::inner_strides_type = typename base_type::inner_strides_type
+
+ +

Definition at line 162 of file xstrided_view.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::iterable_base = select_iterable_base_t<L, xexpression_type::static_layout, self_type>
+
+ +

Definition at line 160 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::linear_iterator = typename storage_type::iterator
+
+ +

Definition at line 155 of file xstrided_view.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::pointer = typename base_type::pointer
+
+ +

Definition at line 148 of file xstrided_view.hpp.

+ +
+
+ +

◆ rebind_t

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::rebind_t = xstrided_view<E, S, L, typename FST::template rebind_t<E>>
+
+ +

Definition at line 278 of file xstrided_view.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::reference = typename base_type::reference
+
+ +

Definition at line 146 of file xstrided_view.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::reverse_linear_iterator = std::reverse_iterator<linear_iterator>
+
+ +

Definition at line 157 of file xstrided_view.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::self_type = xstrided_view<CT, S, L, FST>
+
+ +

Definition at line 136 of file xstrided_view.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::semantic_base = xview_semantic<self_type>
+
+ +

Definition at line 138 of file xstrided_view.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 164 of file xstrided_view.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class requested_type>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 257 of file xstrided_view.hpp.

+ +
+
+ +

◆ simd_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::simd_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 178 of file xstrided_view.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 179 of file xstrided_view.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::size_type = typename base_type::size_type
+
+ +

Definition at line 150 of file xstrided_view.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 168 of file xstrided_view.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 154 of file xstrided_view.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 165 of file xstrided_view.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
+
+ +

Definition at line 174 of file xstrided_view.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::value_type = typename base_type::value_type
+
+ +

Definition at line 145 of file xstrided_view.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + +
using xt::xstrided_view< CT, S, L, FST >::xexpression_type = typename base_type::xexpression_type
+
+ +

Definition at line 142 of file xstrided_view.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xstrided_view()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class CTA, class SA>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
xt::xstrided_view< CT, S, L, FST >::xstrided_view (CTA && e,
SA && shape,
strides_type && strides,
std::size_t offset,
layout_type layout )
+ 		+inlinenoexcept
+
+ +

Constructs an xstrided_view.

+
Parameters
+ + + + + + +
ethe underlying xexpression for this view
shapethe shape of the view
stridesthe strides of the view
offsetthe offset of the first element in the underlying container
layoutthe layout of the view
+
+
+ +

Definition at line 368 of file xstrided_view.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ broadcast_shape()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + + + + + + + +
bool xt::xstrided_view_base< self_type >::broadcast_shape (O & shape,
bool reuse_cache = false ) const
+
+ +

Broadcast the shape of the view to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +
+
+ +

◆ build_view()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::build_view (E && e) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 692 of file xstrided_view.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + + + + +
const_pointer xt::xstrided_view_base< self_type >::data () const
+ 		+noexcept
+
+ +

Returns a constant pointer to the underlying array serving as element storage.

+

The first element of the view is at data() + data_offset().

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + + + + +
pointer xt::xstrided_view_base< self_type >::data ()
+ 		+noexcept
+
+ +

Returns a pointer to the underlying array serving as element storage.

+

The first element of the view is at data() + data_offset().

+ +
+
+ +

◆ data_element() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::data_element (size_type i)
+ 		+inline
+
+ +

Definition at line 462 of file xstrided_view.hpp.

+ +
+
+ +

◆ data_element() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::data_element (size_type i) const
+ 		+inline
+
+ +

Definition at line 468 of file xstrided_view.hpp.

+ +
+
+ +

◆ fill()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xstrided_view< CT, S, L, FST >::fill (const T & value)
+ 		+inline
+
+ +

Fills the view with the given value.

+
Parameters
+ + +
valuethe value to fill the view with.
+
+
+ +

Definition at line 447 of file xstrided_view.hpp.

+ +
+
+ +

◆ flat() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::flat (size_type i)
+ 		+inline
+
+ +

Definition at line 474 of file xstrided_view.hpp.

+ +
+
+ +

◆ flat() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::flat (size_type i) const
+ 		+inline
+
+ +

Definition at line 480 of file xstrided_view.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + + + + +
bool xt::xstrided_view_base< self_type >::has_linear_assign (const O & strides) const
+ 		+noexcept
+
+ +

Checks whether the xstrided_view_base can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +
+
+ +

◆ linear_begin() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_begin ()
+ 		+inline
+
+ +

Definition at line 486 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_begin() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_begin () const
+ 		+inline
+
+ +

Definition at line 498 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_cbegin () const
+ 		+inline
+
+ +

Definition at line 510 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_cend () const
+ 		+inline
+
+ +

Definition at line 516 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_crbegin () const
+ 		+inline
+
+ +

Definition at line 546 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_crend () const
+ 		+inline
+
+ +

Definition at line 552 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_end() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_end ()
+ 		+inline
+
+ +

Definition at line 492 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_end() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_end () const
+ 		+inline
+
+ +

Definition at line 504 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_rbegin() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_rbegin ()
+ 		+inline
+
+ +

Definition at line 522 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_rbegin() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_rbegin () const
+ 		+inline
+
+ +

Definition at line 534 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_rend() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_rend ()
+ 		+inline
+
+ +

Definition at line 528 of file xstrided_view.hpp.

+ +
+
+ +

◆ linear_rend() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::linear_rend () const
+ 		+inline
+
+ +

Definition at line 540 of file xstrided_view.hpp.

+ +
+
+ +

◆ load_simd()

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class alignment, class requested_type, std::size_t N>
+requires provides_simd_interface
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::load_simd (size_type i) const -> simd_return_type<requested_type> +
+ 		+inline
+
+ +

Definition at line 683 of file xstrided_view.hpp.

+ +
+
+ +

◆ operator=() [1/3]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::operator= (const E & e) -> disable_xexpression<E, self_type>& +
+ 		+inline
+
+ +

Definition at line 406 of file xstrided_view.hpp.

+ +
+
+ +

◆ operator=() [2/3]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::operator= (const self_type & rhs)
+ 		+inline
+
+ +

Definition at line 382 of file xstrided_view.hpp.

+ +
+
+ +

◆ operator=() [3/3]

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 397 of file xstrided_view.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class ST, class STEP>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::stepper_begin (const ST & shape) -> disable_indexed_stepper_t<STEP> +
+ 		+inline
+
+ +

Definition at line 563 of file xstrided_view.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class ST, class STEP>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::stepper_begin (const ST & shape) const -> disable_indexed_stepper_t<STEP> +
+ 		+inline
+
+ +

Definition at line 597 of file xstrided_view.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class ST, class STEP>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::stepper_end (const ST & shape,
layout_type l ) -> disable_indexed_stepper_t<STEP> +
+ 		+inline
+
+ +

Definition at line 571 of file xstrided_view.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+
+template<class ST, class STEP>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xstrided_view< CT, S, L, FST >::stepper_end (const ST & shape,
layout_type l ) const -> disable_indexed_stepper_t<STEP> +
+ 		+inline
+
+ +

Definition at line 606 of file xstrided_view.hpp.

+ +
+
+ +

◆ store_simd()

+ +
+
+
+template<class CT, class S, layout_type L, class FST>
+requires provides_simd_interface
+
+template<class alignment, class simd>
+requires provides_simd_interface
+ + + + + +
+ + + + + + + + + + + +
void xt::xstrided_view< CT, S, L, FST >::store_simd (size_type i,
const simd & e )
+ 		+inline
+
+ +

Definition at line 674 of file xstrided_view.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xaccessible< self_type >

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
friend class xaccessible< self_type >
+ 		+friend
+
+ +

Definition at line 301 of file xstrided_view.hpp.

+ +
+
+ +

◆ xaxis_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class D>
+ + + + + +
+ + + + +
friend class xaxis_iterator
+ 		+friend
+
+ +

Definition at line 306 of file xstrided_view.hpp.

+ +
+
+ +

◆ xaxis_slice_iterator

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class D>
+ + + + + +
+ + + + +
friend class xaxis_slice_iterator
+ 		+friend
+
+ +

Definition at line 308 of file xstrided_view.hpp.

+ +
+
+ +

◆ xconst_accessible< self_type >

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
friend class xconst_accessible< self_type >
+ 		+friend
+
+ +

Definition at line 301 of file xstrided_view.hpp.

+ +
+
+ +

◆ xstepper

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+
+template<class C>
+ + + + + +
+ + + + +
friend class xstepper
+ 		+friend
+
+ +

Definition at line 301 of file xstrided_view.hpp.

+ +
+
+ +

◆ xview_semantic< self_type >

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
friend class xview_semantic< self_type >
+ 		+friend
+
+ +

Definition at line 301 of file xstrided_view.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
bool xt::xstrided_view_base< self_type >::contiguous_layout
+ 		+staticconstexpr
+
+ +

Definition at line 133 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ is_const

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
bool xt::xstrided_view_base< self_type >::is_const
+ 		+staticconstexpr
+
+ +

Definition at line 104 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ provides_simd_interface

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
bool xt::xstrided_view< CT, S, L, FST >::provides_simd_interface
+ 		+staticconstexpr
+
+Initial value:
= has_simd_interface<xexpression_type>::value
+
&& L != layout_type::dynamic
+ +
xt::has_simd_interface
Definition xtensor_simd.hpp:269
+
+

Definition at line 182 of file xstrided_view.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, ::xt::layout_type::row_major >>
+ + + + + +
+ + + + +
layout_type xt::xstrided_view_base< self_type >::static_layout
+ 		+staticconstexpr
+
+ +

Definition at line 132 of file xstrided_view_base.hpp.

+ +
+
+
The documentation for this class was generated from the following files:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/io/xmime.hpp
    • +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xstrided_view.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xstrided__view.js b/classxt_1_1xstrided__view.js new file mode 100644 index 000000000..2b57851da --- /dev/null +++ b/classxt_1_1xstrided__view.js @@ -0,0 +1,19 @@ +var classxt_1_1xstrided__view = +[ + [ "xstrided_view", "classxt_1_1xstrided__view.html#aeaca42937cad665d96b797421f114cca", null ], + [ "backstrides", "classxt_1_1xstrided__view.html#a418d8680d4b654413456e4380c2151eb", null ], + [ "broadcast_shape", "classxt_1_1xstrided__view.html#a0f7c1e14391c357570e1d054b19b6165", null ], + [ "data", "classxt_1_1xstrided__view.html#aeed1c4b45db8fc518d5058ea39587e9f", null ], + [ "data", "classxt_1_1xstrided__view.html#a90ad7ad05c7837e0c26fdaa7cbe126c1", null ], + [ "data_offset", "classxt_1_1xstrided__view.html#a52931ad61f35e598829290a885805e26", null ], + [ "expression", "classxt_1_1xstrided__view.html#a929958921ea6477ce8a3c5aba3936146", null ], + [ "expression", "classxt_1_1xstrided__view.html#a0ab07e56a411fedb9e0e213b8ddbc693", null ], + [ "fill", "classxt_1_1xstrided__view.html#a2e8596cc0e323e5d8e884c5f88b00b8b", null ], + [ "has_linear_assign", "classxt_1_1xstrided__view.html#af8980bbe46da6333d9d81411bd9b6610", null ], + [ "layout", "classxt_1_1xstrided__view.html#ae3ff4c9cf2e6873fbc934e946f1b702b", null ], + [ "operator=", "classxt_1_1xstrided__view.html#a48ae99185454667efcd738a48ddc43bf", null ], + [ "shape", "classxt_1_1xstrided__view.html#a63efb4c728be80dc8154df1b578c33cd", null ], + [ "storage", "classxt_1_1xstrided__view.html#a12ee07f7bf30d89f9ea691a03a122e3d", null ], + [ "storage", "classxt_1_1xstrided__view.html#a515e8cbd36c5494ab188f4c3e9d90861", null ], + [ "strides", "classxt_1_1xstrided__view.html#aec137e8210e4a11efc962df4e05b0680", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xstrided__view.png b/classxt_1_1xstrided__view.png new file mode 100644 index 000000000..d5adfec51 Binary files /dev/null and b/classxt_1_1xstrided__view.png differ diff --git a/classxt_1_1xstrided__view__base-members.html b/classxt_1_1xstrided__view__base-members.html new file mode 100644 index 000000000..b537966d5 --- /dev/null +++ b/classxt_1_1xstrided__view__base-members.html @@ -0,0 +1,221 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xstrided_view_base< D > Member List
+
+
+ +

This is the complete list of members for xt::xstrided_view_base< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
at(Args... args) (defined in xt::xaccessible< D >)xt::xaccessible< D >
at(Args... args) -> referencext::xaccessible< D >inline
at(Args... args) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
back()xt::xaccessible< D >inline
back() constxt::xaccessible< D >inline
backstrides() const noexceptxt::xstrided_view_base< D >inline
backstrides_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
base_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
bool_load_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
broadcast_shape(O &shape, bool reuse_cache=false) constxt::xstrided_view_base< D >inline
compute_element_index(It first, It last) const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >protected
compute_element_index(It first, It last) const -> offset_type (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
compute_index(Args... args) const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >protected
compute_index(Args... args) const -> offset_type (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
compute_unchecked_index(Args... args) const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >protected
compute_unchecked_index(Args... args) const -> offset_type (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
const_pointer typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
const_reference typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
contiguous_layout (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >static
data() noexceptxt::xstrided_view_base< D >inline
data() const noexceptxt::xstrided_view_base< D >inline
data_offset() const noexceptxt::xstrided_view_base< D >inline
derived_type typedef (defined in xt::xaccessible< D >)xt::xaccessible< D >
difference_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
dimension() const noexceptxt::xconst_accessible< D >inline
element(It first, It last) (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
element(It first, It last) const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
element(It first, It last) -> referencext::xstrided_view_base< D >inline
element(It first, It last) const -> const_referencext::xstrided_view_base< D >inline
expression() noexceptxt::xstrided_view_base< D >inline
expression() const noexceptxt::xstrided_view_base< D >inline
front()xt::xaccessible< D >inline
front() constxt::xaccessible< D >inline
has_linear_assign(const O &strides) const noexceptxt::xstrided_view_base< D >inline
in_bounds(Args... args) constxt::xconst_accessible< D >inline
inner_backstrides_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
inner_shape_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
inner_storage_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
inner_strides_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
inner_types typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
is_const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >static
is_contiguous() const noexcept (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
layout() const noexceptxt::xstrided_view_base< D >inline
offset_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >protected
operator()() (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
operator()() const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
operator()(Args... args) (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
operator()(Args... args) const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
operator()(Args... args) -> referencext::xstrided_view_base< D >inline
operator()(Args... args) const -> const_referencext::xstrided_view_base< D >inline
operator=(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
operator=(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
operator=(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator=(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
operator[](const S &index) (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](std::initializer_list< I > index) (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](size_type i) (defined in xt::xaccessible< D >)xt::xaccessible< D >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< D >inline
operator[](std::initializer_list< I > index) -> reference (defined in xt::xaccessible< D >)xt::xaccessible< D >inline
operator[](const S &index) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](std::initializer_list< I > index) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
operator[](size_type i) const (defined in xt::xaccessible< D >)xt::xaccessible< D >inline
periodic(Args... args) (defined in xt::xaccessible< D >)xt::xaccessible< D >
periodic(Args... args) -> referencext::xaccessible< D >inline
periodic(Args... args) const (defined in xt::xaccessible< D >)xt::xaccessible< D >
pointer typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
provides_data_interface (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >static
reference typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
set_offset(size_type offset) (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >protected
shape() const noexceptxt::xstrided_view_base< D >inline
xt::xaccessible::shape(size_type index) constxt::xconst_accessible< D >inline
shape_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
simd_value_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
size() const noexcept(noexcept(derived_cast().shape()))xt::xconst_accessible< D >inline
size_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
static_layout (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >static
storage() noexceptxt::xstrided_view_base< D >inline
storage() const noexceptxt::xstrided_view_base< D >inline
storage_getter typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
storage_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
strides() const noexceptxt::xstrided_view_base< D >inline
strides_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
unchecked(Args... args) (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
unchecked(Args... args) const (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
unchecked(Args... args) -> referencext::xstrided_view_base< D >inline
unchecked(Args... args) const -> const_referencext::xstrided_view_base< D >inline
undecay_expression typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
undecay_shape typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
value_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
xaccessible()=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
xaccessible(const xaccessible &)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
xaccessible(xaccessible &&)=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
xconst_accessible()=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
xconst_accessible(const xconst_accessible &)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
xconst_accessible(xconst_accessible &&)=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
xexpression_type typedef (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >
xstrided_view_base(CTA &&e, SA &&shape, strides_type &&strides, size_type offset, layout_type layout) noexceptxt::xstrided_view_base< D >inline
xstrided_view_base(xstrided_view_base &&rhs) (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
xstrided_view_base(const xstrided_view_base &rhs) (defined in xt::xstrided_view_base< D >)xt::xstrided_view_base< D >inline
~xaccessible()=default (defined in xt::xaccessible< D >)xt::xaccessible< D >protected
~xconst_accessible()=default (defined in xt::xconst_accessible< D >)xt::xconst_accessible< D >protected
+
+ + + + diff --git a/classxt_1_1xstrided__view__base.html b/classxt_1_1xstrided__view__base.html new file mode 100644 index 000000000..89b7fb437 --- /dev/null +++ b/classxt_1_1xstrided__view__base.html @@ -0,0 +1,2101 @@ + + + + + + + +xtensor: xt::xstrided_view_base< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Protected Types | +Protected Member Functions | +List of all members
+
xt::xstrided_view_base< D > Class Template Reference
+
+
+
+Inheritance diagram for xt::xstrided_view_base< D >:
+
+
+ + +xt::xaccessible< D > +xt::xconst_accessible< D > +xt::xdynamic_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xdynamic_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xdynamic_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xdynamic_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xdynamic_view< CT, S, L, FST > +xt::xdynamic_view< E, S, L, typename FST::template rebind_t< E > > +xt::xstrided_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xstrided_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xstrided_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xstrided_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xstrided_view< CT, shape_type > +xt::xstrided_view< CT, S, L, FST > +xt::xstrided_view< E, S, L, typename FST::template rebind_t< E > > +xt::xdynamic_view< CT, S, L, FST > +xt::xstrided_view< CT, S, L, FST > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using base_type = xaccessible<D>
 
using inner_types = xcontainer_inner_types<D>
 
using xexpression_type = typename inner_types::xexpression_type
 
using undecay_expression = typename inner_types::undecay_expression
 
using value_type = typename xexpression_type::value_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer
 
using const_pointer = typename xexpression_type::const_pointer
 
using size_type = typename inner_types::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using storage_getter = typename inner_types::storage_getter
 
using inner_storage_type = typename inner_types::inner_storage_type
 
using storage_type = std::remove_reference_t<inner_storage_type>
 
using shape_type = typename inner_types::shape_type
 
using strides_type = get_strides_t<shape_type>
 
using backstrides_type = strides_type
 
using inner_shape_type = shape_type
 
using inner_strides_type = strides_type
 
using inner_backstrides_type = backstrides_type
 
using undecay_shape = typename inner_types::undecay_shape
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = typename xexpression_type::bool_load_type
 
- Public Types inherited from xt::xaccessible< D >
using base_type = xconst_accessible<D>
 
using derived_type = typename base_type::derived_type
 
using reference = typename base_type::reference
 
using size_type = typename base_type::size_type
 
- Public Types inherited from xt::xconst_accessible< D >
using derived_type = D
 
using inner_types = xcontainer_inner_types<D>
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using size_type = typename inner_types::size_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
reference element (It first, It last)
 
+template<class It>
const_reference element (It first, It last) const
 
Constructor
template<class CTA, class SA>
 xstrided_view_base (CTA &&e, SA &&shape, strides_type &&strides, size_type offset, layout_type layout) noexcept
 Constructs an xstrided_view_base.
 
 xstrided_view_base (xstrided_view_base &&rhs)
 
 xstrided_view_base (const xstrided_view_base &rhs)
 
Size and shape
const inner_shape_type & shape () const noexcept
 Returns the shape of the xtrided_view_base.
 
const inner_strides_type & strides () const noexcept
 Returns the strides of the xtrided_view_base.
 
const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the xtrided_view_base.
 
layout_type layout () const noexcept
 Returns the layout of the xtrided_view_base.
 
bool is_contiguous () const noexcept
 
Data
reference operator() ()
 
const_reference operator() () const
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the view.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the view.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
size_type data_offset () const noexcept
 Returns the offset to the first element in the view.
 
xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
const xexpression_type & expression () const noexcept
 Returns a constant reference to the underlying expression of the view.
 
template<class... Args>
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the view.
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the view.
 
template<class... Args>
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the view.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the view.
 
template<class It>
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the view.
 
template<class It>
auto element (It first, It last) const -> const_reference
 Returns a constant reference to the element at the specified position in the view.
 
- Public Member Functions inherited from xt::xaccessible< D >
+template<class... Args>
reference at (Args... args)
 
+template<class S>
disable_integral_t< S, reference > operator[] (const S &index)
 
+template<class I>
reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
+template<class... Args>
reference periodic (Args... args)
 
reference front ()
 Returns a reference to the first element of the expression.
 
reference back ()
 Returns a reference to the last element of the expression.
 
template<class... Args>
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
template<class S>
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
template<class I>
auto operator[] (std::initializer_list< I > index) -> reference
 
template<class... Args>
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+template<class... Args>
const_reference at (Args... args) const
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class I>
const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+template<class... Args>
const_reference periodic (Args... args) const
 
- Public Member Functions inherited from xt::xconst_accessible< D >
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+template<class... Args>
const_reference at (Args... args) const
 
+template<class S>
disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+template<class I>
const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
+template<class... Args>
const_reference periodic (Args... args) const
 
template<class... Args>
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
template<class... Args>
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
template<class S>
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
template<class I>
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
template<class... Args>
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+ + + + + + + + + +

+Static Public Attributes

static constexpr bool is_const = std::is_const<std::remove_reference_t<undecay_expression>>::value
 
static constexpr layout_type static_layout = inner_types::layout
 
static constexpr bool contiguous_layout
 
static constexpr bool provides_data_interface = detail::provides_data_interface<xexpression_type, storage_type>::value
 
+ + + +

+Protected Types

using offset_type = typename strides_type::value_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

+template<class... Args>
offset_type compute_index (Args... args) const
 
+template<class... Args>
offset_type compute_unchecked_index (Args... args) const
 
+template<class It>
offset_type compute_element_index (It first, It last) const
 
- Protected Member Functions inherited from xt::xaccessible< D >
+ xaccessible (const xaccessible &)=default
 
+xaccessible & operator= (const xaccessible &)=default
 
+ xaccessible (xaccessible &&)=default
 
+xaccessible & operator= (xaccessible &&)=default
 
- Protected Member Functions inherited from xt::xconst_accessible< D >
+ xconst_accessible (const xconst_accessible &)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
+ + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class O>
bool broadcast_shape (O &shape, bool reuse_cache=false) const
 Broadcast the shape of the view to the specified parameter.
 
template<class O>
bool has_linear_assign (const O &strides) const noexcept
 Checks whether the xstrided_view_base can be linearly assigned to an expression with the specified strides.
 
template<class... Args>
auto compute_index (Args... args) const -> offset_type
 
template<class... Args>
auto compute_unchecked_index (Args... args) const -> offset_type
 
template<class It>
auto compute_element_index (It first, It last) const -> offset_type
 
void set_offset (size_type offset)
 
+

Detailed Description

+
template<class D>
+class xt::xstrided_view_base< D >
+

Definition at line 96 of file xstrided_view_base.hpp.

+

Member Typedef Documentation

+ +

◆ backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::backstrides_type = strides_type
+
+ +

Definition at line 121 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::base_type = xaccessible<D>
+
+ +

Definition at line 100 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::bool_load_type = typename xexpression_type::bool_load_type
+
+ +

Definition at line 130 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::const_pointer = typename xexpression_type::const_pointer
+
+ +

Definition at line 111 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 108 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 113 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::inner_backstrides_type = backstrides_type
+
+ +

Definition at line 125 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::inner_shape_type = shape_type
+
+ +

Definition at line 123 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ inner_storage_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::inner_storage_type = typename inner_types::inner_storage_type
+
+ +

Definition at line 116 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::inner_strides_type = strides_type
+
+ +

Definition at line 124 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::inner_types = xcontainer_inner_types<D>
+
+ +

Definition at line 101 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ offset_type

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
using xt::xstrided_view_base< D >::offset_type = typename strides_type::value_type
+ 		+protected
+
+ +

Definition at line 195 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::pointer
+
+Initial value:
std::
+
conditional_t<is_const, typename xexpression_type::const_pointer, typename xexpression_type::pointer>
+
+

Definition at line 109 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::reference = typename inner_types::reference
+
+ +

Definition at line 107 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::shape_type = typename inner_types::shape_type
+
+ +

Definition at line 119 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 129 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::size_type = typename inner_types::size_type
+
+ +

Definition at line 112 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ storage_getter

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::storage_getter = typename inner_types::storage_getter
+
+ +

Definition at line 115 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::storage_type = std::remove_reference_t<inner_storage_type>
+
+ +

Definition at line 117 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::strides_type = get_strides_t<shape_type>
+
+ +

Definition at line 120 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ undecay_expression

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::undecay_expression = typename inner_types::undecay_expression
+
+ +

Definition at line 103 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ undecay_shape

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::undecay_shape = typename inner_types::undecay_shape
+
+ +

Definition at line 127 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::value_type = typename xexpression_type::value_type
+
+ +

Definition at line 106 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xstrided_view_base< D >::xexpression_type = typename inner_types::xexpression_type
+
+ +

Definition at line 102 of file xstrided_view_base.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xstrided_view_base() [1/3]

+ +
+
+
+template<class D>
+
+template<class CTA, class SA>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
xt::xstrided_view_base< D >::xstrided_view_base (CTA && e,
SA && shape,
strides_type && strides,
size_type offset,
layout_type layout )
+ 		+inlinenoexcept
+
+ +

Constructs an xstrided_view_base.

+
Parameters
+ + + + + + +
ethe underlying xexpression for this view
shapethe shape of the view
stridesthe strides of the view
offsetthe offset of the first element in the underlying container
layoutthe layout of the view
+
+
+ +

Definition at line 317 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ xstrided_view_base() [2/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
xt::xstrided_view_base< D >::xstrided_view_base (xstrided_view_base< D > && rhs)
+ 		+inline
+
+ +

Definition at line 355 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ xstrided_view_base() [3/3]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
xt::xstrided_view_base< D >::xstrided_view_base (const xstrided_view_base< D > & rhs)
+ 		+inline
+
+ +

Definition at line 368 of file xstrided_view_base.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ backstrides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::backstrides () const
+ 		+inlinenoexcept
+
+ +

Returns the backstrides of the xtrided_view_base.

+ +

Definition at line 408 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class D>
+
+template<class O>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xstrided_view_base< D >::broadcast_shape (O & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the view to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 643 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ compute_element_index()

+ +
+
+
+template<class D>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xstrided_view_base< D >::compute_element_index (It first,
It last ) const -> offset_type +
+ 		+inline
+
+ +

Definition at line 681 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ compute_index()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::compute_index (Args... args) const -> offset_type +
+ 		+inline
+
+ +

Definition at line 665 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ compute_unchecked_index()

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::compute_unchecked_index (Args... args) const -> offset_type +
+ 		+inline
+
+ +

Definition at line 673 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class D>
+requires (provides_data_interface)
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::data () const
+ 		+inlinenoexcept
+
+ +

Returns a constant pointer to the underlying array serving as element storage.

+

The first element of the view is at data() + data_offset().

+ +

Definition at line 596 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class D>
+requires (provides_data_interface)
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::data ()
+ 		+inlinenoexcept
+
+ +

Returns a pointer to the underlying array serving as element storage.

+

The first element of the view is at data() + data_offset().

+ +

Definition at line 585 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ data_offset()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::data_offset () const
+ 		+inlinenoexcept
+
+ +

Returns the offset to the first element in the view.

+ +

Definition at line 606 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class D>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xstrided_view_base< D >::element (It first,
It last ) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the view.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the the number of dimensions of the view..
+
+
+ +

Definition at line 541 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class D>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xstrided_view_base< D >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the view.

+
Parameters
+ + + +
firstiterator starting the sequence of indices
lastiterator ending the sequence of indices The number of indices in the sequence should be equal to or greater than the the number of dimensions of the view..
+
+
+ +

Definition at line 556 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ expression() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::expression () const
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the underlying expression of the view.

+ +

Definition at line 624 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ expression() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::expression ()
+ 		+inlinenoexcept
+
+ +

Returns a reference to the underlying expression of the view.

+ +

Definition at line 615 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class D>
+
+template<class O>
+ + + + + +
+ + + + + + + +
bool xt::xstrided_view_base< D >::has_linear_assign (const O & str) const
+ 		+inlinenoexcept
+
+ +

Checks whether the xstrided_view_base can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 655 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
bool xt::xstrided_view_base< D >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 423 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::layout () const
+ 		+inlinenoexcept
+
+ +

Returns the layout of the xtrided_view_base.

+ +

Definition at line 417 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ operator()() [1/4]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::operator() ()
+ 		+inline
+
+ +

Definition at line 435 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ operator()() [2/4]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::operator() () const
+ 		+inline
+
+ +

Definition at line 441 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ operator()() [3/4]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::operator() (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the view.
+
+
+ +

Definition at line 454 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ operator()() [4/4]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the view.
+
+
+ +

Definition at line 470 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ set_offset()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
void xt::xstrided_view_base< D >::set_offset (size_type offset)
+ 		+protected
+
+ +

Definition at line 687 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the xtrided_view_base.

+ +

Definition at line 390 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ storage() [1/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::storage () const
+ 		+inlinenoexcept
+
+ +

Returns a constant reference to the buffer containing the elements of the view.

+ +

Definition at line 575 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ storage() [2/2]

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::storage ()
+ 		+inlinenoexcept
+
+ +

Returns a reference to the buffer containing the elements of the view.

+ +

Definition at line 566 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ strides()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::strides () const
+ 		+inlinenoexcept
+
+ +

Returns the strides of the xtrided_view_base.

+ +

Definition at line 399 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::unchecked (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the view, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 499 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class D>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xstrided_view_base< D >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the view, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.uncheked(0, 1);
+
+ +

Definition at line 526 of file xstrided_view_base.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
bool xt::xstrided_view_base< D >::contiguous_layout
+ 		+staticconstexpr
+
+Initial value:
= static_layout != layout_type::dynamic
+
&& xexpression_type::contiguous_layout
+ +
+

Definition at line 133 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ is_const

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
bool xt::xstrided_view_base< D >::is_const = std::is_const<std::remove_reference_t<undecay_expression>>::value
+ 		+staticconstexpr
+
+ +

Definition at line 104 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ provides_data_interface

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
bool xt::xstrided_view_base< D >::provides_data_interface = detail::provides_data_interface<xexpression_type, storage_type>::value
+ 		+staticconstexpr
+
+ +

Definition at line 137 of file xstrided_view_base.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class D>
+ + + + + +
+ + + + +
layout_type xt::xstrided_view_base< D >::static_layout = inner_types::layout
+ 		+staticconstexpr
+
+ +

Definition at line 132 of file xstrided_view_base.hpp.

+ +
+
+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/classxt_1_1xstrided__view__base.js b/classxt_1_1xstrided__view__base.js new file mode 100644 index 000000000..7f33a829e --- /dev/null +++ b/classxt_1_1xstrided__view__base.js @@ -0,0 +1,23 @@ +var classxt_1_1xstrided__view__base = +[ + [ "xstrided_view_base", "classxt_1_1xstrided__view__base.html#a395bfaa7afcaf17190eaccebd998e1c4", null ], + [ "backstrides", "classxt_1_1xstrided__view__base.html#a736dcfe2b1e0a157f89a7a4c6445edd9", null ], + [ "broadcast_shape", "classxt_1_1xstrided__view__base.html#a6a79ebace6f36cfb560248f093b7dfa2", null ], + [ "data", "classxt_1_1xstrided__view__base.html#a06823da680ffe172dee428c6245b249e", null ], + [ "data", "classxt_1_1xstrided__view__base.html#a6fe1b51b3991c9c94053d304feef646b", null ], + [ "data_offset", "classxt_1_1xstrided__view__base.html#ab4fb45717672e9ff1681c360d8199ed5", null ], + [ "element", "classxt_1_1xstrided__view__base.html#a76377f2b31c5086bd56c169f39ab8e6b", null ], + [ "element", "classxt_1_1xstrided__view__base.html#a0410b18c9448ceb36193b2b740d0419a", null ], + [ "expression", "classxt_1_1xstrided__view__base.html#a94e4948a88657428eb50b1a92c4c2a43", null ], + [ "expression", "classxt_1_1xstrided__view__base.html#af4ec4a5c434d543b6c664f4572c849d4", null ], + [ "has_linear_assign", "classxt_1_1xstrided__view__base.html#a5264e47f30486f83a313b654d3dd7199", null ], + [ "layout", "classxt_1_1xstrided__view__base.html#a10da93fc02c2c53dde8d9f171ce053a6", null ], + [ "operator()", "classxt_1_1xstrided__view__base.html#a567f05613c6dfb65b68289e994d09183", null ], + [ "operator()", "classxt_1_1xstrided__view__base.html#a986bbe34c4e1ffb0948b9d9a2238c7ce", null ], + [ "shape", "classxt_1_1xstrided__view__base.html#a7f03137aa8b79f042dd1eb5b769f5256", null ], + [ "storage", "classxt_1_1xstrided__view__base.html#a8b2e5b2c411cc06b834960f23dea39e7", null ], + [ "storage", "classxt_1_1xstrided__view__base.html#aeec822654cdb1a74d861e819b1c98730", null ], + [ "strides", "classxt_1_1xstrided__view__base.html#a60cc5bdc36e03dd0b339e89e16d4080c", null ], + [ "unchecked", "classxt_1_1xstrided__view__base.html#a4a944cdaddacef0710cc4e601d95a1c8", null ], + [ "unchecked", "classxt_1_1xstrided__view__base.html#a4ed93202e4e30f980c2967c00e6044c4", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xstrided__view__base.png b/classxt_1_1xstrided__view__base.png new file mode 100644 index 000000000..94245aae0 Binary files /dev/null and b/classxt_1_1xstrided__view__base.png differ diff --git a/classxt_1_1xtensor__adaptor-members.html b/classxt_1_1xtensor__adaptor-members.html new file mode 100644 index 000000000..130182e8d --- /dev/null +++ b/classxt_1_1xtensor__adaptor-members.html @@ -0,0 +1,282 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xtensor_adaptor< EC, N, L, Tag > Member List
+
+
+ +

This is the complete list of members for xt::xtensor_adaptor< EC, N, L, Tag >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xtensor_adaptor< EC, N, L, Tag > >inline
back()xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
back()xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
backstrides() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
backstrides_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
base_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
container_closure_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
data() noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
data() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
data_offset() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
dimension() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
expression_tag typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
extension_base typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
fill(const T &value)xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
flat(size_type i)xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
flat(size_type i) constxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
front()xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
front()xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
layout() const noexceptxt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator=(const xtensor_adaptor &) (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >inline
operator=(xtensor_adaptor &&) (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >inline
operator=(temporary_type &&) (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >inline
operator=(const xexpression< E > &e) (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
operator=(const xexpression< E > &e) -> self_type &xt::xtensor_adaptor< EC, N, L, Tag >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >inline
rank (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >static
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >inline
reset_buffer(P &&pointer, S &&size) (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >inline
reshape(S &&shape, layout_type layout=base_type::static_layout) &xt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > >inline
resize(S &&shape, bool force=false)xt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > >inline
resize(S &&shape, layout_type l)xt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > >inline
resize(S &&shape, const strides_type &strides)xt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > >inline
self_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
semantic_base typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
shape() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
shape_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
size() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
storage() noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
storage() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
storage_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
strides() const noexceptxt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
strides_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
temporary_type typedef (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
unchecked(Args... args) -> referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
unchecked(Args... args) -> referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xtensor_adaptor< EC, N, L, Tag > >inline
xcontainer< xtensor_adaptor< EC, N, L, Tag > > (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >friend
xtensor_adaptor(storage_type &&storage)xt::xtensor_adaptor< EC, N, L, Tag >inline
xtensor_adaptor(const storage_type &storage)xt::xtensor_adaptor< EC, N, L, Tag >inline
xtensor_adaptor(D &&storage, const shape_type &shape, layout_type l=L)xt::xtensor_adaptor< EC, N, L, Tag >inline
xtensor_adaptor(D &&storage, const shape_type &shape, const strides_type &strides)xt::xtensor_adaptor< EC, N, L, Tag >inline
xtensor_adaptor(const xtensor_adaptor &)=default (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
xtensor_adaptor(xtensor_adaptor &&)=default (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
~xtensor_adaptor()=default (defined in xt::xtensor_adaptor< EC, N, L, Tag >)xt::xtensor_adaptor< EC, N, L, Tag >
+
+ + + + diff --git a/classxt_1_1xtensor__adaptor.html b/classxt_1_1xtensor__adaptor.html new file mode 100644 index 000000000..88db2b595 --- /dev/null +++ b/classxt_1_1xtensor__adaptor.html @@ -0,0 +1,1816 @@ + + + + + + + +xtensor: xt::xtensor_adaptor< EC, N, L, Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xtensor_adaptor< EC, N, L, Tag > Class Template Reference
+
+
+ +

Dense multidimensional container adaptor with tensor semantics and fixed dimension. + More...

+ +

#include <xtensor.hpp>

+
+Inheritance diagram for xt::xtensor_adaptor< EC, N, L, Tag >:
+
+
+ + +xt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > > +xt::xcontainer_semantic< xtensor_adaptor< EC, N, L, Tag > > +xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > > +xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > > +xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > > +xt::xaccessible< xtensor_adaptor< EC, N, L, Tag > > +xt::xiterable< xtensor_adaptor< EC, N, L, Tag > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using container_closure_type = EC
 
using self_type = xtensor_adaptor<EC, N, L, Tag>
 
using base_type = xstrided_container<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using extension_base = extension::xtensor_adaptor_base_t<EC, N, L, Tag>
 
using storage_type = typename base_type::storage_type
 
using allocator_type = typename base_type::allocator_type
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using expression_tag = Tag
 
- Public Types inherited from xt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > >
using base_type
 
using storage_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using shape_type
 
using strides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
- Public Types inherited from xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
using derived_type
 
using inner_types
 
using storage_type
 
using allocator_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using accessible_base
 
using data_alignment
 
using simd_type
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using simd_return_type
 
using container_iterator
 
using const_container_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >
using derived_type
 
using inner_types
 
using iterable_base
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_traits
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using select_iterator_impl
 
using select_iterator
 
using select_const_iterator
 
using select_reverse_iterator
 
using select_const_reverse_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xtensor_adaptor< EC, N, L, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xtensor_adaptor (const xtensor_adaptor &)=default
 
+ xtensor_adaptor (xtensor_adaptor &&)=default
 
+template<class E>
xtensor_adaptor & operator= (const xexpression< E > &e)
 
Constructors
 xtensor_adaptor (storage_type &&storage)
 Constructs an xtensor_adaptor of the given stl-like container.
 
 xtensor_adaptor (const storage_type &storage)
 Constructs an xtensor_adaptor of the given stl-like container.
 
template<class D>
 xtensor_adaptor (D &&storage, const shape_type &shape, layout_type l=L)
 Constructs an xtensor_adaptor of the given stl-like container, with the specified shape and layout_type.
 
template<class D>
 xtensor_adaptor (D &&storage, const shape_type &shape, const strides_type &strides)
 Constructs an xtensor_adaptor of the given stl-like container, with the specified shape and strides.
 
xtensor_adaptor & operator= (const xtensor_adaptor &)
 
xtensor_adaptor & operator= (xtensor_adaptor &&)
 
xtensor_adaptor & operator= (temporary_type &&)
 
void resize (S &&shape, bool force=false)
 Resizes the container.
 
void resize (S &&shape, layout_type l)
 Resizes the container.
 
void resize (S &&shape, const strides_type &strides)
 Resizes the container.
 
auto & reshape (S &&shape, layout_type layout=base_type::static_layout) &
 Reshapes the container and keeps old elements.
 
auto & reshape (std::initializer_list< T > shape, layout_type layout=base_type::static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
- Public Member Functions inherited from xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
void fill (const T &value)
 Fills the container with the given value.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
void store_simd (size_type i, const simd &e)
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
- Public Member Functions inherited from xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >
+select_iterator< L > begin () noexcept
 
+select_const_iterator< L > begin () const noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+select_iterator< L > end () noexcept
 
+select_const_iterator< L > end () const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+select_const_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+select_const_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+select_reverse_iterator< L > rbegin () noexcept
 
+select_const_reverse_iterator< L > rbegin () const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+select_reverse_iterator< L > rend () noexcept
 
+select_const_reverse_iterator< L > rend () const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xtensor_adaptor< EC, N, L, Tag > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + + + +

+Static Public Attributes

static constexpr std::size_t rank = N
 
- Static Public Attributes inherited from xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< xtensor_adaptor< EC, N, L, Tag > >
static constexpr layout_type static_layout
 
+ + + +

+Friends

class xcontainer< xtensor_adaptor< EC, N, L, Tag > >
 
+ + + + + + + + +

Extended copy semantic

template<class P, class S>
void reset_buffer (P &&pointer, S &&size)
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xstrided_container< xtensor_adaptor< EC, N, L, Tag > >
+ xstrided_container (const xstrided_container &)=default
 
+ xstrided_container (xstrided_container &&)=default
 
+xstrided_container & operator= (const xstrided_container &)=default
 
+xstrided_container & operator= (xstrided_container &&)=default
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&) noexcept
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept
 
inner_shape_type & shape_impl () noexcept
 
const inner_shape_type & shape_impl () const noexcept
 
inner_strides_type & strides_impl () noexcept
 
const inner_strides_type & strides_impl () const noexcept
 
inner_backstrides_type & backstrides_impl () noexcept
 
const inner_backstrides_type & backstrides_impl () const noexcept
 
void reshape_impl (S &&shape, std::true_type, layout_type layout=base_type::static_layout)
 
void reshape_impl (S &&shape, std::false_type, layout_type layout=base_type::static_layout)
 
layout_type & mutable_layout () noexcept
 
- Protected Member Functions inherited from xt::xcontainer< xtensor_adaptor< EC, N, L, Tag > >
+ xcontainer (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xtensor_adaptor< EC, N, L, Tag > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xtensor_adaptor< EC, N, L, Tag > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class EC, std::size_t N, layout_type L, class Tag>
+class xt::xtensor_adaptor< EC, N, L, Tag >

Dense multidimensional container adaptor with tensor semantics and fixed dimension.

+

The xtensor_adaptor class implements a dense multidimensional container adaptor with tensor semantics and fixed dimension. It is used to provide a multidimensional container semantic and a tensor semantic to stl-like containers.

+
Template Parameters
+ + + + + +
ECThe closure for the container type to adapt.
NThe dimension of the adaptor.
LThe layout_type of the adaptor.
TagThe expression tag.
+
+
+
See also
xstrided_container, xcontainer
+ +

Definition at line 209 of file xtensor.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::allocator_type = typename base_type::allocator_type
+
+ +

Definition at line 222 of file xtensor.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 225 of file xtensor.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::base_type = xstrided_container<self_type>
+
+ +

Definition at line 218 of file xtensor.hpp.

+ +
+
+ +

◆ container_closure_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::container_closure_type = EC
+
+ +

Definition at line 215 of file xtensor.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::expression_tag = Tag
+
+ +

Definition at line 227 of file xtensor.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::extension_base = extension::xtensor_adaptor_base_t<EC, N, L, Tag>
+
+ +

Definition at line 220 of file xtensor.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::self_type = xtensor_adaptor<EC, N, L, Tag>
+
+ +

Definition at line 217 of file xtensor.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 219 of file xtensor.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 223 of file xtensor.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 221 of file xtensor.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 224 of file xtensor.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_adaptor< EC, N, L, Tag >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 226 of file xtensor.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xtensor_adaptor() [1/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
xt::xtensor_adaptor< EC, N, L, Tag >::xtensor_adaptor (storage_type && storage)
+ 		+inline
+
+ +

Constructs an xtensor_adaptor of the given stl-like container.

+
Parameters
+ + +
storagethe container to adapt
+
+
+ +

Definition at line 612 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_adaptor() [2/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
xt::xtensor_adaptor< EC, N, L, Tag >::xtensor_adaptor (const storage_type & storage)
+ 		+inline
+
+ +

Constructs an xtensor_adaptor of the given stl-like container.

+
Parameters
+ + +
storagethe container to adapt
+
+
+ +

Definition at line 623 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_adaptor() [3/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xtensor_adaptor< EC, N, L, Tag >::xtensor_adaptor (D && storage,
const shape_type & shape,
layout_type l = L )
+ 		+inline
+
+ +

Constructs an xtensor_adaptor of the given stl-like container, with the specified shape and layout_type.

+
Parameters
+ + + + +
storagethe container to adapt
shapethe shape of the xtensor_adaptor
lthe layout_type of the xtensor_adaptor
+
+
+ +

Definition at line 638 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_adaptor() [4/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xtensor_adaptor< EC, N, L, Tag >::xtensor_adaptor (D && storage,
const shape_type & shape,
const strides_type & strides )
+ 		+inline
+
+ +

Constructs an xtensor_adaptor of the given stl-like container, with the specified shape and strides.

+
Parameters
+ + + + +
storagethe container to adapt
shapethe shape of the xtensor_adaptor
stridesthe strides of the xtensor_adaptor
+
+
+ +

Definition at line 654 of file xtensor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator=() [1/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_adaptor< EC, N, L, Tag >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 702 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [2/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_adaptor< EC, N, L, Tag >::operator= (const xtensor_adaptor< EC, N, L, Tag > & rhs)
+ 		+inline
+
+ +

Definition at line 668 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [3/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_adaptor< EC, N, L, Tag >::operator= (temporary_type && rhs)
+ 		+inline
+
+ +

Definition at line 684 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [4/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_adaptor< EC, N, L, Tag >::operator= (xtensor_adaptor< EC, N, L, Tag > && rhs)
+ 		+inline
+
+ +

Definition at line 676 of file xtensor.hpp.

+ +
+
+ +

◆ reset_buffer()

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class P, class S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xtensor_adaptor< EC, N, L, Tag >::reset_buffer (P && pointer,
S && size )
+ 		+inline
+
+ +

Definition at line 723 of file xtensor.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xcontainer< xtensor_adaptor< EC, N, L, Tag > >

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + +
friend class xcontainer< xtensor_adaptor< EC, N, L, Tag > >
+ 		+friend
+
+ +

Definition at line 259 of file xtensor.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ rank

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + +
std::size_t xt::xtensor_adaptor< EC, N, L, Tag >::rank = N
+ 		+staticconstexpr
+
+ +

Definition at line 228 of file xtensor.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xtensor.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xtensor__adaptor.js b/classxt_1_1xtensor__adaptor.js new file mode 100644 index 000000000..e74cc87de --- /dev/null +++ b/classxt_1_1xtensor__adaptor.js @@ -0,0 +1,8 @@ +var classxt_1_1xtensor__adaptor = +[ + [ "xtensor_adaptor", "classxt_1_1xtensor__adaptor.html#aecf238db1fe9fda0797db5c10ced651b", null ], + [ "xtensor_adaptor", "classxt_1_1xtensor__adaptor.html#ada04f10997a9bf3cb9d41ad0a57a071b", null ], + [ "xtensor_adaptor", "classxt_1_1xtensor__adaptor.html#a08d8af6b5afb2cf0fdd0fa05ac254066", null ], + [ "xtensor_adaptor", "classxt_1_1xtensor__adaptor.html#adf38d3f009485bbd13e05a33f3e126ed", null ], + [ "operator=", "classxt_1_1xtensor__adaptor.html#af034feb75cd6690b25a4c6b7b4a20bc5", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xtensor__adaptor.png b/classxt_1_1xtensor__adaptor.png new file mode 100644 index 000000000..056567cfb Binary files /dev/null and b/classxt_1_1xtensor__adaptor.png differ diff --git a/classxt_1_1xtensor__container-members.html b/classxt_1_1xtensor__container-members.html new file mode 100644 index 000000000..a721bf135 --- /dev/null +++ b/classxt_1_1xtensor__container-members.html @@ -0,0 +1,296 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xtensor_container< EC, N, L, Tag > Member List
+
+
+ +

This is the complete list of members for xt::xtensor_container< EC, N, L, Tag >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
assign_temporary(temporary_type &&)xt::xcontainer_semantic< xtensor_container< EC, N, L, Tag > >inline
back()xt::xcontainer< xtensor_container< EC, N, L, Tag > >
back()xt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
backstrides() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >
backstrides_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
base_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
const_pointer typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
const_reference typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
data() noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
data() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
data_offset() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
dimension() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
expression_tag typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
extension_base typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
fill(const T &value)xt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
flat(size_type i)xt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
flat(size_type i) constxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
from_shape(S &&s) (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >static
from_shape(S &&s) (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >inline
front()xt::xcontainer< xtensor_container< EC, N, L, Tag > >
front()xt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
inner_backstrides_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
inner_shape_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
inner_strides_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
layout() const noexceptxt::xstrided_container< xtensor_container< EC, N, L, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator=(const xtensor_container &)=default (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
operator=(xtensor_container &&)=default (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
operator=(xarray_container< EC, L, SC, Tag > &&) (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
operator=(const xexpression< E > &e) (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
operator=(xarray_container< EC, L, SC, Tag > &&rhs) (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >inline
operator=(const xexpression< E > &e) -> self_type &xt::xtensor_container< EC, N, L, Tag >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >inline
pointer typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
rank (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >static
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
reference typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >inline
reshape(S &&shape, layout_type layout=base_type::static_layout) &xt::xstrided_container< xtensor_container< EC, N, L, Tag > >inline
resize(S &&shape, bool force=false)xt::xstrided_container< xtensor_container< EC, N, L, Tag > >inline
resize(S &&shape, layout_type l)xt::xstrided_container< xtensor_container< EC, N, L, Tag > >inline
resize(S &&shape, const strides_type &strides)xt::xstrided_container< xtensor_container< EC, N, L, Tag > >inline
self_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
semantic_base typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
shape() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >
shape_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
size() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
storage() noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
storage() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >inline
storage_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
strides() const noexceptxt::xcontainer< xtensor_container< EC, N, L, Tag > >
strides_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
temporary_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
unchecked(Args... args) -> referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
unchecked(Args... args) -> referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xtensor_container< EC, N, L, Tag > >inline
value_type typedef (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
xcontainer< xtensor_container< EC, N, L, Tag > > (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >friend
xtensor_container()xt::xtensor_container< EC, N, L, Tag >inline
xtensor_container(nested_initializer_list_t< value_type, N > t)xt::xtensor_container< EC, N, L, Tag >inline
xtensor_container(const shape_type &shape, layout_type l=L)xt::xtensor_container< EC, N, L, Tag >inlineexplicit
xtensor_container(const shape_type &shape, const_reference value, layout_type l=L)xt::xtensor_container< EC, N, L, Tag >inlineexplicit
xtensor_container(const shape_type &shape, const strides_type &strides)xt::xtensor_container< EC, N, L, Tag >inlineexplicit
xtensor_container(const shape_type &shape, const strides_type &strides, const_reference value)xt::xtensor_container< EC, N, L, Tag >inlineexplicit
xtensor_container(storage_type &&storage, inner_shape_type &&shape, inner_strides_type &&strides)xt::xtensor_container< EC, N, L, Tag >inlineexplicit
xtensor_container(const xtensor_container &)=default (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
xtensor_container(xtensor_container &&)=default (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
xtensor_container(xarray_container< EC, L, SC, Tag > &&) (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >inlineexplicit
xtensor_container(const xexpression< E > &e)xt::xtensor_container< EC, N, L, Tag >inline
~xtensor_container()=default (defined in xt::xtensor_container< EC, N, L, Tag >)xt::xtensor_container< EC, N, L, Tag >
+
+ + + + diff --git a/classxt_1_1xtensor__container.html b/classxt_1_1xtensor__container.html new file mode 100644 index 000000000..639eb3bd8 --- /dev/null +++ b/classxt_1_1xtensor__container.html @@ -0,0 +1,2105 @@ + + + + + + + +xtensor: xt::xtensor_container< EC, N, L, Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xtensor_container< EC, N, L, Tag > Class Template Reference
+
+
+ +

Dense multidimensional container with tensor semantic and fixed dimension. + More...

+ +

#include <xtensor.hpp>

+
+Inheritance diagram for xt::xtensor_container< EC, N, L, Tag >:
+
+
+ + +xt::xstrided_container< xtensor_container< EC, N, L, Tag > > +xt::xcontainer_semantic< xtensor_container< EC, N, L, Tag > > +xt::xcontainer< xtensor_container< EC, N, L, Tag > > +xt::xsemantic_base< xtensor_container< EC, N, L, Tag > > +xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > > +xt::xaccessible< xtensor_container< EC, N, L, Tag > > +xt::xiterable< xtensor_container< EC, N, L, Tag > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xtensor_container<EC, N, L, Tag>
 
using base_type = xstrided_container<self_type>
 
using semantic_base = xcontainer_semantic<self_type>
 
using extension_base = extension::xtensor_container_base_t<EC, N, L, Tag>
 
using storage_type = typename base_type::storage_type
 
using allocator_type = typename base_type::allocator_type
 
using value_type = typename base_type::value_type
 
using reference = typename base_type::reference
 
using const_reference = typename base_type::const_reference
 
using pointer = typename base_type::pointer
 
using const_pointer = typename base_type::const_pointer
 
using shape_type = typename base_type::shape_type
 
using inner_shape_type = typename base_type::inner_shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using inner_backstrides_type = typename base_type::inner_backstrides_type
 
using inner_strides_type = typename base_type::inner_strides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using expression_tag = Tag
 
- Public Types inherited from xt::xstrided_container< xtensor_container< EC, N, L, Tag > >
using base_type
 
using storage_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using shape_type
 
using strides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
- Public Types inherited from xt::xcontainer< xtensor_container< EC, N, L, Tag > >
using derived_type
 
using inner_types
 
using storage_type
 
using allocator_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using accessible_base
 
using data_alignment
 
using simd_type
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using simd_return_type
 
using container_iterator
 
using const_container_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >
using derived_type
 
using inner_types
 
using iterable_base
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_traits
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using select_iterator_impl
 
using select_iterator
 
using select_const_iterator
 
using select_reverse_iterator
 
using select_const_reverse_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xcontainer_semantic< xtensor_container< EC, N, L, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xtensor_container (const xtensor_container &)=default
 
+xtensor_container & operator= (const xtensor_container &)=default
 
+ xtensor_container (xtensor_container &&)=default
 
+xtensor_container & operator= (xtensor_container &&)=default
 
+template<class SC>
xtensor_container & operator= (xarray_container< EC, L, SC, Tag > &&)
 
+template<class E>
xtensor_container & operator= (const xexpression< E > &e)
 
Constructors
 xtensor_container ()
 Allocates an uninitialized xtensor_container that holds 0 elements.
 
 xtensor_container (nested_initializer_list_t< value_type, N > t)
 Allocates an xtensor_container with nested initializer lists.
 
 xtensor_container (const shape_type &shape, layout_type l=L)
 Allocates an uninitialized xtensor_container with the specified shape and layout_type.
 
 xtensor_container (const shape_type &shape, const_reference value, layout_type l=L)
 Allocates an xtensor_container with the specified shape and layout_type.
 
 xtensor_container (const shape_type &shape, const strides_type &strides)
 Allocates an uninitialized xtensor_container with the specified shape and strides.
 
 xtensor_container (const shape_type &shape, const strides_type &strides, const_reference value)
 Allocates an uninitialized xtensor_container with the specified shape and strides.
 
 xtensor_container (storage_type &&storage, inner_shape_type &&shape, inner_strides_type &&strides)
 Allocates an xtensor_container by moving specified data, shape and strides.
 
template<class SC>
 xtensor_container (xarray_container< EC, L, SC, Tag > &&)
 
template<class SC>
xtensor_container< EC, N, L, Tag > & operator= (xarray_container< EC, L, SC, Tag > &&rhs)
 
template<class S>
xtensor_container< EC, N, L, Tag > from_shape (S &&s)
 
void resize (S &&shape, bool force=false)
 Resizes the container.
 
void resize (S &&shape, layout_type l)
 Resizes the container.
 
void resize (S &&shape, const strides_type &strides)
 Resizes the container.
 
auto & reshape (S &&shape, layout_type layout=base_type::static_layout) &
 Reshapes the container and keeps old elements.
 
auto & reshape (std::initializer_list< T > shape, layout_type layout=base_type::static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
- Public Member Functions inherited from xt::xcontainer< xtensor_container< EC, N, L, Tag > >
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
void fill (const T &value)
 Fills the container with the given value.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
void store_simd (size_type i, const simd &e)
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
- Public Member Functions inherited from xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >
+select_iterator< L > begin () noexcept
 
+select_const_iterator< L > begin () const noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+select_iterator< L > end () noexcept
 
+select_const_iterator< L > end () const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+select_const_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+select_const_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+select_reverse_iterator< L > rbegin () noexcept
 
+select_const_reverse_iterator< L > rbegin () const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+select_reverse_iterator< L > rend () noexcept
 
+select_const_reverse_iterator< L > rend () const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xcontainer_semantic< xtensor_container< EC, N, L, Tag > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + +

+Static Public Member Functions

+template<class S = shape_type>
static xtensor_container from_shape (S &&s)
 
+ + + + + + + + + + + +

+Static Public Attributes

static constexpr std::size_t rank = N
 
- Static Public Attributes inherited from xt::xcontainer< xtensor_container< EC, N, L, Tag > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< xtensor_container< EC, N, L, Tag > >
static constexpr layout_type static_layout
 
+ + + +

+Friends

class xcontainer< xtensor_container< EC, N, L, Tag > >
 
+ + + + + + + + + +

Extended copy semantic

template<class E>
 xtensor_container (const xexpression< E > &e)
 The extended copy constructor.
 
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xstrided_container< xtensor_container< EC, N, L, Tag > >
+ xstrided_container (const xstrided_container &)=default
 
+ xstrided_container (xstrided_container &&)=default
 
+xstrided_container & operator= (const xstrided_container &)=default
 
+xstrided_container & operator= (xstrided_container &&)=default
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&) noexcept
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept
 
inner_shape_type & shape_impl () noexcept
 
const inner_shape_type & shape_impl () const noexcept
 
inner_strides_type & strides_impl () noexcept
 
const inner_strides_type & strides_impl () const noexcept
 
inner_backstrides_type & backstrides_impl () noexcept
 
const inner_backstrides_type & backstrides_impl () const noexcept
 
void reshape_impl (S &&shape, std::true_type, layout_type layout=base_type::static_layout)
 
void reshape_impl (S &&shape, std::false_type, layout_type layout=base_type::static_layout)
 
layout_type & mutable_layout () noexcept
 
- Protected Member Functions inherited from xt::xcontainer< xtensor_container< EC, N, L, Tag > >
+ xcontainer (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
- Protected Member Functions inherited from xt::xcontainer_semantic< xtensor_container< EC, N, L, Tag > >
+ xcontainer_semantic (const xcontainer_semantic &)=default
 
+ xcontainer_semantic (xcontainer_semantic &&)=default
 
+xcontainer_semantic & operator= (const xcontainer_semantic &)=default
 
+xcontainer_semantic & operator= (xcontainer_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xtensor_container< EC, N, L, Tag > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class EC, std::size_t N, layout_type L, class Tag>
+class xt::xtensor_container< EC, N, L, Tag >

Dense multidimensional container with tensor semantic and fixed dimension.

+

The xtensor_container class implements a dense multidimensional container with tensor semantics and fixed dimension

+
Template Parameters
+ + + + + +
ECThe type of the container holding the elements.
NThe dimension of the container.
LThe layout_type of the tensor.
TagThe expression tag.
+
+
+
See also
xtensor, xstrided_container, xcontainer
+ +

Definition at line 83 of file xtensor.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::allocator_type = typename base_type::allocator_type
+
+ +

Definition at line 94 of file xtensor.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 103 of file xtensor.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::base_type = xstrided_container<self_type>
+
+ +

Definition at line 90 of file xtensor.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::const_pointer = typename base_type::const_pointer
+
+ +

Definition at line 99 of file xtensor.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::const_reference = typename base_type::const_reference
+
+ +

Definition at line 97 of file xtensor.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::expression_tag = Tag
+
+ +

Definition at line 107 of file xtensor.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::extension_base = extension::xtensor_container_base_t<EC, N, L, Tag>
+
+ +

Definition at line 92 of file xtensor.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::inner_backstrides_type = typename base_type::inner_backstrides_type
+
+ +

Definition at line 104 of file xtensor.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::inner_shape_type = typename base_type::inner_shape_type
+
+ +

Definition at line 101 of file xtensor.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::inner_strides_type = typename base_type::inner_strides_type
+
+ +

Definition at line 105 of file xtensor.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::pointer = typename base_type::pointer
+
+ +

Definition at line 98 of file xtensor.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::reference = typename base_type::reference
+
+ +

Definition at line 96 of file xtensor.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::self_type = xtensor_container<EC, N, L, Tag>
+
+ +

Definition at line 89 of file xtensor.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::semantic_base = xcontainer_semantic<self_type>
+
+ +

Definition at line 91 of file xtensor.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 100 of file xtensor.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 93 of file xtensor.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 102 of file xtensor.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 106 of file xtensor.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_container< EC, N, L, Tag >::value_type = typename base_type::value_type
+
+ +

Definition at line 95 of file xtensor.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xtensor_container() [1/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container ()
+ 		+inline
+
+ +

Allocates an uninitialized xtensor_container that holds 0 elements.

+ +

Definition at line 416 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [2/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (nested_initializer_list_t< value_type, N > t)
+ 		+inline
+
+ +

Allocates an xtensor_container with nested initializer lists.

+ +

Definition at line 426 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [3/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (const shape_type & shape,
layout_type l = L )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xtensor_container with the specified shape and layout_type.

+
Parameters
+ + + +
shapethe shape of the xtensor_container
lthe layout_type of the xtensor_container
+
+
+ +

Definition at line 441 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [4/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (const shape_type & shape,
const_reference value,
layout_type l = L )
+ 		+inlineexplicit
+
+ +

Allocates an xtensor_container with the specified shape and layout_type.

+

Elements are initialized to the specified value.

Parameters
+ + + + +
shapethe shape of the xtensor_container
valuethe value of the elements
lthe layout_type of the xtensor_container
+
+
+ +

Definition at line 455 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [5/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (const shape_type & shape,
const strides_type & strides )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xtensor_container with the specified shape and strides.

+
Parameters
+ + + +
shapethe shape of the xtensor_container
stridesthe strides of the xtensor_container
+
+
+ +

Definition at line 472 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [6/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (const shape_type & shape,
const strides_type & strides,
const_reference value )
+ 		+inlineexplicit
+
+ +

Allocates an uninitialized xtensor_container with the specified shape and strides.

+

Elements are initialized to the specified value.

Parameters
+ + + + +
shapethe shape of the xtensor_container
stridesthe strides of the xtensor_container
valuethe value of the elements
+
+
+ +

Definition at line 486 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [7/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (storage_type && storage,
inner_shape_type && shape,
inner_strides_type && strides )
+ 		+inlineexplicit
+
+ +

Allocates an xtensor_container by moving specified data, shape and strides.

+
Parameters
+ + + + +
storagethe data for the xtensor_container
shapethe shape of the xtensor_container
stridesthe strides of the xtensor_container
+
+
+ +

Definition at line 505 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [8/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class SC>
+ + + + + +
+ + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (xarray_container< EC, L, SC, Tag > && rhs)
+ 		+inlineexplicit
+
+ +

Definition at line 517 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_container() [9/9]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
xt::xtensor_container< EC, N, L, Tag >::xtensor_container (const xexpression< E > & e)
+ 		+inline
+
+ +

The extended copy constructor.

+ +

Definition at line 562 of file xtensor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ from_shape()

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class S>
+ + + + + +
+ + + + + + + +
xtensor_container< EC, N, L, Tag > xt::xtensor_container< EC, N, L, Tag >::from_shape (S && s)
+ 		+inline
+
+ +

Definition at line 544 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [1/2]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_container< EC, N, L, Tag >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 580 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [2/2]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class SC>
+ + + + + +
+ + + + + + + +
xtensor_container< EC, N, L, Tag > & xt::xtensor_container< EC, N, L, Tag >::operator= (xarray_container< EC, L, SC, Tag > && rhs)
+ 		+inline
+
+ +

Definition at line 531 of file xtensor.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xcontainer< xtensor_container< EC, N, L, Tag > >

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + +
friend class xcontainer< xtensor_container< EC, N, L, Tag > >
+ 		+friend
+
+ +

Definition at line 145 of file xtensor.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ rank

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + +
std::size_t xt::xtensor_container< EC, N, L, Tag >::rank = N
+ 		+staticconstexpr
+
+ +

Definition at line 108 of file xtensor.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xtensor.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xtensor__container.js b/classxt_1_1xtensor__container.js new file mode 100644 index 000000000..49399280c --- /dev/null +++ b/classxt_1_1xtensor__container.js @@ -0,0 +1,12 @@ +var classxt_1_1xtensor__container = +[ + [ "xtensor_container", "classxt_1_1xtensor__container.html#aa3a7016797e330568a8b4e5efb6f1c4b", null ], + [ "xtensor_container", "classxt_1_1xtensor__container.html#a5d15ba6d111b6a3aa8403f69d4810c21", null ], + [ "xtensor_container", "classxt_1_1xtensor__container.html#aed68730c6dae5a8155b2c67140a63368", null ], + [ "xtensor_container", "classxt_1_1xtensor__container.html#a56f009f40f5acb09f157345a1a174508", null ], + [ "xtensor_container", "classxt_1_1xtensor__container.html#a27c45be9ad2e0da1a8ad0576c756f39e", null ], + [ "xtensor_container", "classxt_1_1xtensor__container.html#ad411469d4cd09d58528f489dd380de9e", null ], + [ "xtensor_container", "classxt_1_1xtensor__container.html#ad82e5654ec5c9f23d5801aa5e84d4ddc", null ], + [ "xtensor_container", "classxt_1_1xtensor__container.html#a76f048f11c76d405e2e93007e74e2c41", null ], + [ "operator=", "classxt_1_1xtensor__container.html#a1b82b2aea047cca3d11106062721c34c", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xtensor__container.png b/classxt_1_1xtensor__container.png new file mode 100644 index 000000000..ba400ddca Binary files /dev/null and b/classxt_1_1xtensor__container.png differ diff --git a/classxt_1_1xtensor__view-members.html b/classxt_1_1xtensor__view-members.html new file mode 100644 index 000000000..ebd37a01d --- /dev/null +++ b/classxt_1_1xtensor__view-members.html @@ -0,0 +1,282 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xtensor_view< EC, N, L, Tag > Member List
+
+
+ +

This is the complete list of members for xt::xtensor_view< EC, N, L, Tag >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
allocator_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
assign_temporary(temporary_type &&)xt::xview_semantic< xtensor_view< EC, N, L, Tag > >inline
back()xt::xcontainer< xtensor_view< EC, N, L, Tag > >
back()xt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
backstrides() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >
backstrides_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
base_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
begin() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
begin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
begin(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
begin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
broadcast_shape(S &shape, bool reuse_cache=false) constxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
cbegin() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
cbegin(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
cend() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
cend(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
container_closure_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
crbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
crbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
crend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
crend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
data() noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
data() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
data_offset() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
dimension() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
element(It first, It last) -> referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
element(It first, It last) const -> const_referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
end() noexcept -> select_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
end() const noexcept -> select_const_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
end(const S &shape) noexcept -> broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
end(const S &shape) const noexcept -> const_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
expression_tag typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
extension_base typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
fill(const T &value)xt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
flat(size_type i)xt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
flat(size_type i) constxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
front()xt::xcontainer< xtensor_view< EC, N, L, Tag > >
front()xt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
has_linear_assign(const S &strides) const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
layout() const noexceptxt::xstrided_container< xtensor_view< EC, N, L, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
operator()(Args... args) -> referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
operator()(Args... args) const -> const_referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator=(const xtensor_view &) (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >inline
operator=(xtensor_view &&) (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >inline
operator=(const xexpression< E > &e) (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
operator=(const E &e) (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
operator=(const xexpression< E > &e) -> self_type &xt::xtensor_view< EC, N, L, Tag >inline
operator=(const E &e) -> disable_xexpression< E, self_type > & (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rbegin() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rbegin() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rbegin(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rbegin(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend() noexcept -> select_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend() const noexcept -> select_const_reverse_iterator< L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend(const S &shape) noexcept -> reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
rend(const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >inline
reshape(S &&shape, layout_type layout=base_type::static_layout) &xt::xstrided_container< xtensor_view< EC, N, L, Tag > >inline
resize(S &&shape, bool force=false)xt::xstrided_container< xtensor_view< EC, N, L, Tag > >inline
resize(S &&shape, layout_type l)xt::xstrided_container< xtensor_view< EC, N, L, Tag > >inline
resize(S &&shape, const strides_type &strides)xt::xstrided_container< xtensor_view< EC, N, L, Tag > >inline
self_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
semantic_base typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
shape() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >
shape_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
size() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
storage() noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
storage() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >inline
storage_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
strides() const noexceptxt::xcontainer< xtensor_view< EC, N, L, Tag > >
strides_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
temporary_type typedef (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
unchecked(Args... args) -> referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
unchecked(Args... args) -> referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
unchecked(Args... args) const -> const_referencext::xcontainer< xtensor_view< EC, N, L, Tag > >inline
xcontainer< xtensor_view< EC, N, L, Tag > > (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >friend
xtensor_view(storage_type &&storage)xt::xtensor_view< EC, N, L, Tag >inline
xtensor_view(const storage_type &storage)xt::xtensor_view< EC, N, L, Tag >inline
xtensor_view(D &&storage, const shape_type &shape, layout_type l=L)xt::xtensor_view< EC, N, L, Tag >inline
xtensor_view(D &&storage, const shape_type &shape, const strides_type &strides)xt::xtensor_view< EC, N, L, Tag >inline
xtensor_view(const xtensor_view &)=default (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
xtensor_view(xtensor_view &&)=default (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
xview_semantic< xtensor_view< EC, N, L, Tag > > (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >friend
~xtensor_view()=default (defined in xt::xtensor_view< EC, N, L, Tag >)xt::xtensor_view< EC, N, L, Tag >
+
+ + + + diff --git a/classxt_1_1xtensor__view.html b/classxt_1_1xtensor__view.html new file mode 100644 index 000000000..8d4c4bb77 --- /dev/null +++ b/classxt_1_1xtensor__view.html @@ -0,0 +1,1781 @@ + + + + + + + +xtensor: xt::xtensor_view< EC, N, L, Tag > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Friends | +List of all members
+
xt::xtensor_view< EC, N, L, Tag > Class Template Reference
+
+
+ +

Dense multidimensional container adaptor with view semantics and fixed dimension. + More...

+ +

#include <xtensor.hpp>

+
+Inheritance diagram for xt::xtensor_view< EC, N, L, Tag >:
+
+
+ + +xt::xstrided_container< xtensor_view< EC, N, L, Tag > > +xt::xview_semantic< xtensor_view< EC, N, L, Tag > > +xt::xcontainer< xtensor_view< EC, N, L, Tag > > +xt::xsemantic_base< xtensor_view< EC, N, L, Tag > > +xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > > +xt::xaccessible< xtensor_view< EC, N, L, Tag > > +xt::xiterable< xtensor_view< EC, N, L, Tag > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using container_closure_type = EC
 
using self_type = xtensor_view<EC, N, L, Tag>
 
using base_type = xstrided_container<self_type>
 
using semantic_base = xview_semantic<self_type>
 
using extension_base = extension::xtensor_adaptor_base_t<EC, N, L, Tag>
 
using storage_type = typename base_type::storage_type
 
using allocator_type = typename base_type::allocator_type
 
using shape_type = typename base_type::shape_type
 
using strides_type = typename base_type::strides_type
 
using backstrides_type = typename base_type::backstrides_type
 
using temporary_type = typename semantic_base::temporary_type
 
using expression_tag = Tag
 
- Public Types inherited from xt::xstrided_container< xtensor_view< EC, N, L, Tag > >
using base_type
 
using storage_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using shape_type
 
using strides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
- Public Types inherited from xt::xcontainer< xtensor_view< EC, N, L, Tag > >
using derived_type
 
using inner_types
 
using storage_type
 
using allocator_type
 
using value_type
 
using reference
 
using const_reference
 
using pointer
 
using const_pointer
 
using size_type
 
using difference_type
 
using simd_value_type
 
using bool_load_type
 
using shape_type
 
using strides_type
 
using backstrides_type
 
using inner_shape_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using iterable_base
 
using stepper
 
using const_stepper
 
using accessible_base
 
using data_alignment
 
using simd_type
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using simd_return_type
 
using container_iterator
 
using const_container_iterator
 
- Public Types inherited from xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >
using derived_type
 
using inner_types
 
using iterable_base
 
using stepper
 
using const_stepper
 
using layout_iterator
 
using const_layout_iterator
 
using reverse_layout_iterator
 
using const_reverse_layout_iterator
 
using broadcast_iterator
 
using const_broadcast_iterator
 
using reverse_broadcast_iterator
 
using const_reverse_broadcast_iterator
 
using linear_traits
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator
 
using const_reverse_linear_iterator
 
using select_iterator_impl
 
using select_iterator
 
using select_const_iterator
 
using select_reverse_iterator
 
using select_const_reverse_iterator
 
using iterator
 
using const_iterator
 
using reverse_iterator
 
using const_reverse_iterator
 
- Public Types inherited from xt::xview_semantic< xtensor_view< EC, N, L, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >
using base_type
 
using derived_type
 
using temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xtensor_view (const xtensor_view &)=default
 
+ xtensor_view (xtensor_view &&)=default
 
+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
Constructors
 xtensor_view (storage_type &&storage)
 Constructs an xtensor_view of the given stl-like container.
 
 xtensor_view (const storage_type &storage)
 Constructs an xtensor_view of the given stl-like container.
 
template<class D>
 xtensor_view (D &&storage, const shape_type &shape, layout_type l=L)
 Constructs an xtensor_view of the given stl-like container, with the specified shape and layout_type.
 
template<class D>
 xtensor_view (D &&storage, const shape_type &shape, const strides_type &strides)
 Constructs an xtensor_view of the given stl-like container, with the specified shape and strides.
 
xtensor_view & operator= (const xtensor_view &)
 
xtensor_view & operator= (xtensor_view &&)
 
void resize (S &&shape, bool force=false)
 Resizes the container.
 
void resize (S &&shape, layout_type l)
 Resizes the container.
 
void resize (S &&shape, const strides_type &strides)
 Resizes the container.
 
auto & reshape (S &&shape, layout_type layout=base_type::static_layout) &
 Reshapes the container and keeps old elements.
 
auto & reshape (std::initializer_list< T > shape, layout_type layout=base_type::static_layout) &
 
layout_type layout () const noexcept
 Return the layout_type of the container.
 
bool is_contiguous () const noexcept
 
- Public Member Functions inherited from xt::xcontainer< xtensor_view< EC, N, L, Tag > >
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
+reference operator[] (size_type i)
 
+reference back ()
 Returns a reference to the last element of the expression.
 
+reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
+reference operator() (Args... args)
 
+const_reference operator() (Args... args) const
 
+reference unchecked (Args... args)
 
+const_reference unchecked (Args... args) const
 
+reference element (It first, It last)
 
+const_reference element (It first, It last) const
 
+stepper stepper_begin (const S &shape) noexcept
 
+const_stepper stepper_begin (const S &shape) const noexcept
 
+stepper stepper_end (const S &shape, layout_type l) noexcept
 
+const_stepper stepper_end (const S &shape, layout_type l) const noexcept
 
+container_simd_return_type_t< storage_type, value_type, requested_type > load_simd (size_type i) const
 
+reference at (Args... args)
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
reference back ()
 Returns a reference to the last element of the expression.
 
reference front ()
 Returns a reference to the first element of the expression.
 
+reference periodic (Args... args)
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
void fill (const T &value)
 Fills the container with the given value.
 
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the container.
 
auto element (It first, It last) -> reference
 Returns a reference to the element at the specified position in the container.
 
auto element (It first, It last) const -> const_reference
 Returns a reference to the element at the specified position in the container.
 
storage_type & storage () noexcept
 Returns a reference to the buffer containing the elements of the container.
 
const storage_type & storage () const noexcept
 Returns a constant reference to the buffer containing the elements of the container.
 
pointer data () noexcept
 Returns a pointer to the underlying array serving as element storage.
 
const_pointer data () const noexcept
 Returns a constant pointer to the underlying array serving as element storage.
 
const size_type data_offset () const noexcept
 Returns the offset to the first element in the container.
 
size_type size () const noexcept
 Returns the number of element in the container.
 
constexpr size_type dimension () const noexcept
 Returns the number of dimensions of the container.
 
constexpr const inner_shape_type & shape () const noexcept
 Returns the shape of the container.
 
constexpr const inner_strides_type & strides () const noexcept
 Returns the strides of the container.
 
constexpr const inner_backstrides_type & backstrides () const noexcept
 Returns the backstrides of the container.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
bool broadcast_shape (S &shape, bool reuse_cache=false) const
 Broadcast the shape of the container to the specified parameter.
 
bool has_linear_assign (const S &strides) const noexcept
 Checks whether the xcontainer can be linearly assigned to an expression with the specified strides.
 
auto stepper_begin (const S &shape) noexcept -> stepper
 
auto stepper_begin (const S &shape) const noexcept -> const_stepper
 
auto stepper_end (const S &shape, layout_type l) noexcept -> stepper
 
auto stepper_end (const S &shape, layout_type l) const noexcept -> const_stepper
 
reference data_element (size_type i)
 
const_reference data_element (size_type i) const
 
reference flat (size_type i)
 Returns a reference to the element at the specified position in the container storage (as if it was one dimensional).
 
const_reference flat (size_type i) const
 Returns a constant reference to the element at the specified position in the container storage (as if it was one dimensional).
 
void store_simd (size_type i, const simd &e)
 
auto load_simd (size_type i) const -> container_simd_return_type_t< storage_type, value_type, requested_type >
 
linear_iterator linear_begin () noexcept
 
const_linear_iterator linear_begin () const noexcept
 
linear_iterator linear_end () noexcept
 
const_linear_iterator linear_end () const noexcept
 
const_linear_iterator linear_cbegin () const noexcept
 
const_linear_iterator linear_cend () const noexcept
 
reverse_linear_iterator linear_rbegin () noexcept
 
const_reverse_linear_iterator linear_rbegin () const noexcept
 
reverse_linear_iterator linear_rend () noexcept
 
const_reverse_linear_iterator linear_rend () const noexcept
 
const_reverse_linear_iterator linear_crbegin () const noexcept
 
const_reverse_linear_iterator linear_crend () const noexcept
 
- Public Member Functions inherited from xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >
+select_iterator< L > begin () noexcept
 
+select_const_iterator< L > begin () const noexcept
 
+broadcast_iterator< S, L > begin (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > begin (const S &shape) const noexcept
 
+select_iterator< L > end () noexcept
 
+select_const_iterator< L > end () const noexcept
 
+broadcast_iterator< S, L > end (const S &shape) noexcept
 
+const_broadcast_iterator< S, L > end (const S &shape) const noexcept
 
+select_const_iterator< L > cbegin () const noexcept
 
+const_broadcast_iterator< S, L > cbegin (const S &shape) const noexcept
 
+select_const_iterator< L > cend () const noexcept
 
+const_broadcast_iterator< S, L > cend (const S &shape) const noexcept
 
+select_reverse_iterator< L > rbegin () noexcept
 
+select_const_reverse_iterator< L > rbegin () const noexcept
 
+reverse_broadcast_iterator< S, L > rbegin (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rbegin (const S &shape) const noexcept
 
+select_reverse_iterator< L > rend () noexcept
 
+select_const_reverse_iterator< L > rend () const noexcept
 
+reverse_broadcast_iterator< S, L > rend (const S &shape) noexcept
 
+const_reverse_broadcast_iterator< S, L > rend (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crbegin () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crbegin (const S &shape) const noexcept
 
+select_const_reverse_iterator< L > crend () const noexcept
 
+const_reverse_broadcast_iterator< S, L > crend (const S &shape) const noexcept
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin () noexcept -> select_iterator< L >
 Returns an iterator to the first element of the expression.
 
auto begin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto end () noexcept -> select_iterator< L >
 Returns an iterator to the element following the last element of the expression.
 
auto end () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the first element of the expression.
 
auto cend () const noexcept -> select_const_iterator< L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend () noexcept -> select_reverse_iterator< L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend () const noexcept -> select_const_reverse_iterator< L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto begin (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the first element of the expression.
 
auto begin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto end (const S &shape) noexcept -> broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the expression.
 
auto end (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto cbegin (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the expression.
 
auto cend (const S &shape) const noexcept -> const_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto rbegin (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the first element of the reversed expression.
 
auto rbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto rend (const S &shape) noexcept -> reverse_broadcast_iterator< S, L >
 Returns an iterator to the element following the last element of the reversed expression.
 
auto rend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
auto crbegin (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the first element of the reversed expression.
 
auto crend (const S &shape) const noexcept -> const_reverse_broadcast_iterator< S, L >
 Returns a constant iterator to the element following the last element of the reversed expression.
 
- Public Member Functions inherited from xt::xview_semantic< xtensor_view< EC, N, L, Tag > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + +

+Friends

class xcontainer< xtensor_view< EC, N, L, Tag > >
 
class xview_semantic< xtensor_view< EC, N, L, Tag > >
 
+ + + + + + + + +

Extended copy semantic

template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type > &
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Static Public Attributes inherited from xt::xcontainer< xtensor_view< EC, N, L, Tag > >
static constexpr layout_type static_layout
 
static constexpr bool contiguous_layout
 
- Static Public Attributes inherited from xt::xcontiguous_iterable< xtensor_view< EC, N, L, Tag > >
static constexpr layout_type static_layout
 
- Protected Member Functions inherited from xt::xstrided_container< xtensor_view< EC, N, L, Tag > >
+ xstrided_container (const xstrided_container &)=default
 
+ xstrided_container (xstrided_container &&)=default
 
+xstrided_container & operator= (const xstrided_container &)=default
 
+xstrided_container & operator= (xstrided_container &&)=default
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&) noexcept
 
 xstrided_container (inner_shape_type &&, inner_strides_type &&, inner_backstrides_type &&, layout_type &&) noexcept
 
inner_shape_type & shape_impl () noexcept
 
const inner_shape_type & shape_impl () const noexcept
 
inner_strides_type & strides_impl () noexcept
 
const inner_strides_type & strides_impl () const noexcept
 
inner_backstrides_type & backstrides_impl () noexcept
 
const inner_backstrides_type & backstrides_impl () const noexcept
 
void reshape_impl (S &&shape, std::true_type, layout_type layout=base_type::static_layout)
 
void reshape_impl (S &&shape, std::false_type, layout_type layout=base_type::static_layout)
 
layout_type & mutable_layout () noexcept
 
- Protected Member Functions inherited from xt::xcontainer< xtensor_view< EC, N, L, Tag > >
+ xcontainer (const xcontainer &)=default
 
+ xcontainer (xcontainer &&)=default
 
+xcontainer & operator= (const xcontainer &)=default
 
+xcontainer & operator= (xcontainer &&)=default
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
derived_type & derived_cast () &noexcept
 
const derived_type & derived_cast () const &noexcept
 
derived_type derived_cast () &&noexcept
 
- Protected Member Functions inherited from xt::xview_semantic< xtensor_view< EC, N, L, Tag > >
+ xview_semantic (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xtensor_view< EC, N, L, Tag > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class EC, std::size_t N, layout_type L, class Tag>
+class xt::xtensor_view< EC, N, L, Tag >

Dense multidimensional container adaptor with view semantics and fixed dimension.

+

The xtensor_view class implements a dense multidimensional container adaptor with viewsemantics and fixed dimension. It is used to provide a multidimensional container semantic and a view semantic to stl-like containers.

+
Template Parameters
+ + + + + +
ECThe closure for the container type to adapt.
NThe dimension of the view.
LThe layout_type of the view.
TagThe expression tag.
+
+
+
See also
xstrided_container, xcontainer
+ +

Definition at line 326 of file xtensor.hpp.

+

Member Typedef Documentation

+ +

◆ allocator_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::allocator_type = typename base_type::allocator_type
+
+ +

Definition at line 339 of file xtensor.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::backstrides_type = typename base_type::backstrides_type
+
+ +

Definition at line 342 of file xtensor.hpp.

+ +
+
+ +

◆ base_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::base_type = xstrided_container<self_type>
+
+ +

Definition at line 335 of file xtensor.hpp.

+ +
+
+ +

◆ container_closure_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::container_closure_type = EC
+
+ +

Definition at line 332 of file xtensor.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::expression_tag = Tag
+
+ +

Definition at line 344 of file xtensor.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::extension_base = extension::xtensor_adaptor_base_t<EC, N, L, Tag>
+
+ +

Definition at line 337 of file xtensor.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::self_type = xtensor_view<EC, N, L, Tag>
+
+ +

Definition at line 334 of file xtensor.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::semantic_base = xview_semantic<self_type>
+
+ +

Definition at line 336 of file xtensor.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::shape_type = typename base_type::shape_type
+
+ +

Definition at line 340 of file xtensor.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::storage_type = typename base_type::storage_type
+
+ +

Definition at line 338 of file xtensor.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::strides_type = typename base_type::strides_type
+
+ +

Definition at line 341 of file xtensor.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + +
using xt::xtensor_view< EC, N, L, Tag >::temporary_type = typename semantic_base::temporary_type
+
+ +

Definition at line 343 of file xtensor.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xtensor_view() [1/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
xt::xtensor_view< EC, N, L, Tag >::xtensor_view (storage_type && storage)
+ 		+inline
+
+ +

Constructs an xtensor_view of the given stl-like container.

+
Parameters
+ + +
storagethe container to adapt
+
+
+ +

Definition at line 741 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_view() [2/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
xt::xtensor_view< EC, N, L, Tag >::xtensor_view (const storage_type & storage)
+ 		+inline
+
+ +

Constructs an xtensor_view of the given stl-like container.

+
Parameters
+ + +
storagethe container to adapt
+
+
+ +

Definition at line 752 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_view() [3/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xtensor_view< EC, N, L, Tag >::xtensor_view (D && storage,
const shape_type & shape,
layout_type l = L )
+ 		+inline
+
+ +

Constructs an xtensor_view of the given stl-like container, with the specified shape and layout_type.

+
Parameters
+ + + + +
storagethe container to adapt
shapethe shape of the xtensor_view
lthe layout_type of the xtensor_view
+
+
+ +

Definition at line 767 of file xtensor.hpp.

+ +
+
+ +

◆ xtensor_view() [4/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class D>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xtensor_view< EC, N, L, Tag >::xtensor_view (D && storage,
const shape_type & shape,
const strides_type & strides )
+ 		+inline
+
+ +

Constructs an xtensor_view of the given stl-like container, with the specified shape and strides.

+
Parameters
+ + + + +
storagethe container to adapt
shapethe shape of the xtensor_view
stridesthe strides of the xtensor_view
+
+
+ +

Definition at line 783 of file xtensor.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator=() [1/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_view< EC, N, L, Tag >::operator= (const E & e) -> disable_xexpression<E, self_type>& +
+ 		+inline
+
+ +

Definition at line 826 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [2/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_view< EC, N, L, Tag >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 817 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [3/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_view< EC, N, L, Tag >::operator= (const xtensor_view< EC, N, L, Tag > & rhs)
+ 		+inline
+
+ +

Definition at line 793 of file xtensor.hpp.

+ +
+
+ +

◆ operator=() [4/4]

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + + + + +
auto xt::xtensor_view< EC, N, L, Tag >::operator= (xtensor_view< EC, N, L, Tag > && rhs)
+ 		+inline
+
+ +

Definition at line 801 of file xtensor.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xcontainer< xtensor_view< EC, N, L, Tag > >

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + +
friend class xcontainer< xtensor_view< EC, N, L, Tag > >
+ 		+friend
+
+ +

Definition at line 376 of file xtensor.hpp.

+ +
+
+ +

◆ xview_semantic< xtensor_view< EC, N, L, Tag > >

+ +
+
+
+template<class EC, std::size_t N, layout_type L, class Tag>
+ + + + + +
+ + + + +
friend class xview_semantic< xtensor_view< EC, N, L, Tag > >
+ 		+friend
+
+ +

Definition at line 376 of file xtensor.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/containers/xtensor.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xtensor__view.js b/classxt_1_1xtensor__view.js new file mode 100644 index 000000000..b8262b032 --- /dev/null +++ b/classxt_1_1xtensor__view.js @@ -0,0 +1,8 @@ +var classxt_1_1xtensor__view = +[ + [ "xtensor_view", "classxt_1_1xtensor__view.html#a3245a15af4f5a46b7315d4f14a1657d8", null ], + [ "xtensor_view", "classxt_1_1xtensor__view.html#ad26a102ac5d777f6d1b3dfad5a0ef1fa", null ], + [ "xtensor_view", "classxt_1_1xtensor__view.html#a70a1388809ad0d8d2869c56f2957fb73", null ], + [ "xtensor_view", "classxt_1_1xtensor__view.html#afd854308ee21d8738686c64a14363481", null ], + [ "operator=", "classxt_1_1xtensor__view.html#a595e97c93a52f5f196d00396435ec76b", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xtensor__view.png b/classxt_1_1xtensor__view.png new file mode 100644 index 000000000..80e284659 Binary files /dev/null and b/classxt_1_1xtensor__view.png differ diff --git a/classxt_1_1xvectorizer-members.html b/classxt_1_1xvectorizer-members.html new file mode 100644 index 000000000..ad512b6c8 --- /dev/null +++ b/classxt_1_1xvectorizer-members.html @@ -0,0 +1,124 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xvectorizer< F, R > Member List
+
+
+ +

This is the complete list of members for xt::xvectorizer< F, R >, including all inherited members.

+ + + + + +
operator()(E &&... e) const (defined in xt::xvectorizer< F, R >)xt::xvectorizer< F, R >
operator()(E &&... e) const -> xfunction_type< E... > (defined in xt::xvectorizer< F, R >)xt::xvectorizer< F, R >inline
xfunction_type typedef (defined in xt::xvectorizer< F, R >)xt::xvectorizer< F, R >
xvectorizer(Func &&f) (defined in xt::xvectorizer< F, R >)xt::xvectorizer< F, R >inline
+
+ + + + diff --git a/classxt_1_1xvectorizer.html b/classxt_1_1xvectorizer.html new file mode 100644 index 000000000..80bbb7f5d --- /dev/null +++ b/classxt_1_1xvectorizer.html @@ -0,0 +1,235 @@ + + + + + + + +xtensor: xt::xvectorizer< F, R > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +List of all members
+
xt::xvectorizer< F, R > Class Template Reference
+
+
+ + + + + +

+Public Types

template<class... E>
using xfunction_type = xfunction<F, xclosure_t<E>...>
 
+ + + + + + + + + + +

+Public Member Functions

template<class Func, class = std::enable_if_t<!std::is_same<std::decay_t<Func>, xvectorizer>::value>>
 xvectorizer (Func &&f)
 
+template<class... E>
xfunction_type< E... > operator() (E &&... e) const
 
template<class... E>
auto operator() (E &&... e) const -> xfunction_type< E... >
 
+

Detailed Description

+
template<class F, class R>
+class xt::xvectorizer< F, R >
+

Definition at line 27 of file xvectorize.hpp.

+

Member Typedef Documentation

+ +

◆ xfunction_type

+ +
+
+
+template<class F, class R>
+
+template<class... E>
+ + + + +
using xt::xvectorizer< F, R >::xfunction_type = xfunction<F, xclosure_t<E>...>
+
+ +

Definition at line 32 of file xvectorize.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xvectorizer()

+ +
+
+
+template<class F, class R>
+
+template<class Func, class>
+ + + + + +
+ + + + + + + +
xt::xvectorizer< F, R >::xvectorizer (Func && f)
+ 		+inline
+
+ +

Definition at line 72 of file xvectorize.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator()()

+ +
+
+
+template<class F, class R>
+
+template<class... E>
+ + + + + +
+ + + + + + + +
auto xt::xvectorizer< F, R >::operator() (E &&... e) const -> xfunction_type<E...> +
+ 		+inline
+
+ +

Definition at line 79 of file xvectorize.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xvectorize.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xview-members.html b/classxt_1_1xview-members.html new file mode 100644 index 000000000..ed3e04e19 --- /dev/null +++ b/classxt_1_1xview-members.html @@ -0,0 +1,345 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xview< CT, S > Member List
+
+
+ +

This is the complete list of members for xt::xview< CT, S >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
access(Arg arg, Args... args) -> reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
access(Arg arg, Args... args) const -> const_reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
access_impl(std::index_sequence< I... >, Args... args) -> reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
access_impl(std::index_sequence< I... >, Args... args) const -> const_reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
accessible_base typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
assign_temporary(temporary_type &&)xt::xview_semantic< xview< CT, S... > >inline
assign_to(xexpression< E > &e, bool force_resize) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
at(Args... args) -> referencext::xaccessible< xview< CT, S... > >inline
at(Args... args) -> referencext::xaccessible< xview< CT, S... > >inline
back() constxt::xaccessible< xview< CT, S... > >
back()xt::xaccessible< xview< CT, S... > >inline
back() constxt::xaccessible< xview< CT, S... > >inline
backstrides() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
backstrides() const -> const inner_strides_type &requires(has_data_interface_concept< T >and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
backstrides_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
bool_load_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
broadcast_shape(ST &shape, bool reuse_cache=false) constxt::xview< CT, S >inline
build_view(E &&e) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
build_view(E &&e) const -> rebind_t< E > (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
build_view_impl(E &&e, std::index_sequence< I... >) const -> rebind_t< E > (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
const_container_iterator typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
const_linear_iterator typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
const_pointer typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
const_reference typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
const_reverse_linear_iterator typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
const_stepper typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
container_iterator typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
contiguous_layout (defined in xt::xview< CT, S >)xt::xview< CT, S >static
data() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
data() (defined in xt::xview< CT, S >)xt::xview< CT, S >
data() const -> const_pointer requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)xt::xview< CT, S >inline
data() -> pointer requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_element(size_type i) (defined in xt::xview< CT, S >)xt::xview< CT, S >
data_element(size_type i) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
data_element(size_type i) -> reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_element(size_type i) const -> const_reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_offset() const noexceptxt::xview< CT, S >inline
data_xbegin() noexcept (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_xbegin() const noexcept (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_xbegin_impl(It begin) const noexcept (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_xend(layout_type l, size_type offset) noexcept (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_xend(layout_type l, size_type offset) const noexcept (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
data_xend_impl(It begin, layout_type l, size_type offset) const noexcept (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
difference_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
dimension() const noexceptxt::xconst_accessible< xview< CT, S... > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
element(It first, It last) (defined in xt::xview< CT, S >)xt::xview< CT, S >
element(It first, It last) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
element(It first, It last) -> reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
element(It first, It last) const -> const_reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
expression() noexceptxt::xview< CT, S >inline
expression() const noexceptxt::xview< CT, S >inline
expression_tag typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
extension_base typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
fill(const T &value)xt::xview< CT, S >inline
flat(size_type i) (defined in xt::xview< CT, S >)xt::xview< CT, S >
flat(size_type i) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
flat(size_type i) -> reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
flat(size_type i) const -> const_reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
front() constxt::xaccessible< xview< CT, S... > >
front()xt::xaccessible< xview< CT, S... > >inline
front() constxt::xaccessible< xview< CT, S... > >inline
has_linear_assign(const ST &strides) constxt::xview< CT, S >inline
has_trivial_strides (defined in xt::xview< CT, S >)xt::xview< CT, S >static
in_bounds(Args... args) constxt::xconst_accessible< xview< CT, S... > >inline
index(Args... args) const -> size_type (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
inner_backstrides_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
inner_shape_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
inner_strides_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
inner_types typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
is_const (defined in xt::xview< CT, S >)xt::xview< CT, S >static
is_contiguous() const noexcept (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
is_contiguous_view (defined in xt::xview< CT, S >)xt::xview< CT, S >static
is_strided_view (defined in xt::xview< CT, S >)xt::xview< CT, S >static
iterable_base typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
layout() const noexceptxt::xview< CT, S >inline
linear_begin() (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_begin() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_begin() -> linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_begin() const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_cbegin() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_cbegin() const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_cend() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_cend() const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_crbegin() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_crbegin() const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_crend() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_crend() const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_end() (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_end() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_end() -> linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_end() const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_iterator typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rbegin() (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rbegin() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rbegin() -> reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rbegin() const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rend() (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rend() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rend() -> reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
linear_rend() const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >
load_simd(size_type i) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
load_simd(size_type i) const -> simd_return_type< requested_type > requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
make_index(It first, It last) const -> base_index_type (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator const_reference() const (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
operator reference() (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator&() & (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
operator&() const & (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
operator&() && (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator()(Args... args) (defined in xt::xview< CT, S >)xt::xview< CT, S >
operator()(Args... args) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
operator()(Args... args) -> referencext::xview< CT, S >inline
operator()(Args... args) const -> const_referencext::xview< CT, S >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator=(const xview &rhs) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
operator=(const xexpression< E > &e) (defined in xt::xview< CT, S >)xt::xview< CT, S >
operator=(const E &e) (defined in xt::xview< CT, S >)xt::xview< CT, S >
operator=(const xexpression< E > &e) -> self_type &xt::xview< CT, S >inline
operator=(const E &e) -> disable_xexpression< E, self_type > & (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< xview< CT, S... > >inline
operator[](const S &index) -> disable_integral_t< S, reference >xt::xaccessible< xview< CT, S... > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< xview< CT, S... > >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
periodic(Args... args) -> referencext::xaccessible< xview< CT, S... > >inline
periodic(Args... args) -> referencext::xaccessible< xview< CT, S... > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< xview< CT, S... > >inline
pointer typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
rank (defined in xt::xview< CT, S >)xt::xview< CT, S >static
rebind_t typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
reference typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
reverse_linear_iterator typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
self_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
semantic_base typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
shape() const noexceptxt::xview< CT, S >inline
xt::xaccessible< xview< CT, S... > >::shape(size_type index) constxt::xconst_accessible< xview< CT, S... > >inline
shape_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
simd_return_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
simd_value_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
size() const noexcept(noexcept(derived_cast().shape()))xt::xconst_accessible< xview< CT, S... > >inline
size_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
slice_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
sliced_access(const xslice< T > &slice) const -> size_type (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
sliced_access(const xslice< T > &slice, Arg arg, Args... args) const -> size_type (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
sliced_access(const T &squeeze, Args...) const -> size_type requires(!is_xslice< T >::value) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
slices() const noexceptxt::xview< CT, S >inline
static_layout (defined in xt::xview< CT, S >)xt::xview< CT, S >static
stepper typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
stepper_begin(const ST &shape) (defined in xt::xview< CT, S >)xt::xview< CT, S >
stepper_begin(const ST &shape) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
stepper_begin(const ST &shape) -> stepper (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
stepper_begin(const ST &shape) const -> const_stepper (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
stepper_end(const ST &shape, layout_type l) (defined in xt::xview< CT, S >)xt::xview< CT, S >
stepper_end(const ST &shape, layout_type l) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
stepper_end(const ST &shape, layout_type l) -> stepper (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
stepper_end(const ST &shape, layout_type l) const -> const_stepper (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
storage() (defined in xt::xview< CT, S >)xt::xview< CT, S >
storage() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
storage() -> storage_type &requires(has_data_interface_concept< T >)xt::xview< CT, S >inline
storage() const -> const storage_type &requires(has_data_interface_concept< T >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
storage_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
store_simd(size_type i, const simd &e) (defined in xt::xview< CT, S >)xt::xview< CT, S >
store_simd(size_type i, const simd &e) -> void requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >) (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
strides() const (defined in xt::xview< CT, S >)xt::xview< CT, S >
strides() const -> const inner_strides_type &requires(has_data_interface_concept< T >and strided_view_concept< CT, S... >)xt::xview< CT, S >inline
strides_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
temporary_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
unchecked(Args... args) (defined in xt::xview< CT, S >)xt::xview< CT, S >
unchecked(Args... args) const (defined in xt::xview< CT, S >)xt::xview< CT, S >
unchecked(Args... args) -> referencext::xview< CT, S >inline
unchecked(Args... args) const -> const_referencext::xview< CT, S >inline
unchecked_impl(std::index_sequence< I... >, Args... args) -> reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
unchecked_impl(std::index_sequence< I... >, Args... args) const -> const_reference (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
underlying_size(size_type dim) const (defined in xt::xview< CT, S >)xt::xview< CT, S >inline
value_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
xexpression_inner_backstrides_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
xexpression_inner_strides_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
xexpression_type typedef (defined in xt::xview< CT, S >)xt::xview< CT, S >
xview(CTA &&e, FSL &&first_slice, SL &&... slices) noexceptxt::xview< CT, S >explicit
xview(const xview &)=default (defined in xt::xview< CT, S >)xt::xview< CT, S >
xview_semantic< xview< CT, S... > > (defined in xt::xview< CT, S >)xt::xview< CT, S >friend
+
+ + + + diff --git a/classxt_1_1xview.html b/classxt_1_1xview.html new file mode 100644 index 000000000..67ef56b05 --- /dev/null +++ b/classxt_1_1xview.html @@ -0,0 +1,4544 @@ + + + + + + + +xtensor: xt::xview< CT, S > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Static Public Attributes | +Friends | +List of all members
+
xt::xview< CT, S > Class Template Reference
+
+
+ +

Multidimensional view with tensor semantic. + More...

+ +

#include <xview.hpp>

+
+Inheritance diagram for xt::xview< CT, S >:
+
+
+ + +xt::xview_semantic< xview< CT, S... > > +xt::xaccessible< xview< CT, S... > > +xt::xsemantic_base< xview< CT, S... > > +xt::xconst_accessible< xview< CT, S... > > + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Types

using self_type = xview<CT, S...>
 
using inner_types = xcontainer_inner_types<self_type>
 
using xexpression_type = std::decay_t<CT>
 
using semantic_base = xview_semantic<self_type>
 
using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
 
using accessible_base = xaccessible<self_type>
 
using extension_base = extension::xview_base_t<CT, S...>
 
using expression_tag = typename extension_base::expression_tag
 
using value_type = typename xexpression_type::value_type
 
using simd_value_type = xt_simd::simd_type<value_type>
 
using bool_load_type = typename xexpression_type::bool_load_type
 
using reference = typename inner_types::reference
 
using const_reference = typename inner_types::const_reference
 
using pointer
 
using const_pointer = typename xexpression_type::const_pointer
 
using size_type = typename inner_types::size_type
 
using difference_type = typename xexpression_type::difference_type
 
using iterable_base = xiterable<self_type>
 
using inner_shape_type = typename iterable_base::inner_shape_type
 
using shape_type = typename xview_shape_type<typename xexpression_type::shape_type, S...>::type
 
using xexpression_inner_strides_type
 
using xexpression_inner_backstrides_type
 
using storage_type = typename inner_types::storage_type
 
using inner_strides_type
 
using inner_backstrides_type
 
using strides_type = get_strides_t<shape_type>
 
using backstrides_type = strides_type
 
using slice_type = std::tuple<S...>
 
using stepper = typename iterable_base::stepper
 
using const_stepper = typename iterable_base::const_stepper
 
using linear_iterator
 
using const_linear_iterator
 
using reverse_linear_iterator = std::reverse_iterator<linear_iterator>
 
using const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>
 
using container_iterator = pointer
 
using const_container_iterator = const_pointer
 
template<class E>
using rebind_t = xview<E, S...>
 
template<class requested_type>
using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
 
- Public Types inherited from xt::xview_semantic< xview< CT, S... > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xsemantic_base< xview< CT, S... > >
using base_type
 
using derived_type
 
using temporary_type
 
- Public Types inherited from xt::xaccessible< xview< CT, S... > >
using base_type
 
using derived_type
 
using reference
 
using size_type
 
- Public Types inherited from xt::xconst_accessible< xview< CT, S... > >
using derived_type
 
using inner_types
 
using reference
 
using const_reference
 
using size_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+ xview (const xview &)=default
 
+template<class E>
self_type & operator= (const xexpression< E > &e)
 
+template<class E>
disable_xexpression< E, self_type > & operator= (const E &e)
 
+template<class... Args>
reference operator() (Args... args)
 
+template<class... Args>
reference unchecked (Args... args)
 
+template<class It>
reference element (It first, It last)
 
+template<class... Args>
const_reference operator() (Args... args) const
 
+template<class... Args>
const_reference unchecked (Args... args) const
 
+template<class It>
const_reference element (It first, It last) const
 
+template<class ST>
stepper stepper_begin (const ST &shape)
 
+template<class ST>
stepper stepper_end (const ST &shape, layout_type l)
 
+template<class ST>
const_stepper stepper_begin (const ST &shape) const
 
+template<class ST>
const_stepper stepper_end (const ST &shape, layout_type l) const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T>)
storage_type & storage ()
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T>)
const storage_type & storage () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
linear_iterator linear_begin ()
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
linear_iterator linear_end ()
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_linear_iterator linear_begin () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_linear_iterator linear_end () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_linear_iterator linear_cbegin () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_linear_iterator linear_cend () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
reverse_linear_iterator linear_rbegin ()
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
reverse_linear_iterator linear_rend ()
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_reverse_linear_iterator linear_rbegin () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_reverse_linear_iterator linear_rend () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_reverse_linear_iterator linear_crbegin () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_reverse_linear_iterator linear_crend () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const inner_strides_type & strides () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const inner_strides_type & backstrides () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
const_pointer data () const
 
+template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
pointer data ()
 
template<xscalar_concept ST = self_type>
 operator reference ()
 
template<xscalar_concept ST = self_type>
 operator const_reference () const
 
+template<class E>
rebind_t< E > build_view (E &&e) const
 
+template<class align, class simd, class T = xexpression_type>
+requires (has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
void store_simd (size_type i, const simd &e)
 
+template<class align, class requested_type = value_type, std::size_t N = xt_simd::simd_traits<requested_type>::size, class T = xexpression_type>
+requires (has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
simd_return_type< requested_type > load_simd (size_type i) const
 
+template<class T = xexpression_type>
+requires (has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
reference data_element (size_type i)
 
+template<class T = xexpression_type>
+requires (has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
const_reference data_element (size_type i) const
 
+template<class T = xexpression_type>
+requires (has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
reference flat (size_type i)
 
+template<class T = xexpression_type>
+requires (has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
const_reference flat (size_type i) const
 
Size and shape
const inner_shape_type & shape () const noexcept
 Returns the shape of the view.
 
const slice_type & slices () const noexcept
 Returns the slices of the view.
 
layout_type layout () const noexcept
 Returns the slices of the view.
 
bool is_contiguous () const noexcept
 
Extended copy semantic
template<class E>
auto operator= (const xexpression< E > &e) -> self_type &
 The extended assignment operator.
 
template<class E>
auto operator= (const E &e) -> disable_xexpression< E, self_type > &
 
- Public Member Functions inherited from xt::xview_semantic< xview< CT, S... > >
+derived_type & assign_xexpression (const xexpression< E > &e)
 
+derived_type & computed_assign (const xexpression< E > &e)
 
+derived_type & scalar_computed_assign (const E &e, F &&f)
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< xview< CT, S... > >
+disable_xexpression< E, derived_type & > operator+= (const E &)
 
+derived_type & operator+= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator-= (const E &)
 
+derived_type & operator-= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator*= (const E &)
 
+derived_type & operator*= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator/= (const E &)
 
+derived_type & operator/= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator%= (const E &)
 
+derived_type & operator%= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator&= (const E &)
 
+derived_type & operator&= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator|= (const E &)
 
+derived_type & operator|= (const xexpression< E > &)
 
+disable_xexpression< E, derived_type & > operator^= (const E &)
 
+derived_type & operator^= (const xexpression< E > &)
 
+derived_type & assign (const xexpression< E > &)
 
+derived_type & plus_assign (const xexpression< E > &)
 
+derived_type & minus_assign (const xexpression< E > &)
 
+derived_type & multiplies_assign (const xexpression< E > &)
 
+derived_type & divides_assign (const xexpression< E > &)
 
+derived_type & modulus_assign (const xexpression< E > &)
 
+derived_type & bit_and_assign (const xexpression< E > &)
 
+derived_type & bit_or_assign (const xexpression< E > &)
 
+derived_type & bit_xor_assign (const xexpression< E > &)
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
auto operator= (const xexpression< E > &e) -> derived_type &
 
- Public Member Functions inherited from xt::xaccessible< xview< CT, S... > >
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
+const_reference operator[] (size_type i) const
 
+const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+const_reference front () const
 Returns a constant reference to first the element of the expression.
 
+const_reference periodic (Args... args) const
 
+reference at (Args... args)
 
auto at (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+const_reference at (Args... args) const
 
+disable_integral_t< S, reference > operator[] (const S &index)
 
+reference operator[] (std::initializer_list< I > index)
 
reference operator[] (size_type i)
 
auto operator[] (const S &index) -> disable_integral_t< S, reference >
 Returns a reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) -> reference
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
+reference periodic (Args... args)
 
auto periodic (Args... args) -> reference
 Returns a reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
+const_reference periodic (Args... args) const
 
reference front ()
 Returns a reference to the first element of the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
reference back ()
 Returns a reference to the last element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
- Public Member Functions inherited from xt::xconst_accessible< xview< CT, S... > >
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
size_type size () const noexcept(noexcept(derived_cast().shape()))
 Returns the size of the expression.
 
size_type dimension () const noexcept
 Returns the number of dimensions of the expression.
 
size_type shape (size_type index) const
 Returns the i-th dimension of the expression.
 
+const_reference at (Args... args) const
 
auto at (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after dimension and bounds checking.
 
+disable_integral_t< S, const_reference > operator[] (const S &index) const
 
+const_reference operator[] (std::initializer_list< I > index) const
 
const_reference operator[] (size_type i) const
 
auto operator[] (const S &index) const -> disable_integral_t< S, const_reference >
 Returns a constant reference to the element at the specified position in the expression.
 
auto operator[] (std::initializer_list< I > index) const -> const_reference
 
+const_reference periodic (Args... args) const
 
auto periodic (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the expression, after applying periodicity to the indices (negative and 'overflowing' indices are changed).
 
bool in_bounds (Args... args) const
 Returns true only if the the specified position is a valid entry in the expression.
 
const_reference front () const
 Returns a constant reference to first the element of the expression.
 
const_reference back () const
 Returns a constant reference to last the element of the expression.
 
+ + + + + + + + + + + + + + + +

+Static Public Attributes

static constexpr bool is_const = std::is_const<std::remove_reference_t<CT>>::value
 
static constexpr layout_type static_layout = inner_types::layout
 
static constexpr bool contiguous_layout = static_layout != layout_type::dynamic
 
static constexpr bool is_strided_view = detail::is_strided_view<xexpression_type, S...>::value
 
static constexpr bool is_contiguous_view = contiguous_layout
 
static constexpr bool has_trivial_strides
 
static constexpr std::size_t rank = SIZE_MAX
 
+ + + +

+Friends

class xview_semantic< xview< CT, S... > >
 
+ + + + + + + +

Constructor

template<class CTA, class FSL, class... SL>
 xview (CTA &&e, FSL &&first_slice, SL &&... slices) noexcept
 Constructs a view on the specified xexpression.
 
self_type & operator= (const xview &rhs)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Data

template<class T>
void fill (const T &value)
 Fills the view with the given value.
 
xexpression_type & expression () noexcept
 Returns a reference to the underlying expression of the view.
 
const xexpression_type & expression () const noexcept
 Returns a const reference to the underlying expression of the view.
 
template<class T = xexpression_type>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
std::size_t data_offset () const noexcept
 Return the offset to the first element of the view in the underlying container.
 
size_type underlying_size (size_type dim) const
 
xtl::xclosure_pointer< self_type & > operator& () &
 
xtl::xclosure_pointer< const self_type & > operator& () const &
 
xtl::xclosure_pointer< self_type > operator& () &&
 
template<class... Args>
auto operator() (Args... args) -> reference
 Returns a reference to the element at the specified position in the view.
 
template<class... Args>
auto unchecked (Args... args) -> reference
 Returns a reference to the element at the specified position in the view.
 
template<class It>
auto element (It first, It last) -> reference
 
template<class... Args>
auto operator() (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the view.
 
template<class... Args>
auto unchecked (Args... args) const -> const_reference
 Returns a constant reference to the element at the specified position in the view.
 
template<class It>
auto element (It first, It last) const -> const_reference
 
template<class T>
auto storage () -> storage_type &requires(has_data_interface_concept< T >)
 Returns the data holder of the underlying container (only if the view is on a realized container).
 
template<class T>
auto storage () const -> const storage_type &requires(has_data_interface_concept< T >)
 
template<class T>
auto linear_begin () -> linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_end () -> linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_begin () const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_end () const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_cbegin () const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_cend () const -> const_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_rbegin () -> reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_rend () -> reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_rbegin () const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_rend () const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_crbegin () const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto linear_crend () const -> const_reverse_linear_iterator requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto strides () const -> const inner_strides_type &requires(has_data_interface_concept< T >and strided_view_concept< CT, S... >)
 Return the strides for the underlying container of the view.
 
template<class T>
auto backstrides () const -> const inner_strides_type &requires(has_data_interface_concept< T >and strided_view_concept< CT, S... >)
 
template<class T>
auto data () const -> const_pointer requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 Return the pointer to the underlying buffer.
 
template<class T>
auto data () -> pointer requires(has_data_interface_concept< T > and strided_view_concept< CT, S... >)
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Broadcasting

template<class ST>
bool broadcast_shape (ST &shape, bool reuse_cache=false) const
 Broadcast the shape of the view to the specified parameter.
 
template<class ST>
bool has_linear_assign (const ST &strides) const
 Checks whether the xview can be linearly assigned to an expression with the specified strides.
 
template<class It>
It data_xbegin_impl (It begin) const noexcept
 
template<class It>
It data_xend_impl (It begin, layout_type l, size_type offset) const noexcept
 
container_iterator data_xbegin () noexcept
 
const_container_iterator data_xbegin () const noexcept
 
container_iterator data_xend (layout_type l, size_type offset) noexcept
 
const_container_iterator data_xend (layout_type l, size_type offset) const noexcept
 
template<class E, class T = xexpression_type>
+requires (has_data_interface_concept<T> and contiguous_view_concept<E, S...>)
void assign_to (xexpression< E > &e, bool force_resize) const
 
template<class E, std::size_t... I>
auto build_view_impl (E &&e, std::index_sequence< I... >) const -> rebind_t< E >
 
template<class E>
auto build_view (E &&e) const -> rebind_t< E >
 
template<class align, class simd, class T>
auto store_simd (size_type i, const simd &e) -> void requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class align, class requested_type, std::size_t N, class T>
auto load_simd (size_type i) const -> simd_return_type< requested_type > requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto data_element (size_type i) -> reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto data_element (size_type i) const -> const_reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto flat (size_type i) -> reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class T>
auto flat (size_type i) const -> const_reference requires(has_simd_interface_concept< T > and strided_view_concept< CT, S... >)
 
template<class Arg, class... Args>
auto access (Arg arg, Args... args) -> reference
 
template<class Arg, class... Args>
auto access (Arg arg, Args... args) const -> const_reference
 
template<typename std::decay_t< CT >::size_type... I, class... Args>
auto unchecked_impl (std::index_sequence< I... >, Args... args) -> reference
 
template<typename std::decay_t< CT >::size_type... I, class... Args>
auto unchecked_impl (std::index_sequence< I... >, Args... args) const -> const_reference
 
template<typename std::decay_t< CT >::size_type... I, class... Args>
auto access_impl (std::index_sequence< I... >, Args... args) -> reference
 
template<typename std::decay_t< CT >::size_type... I, class... Args>
auto access_impl (std::index_sequence< I... >, Args... args) const -> const_reference
 
template<typename std::decay_t< CT >::size_type I, class... Args>
auto index (Args... args) const -> size_type
 
template<typename std::decay_t< CT >::size_type I, class T>
auto sliced_access (const xslice< T > &slice) const -> size_type
 
template<typename std::decay_t< CT >::size_type I, class T, class Arg, class... Args>
auto sliced_access (const xslice< T > &slice, Arg arg, Args... args) const -> size_type
 
template<typename std::decay_t< CT >::size_type I, class T, class... Args>
auto sliced_access (const T &squeeze, Args...) const -> size_type requires(!is_xslice< T >::value)
 
template<class It>
auto make_index (It first, It last) const -> base_index_type
 
template<class ST>
auto stepper_begin (const ST &shape) -> stepper
 
template<class ST>
auto stepper_end (const ST &shape, layout_type l) -> stepper
 
template<class ST>
auto stepper_begin (const ST &shape) const -> const_stepper
 
template<class ST>
auto stepper_end (const ST &shape, layout_type l) const -> const_stepper
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Additional Inherited Members

- Protected Member Functions inherited from xt::xview_semantic< xview< CT, S... > >
+ xview_semantic (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< xview< CT, S... > >
+ xsemantic_base (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xaccessible< xview< CT, S... > >
+ xaccessible (const xaccessible &)=default
 
+ xaccessible (xaccessible &&)=default
 
+xaccessible & operator= (const xaccessible &)=default
 
+xaccessible & operator= (xaccessible &&)=default
 
- Protected Member Functions inherited from xt::xconst_accessible< xview< CT, S... > >
+ xconst_accessible (const xconst_accessible &)=default
 
+ xconst_accessible (xconst_accessible &&)=default
 
+xconst_accessible & operator= (const xconst_accessible &)=default
 
+xconst_accessible & operator= (xconst_accessible &&)=default
 
+

Detailed Description

+
template<class CT, class... S>
+class xt::xview< CT, S >

Multidimensional view with tensor semantic.

+

The xview class implements a multidimensional view with tensor semantic. It is used to adapt the shape of an xexpression without changing it. xview is not meant to be used directly, but only with the view helper functions.

+
Template Parameters
+ + + +
CTthe closure type of the xexpression to adapt
Sthe slices type describing the shape adaptation
+
+
+
See also
view, range, all, newaxis, keep, drop
+
Examples
/home/runner/work/xtensor/xtensor/include/xtensor/views/index_mapper.hpp.
+
+ +

Definition at line 358 of file xview.hpp.

+

Member Typedef Documentation

+ +

◆ accessible_base

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::accessible_base = xaccessible<self_type>
+
+ +

Definition at line 374 of file xview.hpp.

+ +
+
+ +

◆ backstrides_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::backstrides_type = strides_type
+
+ +

Definition at line 431 of file xview.hpp.

+ +
+
+ +

◆ bool_load_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::bool_load_type = typename xexpression_type::bool_load_type
+
+ +

Definition at line 381 of file xview.hpp.

+ +
+
+ +

◆ const_container_iterator

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::const_container_iterator = const_pointer
+
+ +

Definition at line 452 of file xview.hpp.

+ +
+
+ +

◆ const_linear_iterator

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::const_linear_iterator
+
+Initial value:
std::conditional_t<
+
has_data_interface<xexpression_type>::value && is_strided_view,
+
typename xexpression_type::const_linear_iterator,
+
typename iterable_base::const_linear_iterator>
+
xt::has_data_interface
Definition xutils.hpp:563
+
+

Definition at line 443 of file xview.hpp.

+ +
+
+ +

◆ const_pointer

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::const_pointer = typename xexpression_type::const_pointer
+
+ +

Definition at line 386 of file xview.hpp.

+ +
+
+ +

◆ const_reference

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::const_reference = typename inner_types::const_reference
+
+ +

Definition at line 383 of file xview.hpp.

+ +
+
+ +

◆ const_reverse_linear_iterator

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>
+
+ +

Definition at line 449 of file xview.hpp.

+ +
+
+ +

◆ const_stepper

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::const_stepper = typename iterable_base::const_stepper
+
+ +

Definition at line 437 of file xview.hpp.

+ +
+
+ +

◆ container_iterator

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::container_iterator = pointer
+
+ +

Definition at line 451 of file xview.hpp.

+ +
+
+ +

◆ difference_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::difference_type = typename xexpression_type::difference_type
+
+ +

Definition at line 388 of file xview.hpp.

+ +
+
+ +

◆ expression_tag

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::expression_tag = typename extension_base::expression_tag
+
+ +

Definition at line 376 of file xview.hpp.

+ +
+
+ +

◆ extension_base

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::extension_base = extension::xview_base_t<CT, S...>
+
+ +

Definition at line 375 of file xview.hpp.

+ +
+
+ +

◆ inner_backstrides_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::inner_backstrides_type
+
+Initial value:
std::conditional_t<
+
has_trivial_strides,
+
typename detail::unwrap_offset_container<
+
xexpression_type::static_layout,
+
xexpression_inner_backstrides_type,
+
integral_count<S...>()>::type,
+
get_strides_t<shape_type>>
+
+

Definition at line 422 of file xview.hpp.

+ +
+
+ +

◆ inner_shape_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::inner_shape_type = typename iterable_base::inner_shape_type
+
+ +

Definition at line 397 of file xview.hpp.

+ +
+
+ +

◆ inner_strides_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::inner_strides_type
+
+Initial value:
std::conditional_t<
+
has_trivial_strides,
+
typename detail::unwrap_offset_container<
+
xexpression_type::static_layout,
+
xexpression_inner_strides_type,
+
integral_count<S...>()>::type,
+
get_strides_t<shape_type>>
+
+

Definition at line 414 of file xview.hpp.

+ +
+
+ +

◆ inner_types

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::inner_types = xcontainer_inner_types<self_type>
+
+ +

Definition at line 369 of file xview.hpp.

+ +
+
+ +

◆ iterable_base

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::iterable_base = xiterable<self_type>
+
+ +

Definition at line 396 of file xview.hpp.

+ +
+
+ +

◆ linear_iterator

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::linear_iterator
+
+Initial value:
std::conditional_t<
+
has_data_interface<xexpression_type>::value && is_strided_view,
+
std::conditional_t<is_const, typename xexpression_type::const_linear_iterator, typename xexpression_type::linear_iterator>,
+
typename iterable_base::linear_iterator>
+
+

Definition at line 439 of file xview.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::pointer
+
+Initial value:
std::
+
conditional_t<is_const, typename xexpression_type::const_pointer, typename xexpression_type::pointer>
+
+

Definition at line 384 of file xview.hpp.

+ +
+
+ +

◆ rebind_t

+ +
+
+
+template<class CT, class... S>
+
+template<class E>
+ + + + +
using xt::xview< CT, S >::rebind_t = xview<E, S...>
+
+ +

Definition at line 622 of file xview.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::reference = typename inner_types::reference
+
+ +

Definition at line 382 of file xview.hpp.

+ +
+
+ +

◆ reverse_linear_iterator

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::reverse_linear_iterator = std::reverse_iterator<linear_iterator>
+
+ +

Definition at line 448 of file xview.hpp.

+ +
+
+ +

◆ self_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::self_type = xview<CT, S...>
+
+ +

Definition at line 368 of file xview.hpp.

+ +
+
+ +

◆ semantic_base

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::semantic_base = xview_semantic<self_type>
+
+ +

Definition at line 371 of file xview.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::shape_type = typename xview_shape_type<typename xexpression_type::shape_type, S...>::type
+
+ +

Definition at line 398 of file xview.hpp.

+ +
+
+ +

◆ simd_return_type

+ +
+
+
+template<class CT, class... S>
+
+template<class requested_type>
+ + + + +
using xt::xview< CT, S >::simd_return_type = xt_simd::simd_return_type<value_type, requested_type>
+
+ +

Definition at line 632 of file xview.hpp.

+ +
+
+ +

◆ simd_value_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::simd_value_type = xt_simd::simd_type<value_type>
+
+ +

Definition at line 380 of file xview.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::size_type = typename inner_types::size_type
+
+ +

Definition at line 387 of file xview.hpp.

+ +
+
+ +

◆ slice_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::slice_type = std::tuple<S...>
+
+ +

Definition at line 434 of file xview.hpp.

+ +
+
+ +

◆ stepper

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::stepper = typename iterable_base::stepper
+
+ +

Definition at line 436 of file xview.hpp.

+ +
+
+ +

◆ storage_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::storage_type = typename inner_types::storage_type
+
+ +

Definition at line 410 of file xview.hpp.

+ +
+
+ +

◆ strides_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::strides_type = get_strides_t<shape_type>
+
+ +

Definition at line 430 of file xview.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::temporary_type = typename xcontainer_inner_types<self_type>::temporary_type
+
+ +

Definition at line 372 of file xview.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::value_type = typename xexpression_type::value_type
+
+ +

Definition at line 379 of file xview.hpp.

+ +
+
+ +

◆ xexpression_inner_backstrides_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::xexpression_inner_backstrides_type
+
+Initial value:
xtl::mpl::eval_if_t<
+
has_strides<xexpression_type>,
+
detail::expr_inner_backstrides_type<xexpression_type>,
+
get_strides_type<shape_type>>
+
xt::get_strides_type
Definition xutils.hpp:961
+
xt::has_strides
Definition xutils.hpp:576
+
+

Definition at line 405 of file xview.hpp.

+ +
+
+ +

◆ xexpression_inner_strides_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::xexpression_inner_strides_type
+
+Initial value:
xtl::mpl::eval_if_t<
+
has_strides<xexpression_type>,
+
detail::expr_inner_strides_type<xexpression_type>,
+
get_strides_type<shape_type>>
+
+

Definition at line 400 of file xview.hpp.

+ +
+
+ +

◆ xexpression_type

+ +
+
+
+template<class CT, class... S>
+ + + + +
using xt::xview< CT, S >::xexpression_type = std::decay_t<CT>
+
+ +

Definition at line 370 of file xview.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xview()

+ +
+
+
+template<class CT, class... S>
+
+template<class CTA, class FSL, class... SL>
+ + + + + +
+ + + + + + + + + + + + + + + + +
xt::xview< CT, S >::xview (CTA && e,
FSL && first_slice,
SL &&... slices )
+ 		+explicitnoexcept
+
+ +

Constructs a view on the specified xexpression.

+

Users should not call directly this constructor but use the view function instead.

Parameters
+ + + + +
ethe xexpression to adapt
first_slicethe first slice describing the view
slicesthe slices list describing the view
+
+
+
See also
view
+ +

Definition at line 881 of file xview.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ access() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class Arg, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::access (Arg arg,
Args... args ) -> reference +
+ 		+inline
+
+ +

Definition at line 1587 of file xview.hpp.

+ +
+
+ +

◆ access() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class Arg, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::access (Arg arg,
Args... args ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 1604 of file xview.hpp.

+ +
+
+ +

◆ access_impl() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type... I, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::access_impl (std::index_sequence< I... > ,
Args... args ) -> reference +
+ 		+inline
+
+ +

Definition at line 1630 of file xview.hpp.

+ +
+
+ +

◆ access_impl() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type... I, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::access_impl (std::index_sequence< I... > ,
Args... args ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 1637 of file xview.hpp.

+ +
+
+ +

◆ assign_to()

+ +
+
+
+template<class CT, class... S>
+requires (has_data_interface_concept<T> and contiguous_view_concept<E, S...>)
+
+template<class E, class T>
+requires (has_data_interface_concept<T> and contiguous_view_concept<E, S...>)
+ + + + + + + + + + + +
void xt::xview< CT, S >::assign_to (xexpression< E > & e,
bool force_resize ) const
+
+ +

Definition at line 1454 of file xview.hpp.

+ +
+
+ +

◆ backstrides()

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::backstrides () const -> const inner_strides_type& requires(has_data_interface_concept<T>and strided_view_concept<CT, S...>)
+ 		+inline
+
+ +

Definition at line 1282 of file xview.hpp.

+ +
+
+ +

◆ broadcast_shape()

+ +
+
+
+template<class CT, class... S>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
bool xt::xview< CT, S >::broadcast_shape (ST & shape,
bool reuse_cache = false ) const
+ 		+inline
+
+ +

Broadcast the shape of the view to the specified parameter.

+
Parameters
+ + + +
shapethe result shape
reuse_cacheparameter for internal optimization
+
+
+
Returns
a boolean indicating whether the broadcasting is trivial
+ +

Definition at line 1386 of file xview.hpp.

+ +
+
+ +

◆ build_view()

+ +
+
+
+template<class CT, class... S>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::build_view (E && e) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 1471 of file xview.hpp.

+ +
+
+ +

◆ build_view_impl()

+ +
+
+
+template<class CT, class... S>
+
+template<class E, std::size_t... I>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::build_view_impl (E && e,
std::index_sequence< I... >  ) const -> rebind_t<E> +
+ 		+inline
+
+ +

Definition at line 1464 of file xview.hpp.

+ +
+
+ +

◆ data() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::data () -> pointer + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Definition at line 1305 of file xview.hpp.

+ +
+
+ +

◆ data() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::data () const -> const_pointer + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Return the pointer to the underlying buffer.

+ +

Definition at line 1297 of file xview.hpp.

+ +
+
+ +

◆ data_element() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::data_element (size_type i) -> reference + requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Definition at line 1494 of file xview.hpp.

+ +
+
+ +

◆ data_element() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::data_element (size_type i) const -> const_reference + requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Definition at line 1502 of file xview.hpp.

+ +
+
+ +

◆ data_offset()

+ +
+
+
+template<class CT, class... S>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
+
+template<class T>
+requires (has_data_interface_concept<T> and strided_view_concept<CT, S...>)
+ + + + + +
+ + + + + + + +
std::size_t xt::xview< CT, S >::data_offset () const
+ 		+inlinenoexcept
+
+ +

Return the offset to the first element of the view in the underlying container.

+ +

Definition at line 1337 of file xview.hpp.

+ +
+
+ +

◆ data_xbegin() [1/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::data_xbegin () const
+ 		+inlinenoexcept
+
+ +

Definition at line 1433 of file xview.hpp.

+ +
+
+ +

◆ data_xbegin() [2/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::data_xbegin ()
+ 		+inlinenoexcept
+
+ +

Definition at line 1427 of file xview.hpp.

+ +
+
+ +

◆ data_xbegin_impl()

+ +
+
+
+template<class CT, class... S>
+
+template<class It>
+ + + + + +
+ + + + + + + +
It xt::xview< CT, S >::data_xbegin_impl (It begin) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1414 of file xview.hpp.

+ +
+
+ +

◆ data_xend() [1/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::data_xend (layout_type l,
size_type offset ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1445 of file xview.hpp.

+ +
+
+ +

◆ data_xend() [2/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::data_xend (layout_type l,
size_type offset )
+ 		+inlinenoexcept
+
+ +

Definition at line 1439 of file xview.hpp.

+ +
+
+ +

◆ data_xend_impl()

+ +
+
+
+template<class CT, class... S>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + + + + + + +
It xt::xview< CT, S >::data_xend_impl (It begin,
layout_type l,
size_type offset ) const
+ 		+inlinenoexcept
+
+ +

Definition at line 1421 of file xview.hpp.

+ +
+
+ +

◆ element() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::element (It first,
It last ) -> reference +
+ 		+inline
+
+ +

Definition at line 1070 of file xview.hpp.

+ +
+
+ +

◆ element() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::element (It first,
It last ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 1123 of file xview.hpp.

+ +
+
+ +

◆ expression() [1/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::expression () const
+ 		+inlinenoexcept
+
+ +

Returns a const reference to the underlying expression of the view.

+ +

Definition at line 1143 of file xview.hpp.

+ +
+
+ +

◆ expression() [2/2]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::expression ()
+ 		+inlinenoexcept
+
+ +

Returns a reference to the underlying expression of the view.

+ +

Definition at line 1134 of file xview.hpp.

+ +
+
+ +

◆ fill()

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
void xt::xview< CT, S >::fill (const T & value)
+ 		+inline
+
+ +

Fills the view with the given value.

+
Parameters
+ + +
valuethe value to fill the view with.
+
+
+ +

Definition at line 1013 of file xview.hpp.

+ +
+
+ +

◆ flat() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::flat (size_type i) -> reference + requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Definition at line 1510 of file xview.hpp.

+ +
+
+ +

◆ flat() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::flat (size_type i) const -> const_reference + requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Definition at line 1519 of file xview.hpp.

+ +
+
+ +

◆ has_linear_assign()

+ +
+
+
+template<class CT, class... S>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
bool xt::xview< CT, S >::has_linear_assign (const ST & str) const
+ 		+inline
+
+ +

Checks whether the xview can be linearly assigned to an expression with the specified strides.

+
Returns
a boolean indicating whether a linear assign is possible
+ +

Definition at line 1398 of file xview.hpp.

+ +
+
+ +

◆ index()

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type I, class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::index (Args... args) const -> size_type +
+ 		+inline
+
+ +

Definition at line 1644 of file xview.hpp.

+ +
+
+ +

◆ is_contiguous()

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
bool xt::xview< CT, S >::is_contiguous () const
+ 		+inlinenoexcept
+
+ +

Definition at line 995 of file xview.hpp.

+ +
+
+ +

◆ layout()

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
layout_type xt::xview< CT, S >::layout () const
+ 		+inlinenoexcept
+
+ +

Returns the slices of the view.

+ +

Definition at line 974 of file xview.hpp.

+ +
+
+ +

◆ linear_begin() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_begin () -> linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1171 of file xview.hpp.

+ +
+
+ +

◆ linear_begin() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_begin () const -> const_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1187 of file xview.hpp.

+ +
+
+ +

◆ linear_cbegin()

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_cbegin () const -> const_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1203 of file xview.hpp.

+ +
+
+ +

◆ linear_cend()

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_cend () const -> const_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1211 of file xview.hpp.

+ +
+
+ +

◆ linear_crbegin()

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_crbegin () const -> const_reverse_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1251 of file xview.hpp.

+ +
+
+ +

◆ linear_crend()

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_crend () const -> const_reverse_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1259 of file xview.hpp.

+ +
+
+ +

◆ linear_end() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_end () -> linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1179 of file xview.hpp.

+ +
+
+ +

◆ linear_end() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_end () const -> const_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1195 of file xview.hpp.

+ +
+
+ +

◆ linear_rbegin() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_rbegin () -> reverse_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1219 of file xview.hpp.

+ +
+
+ +

◆ linear_rbegin() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_rbegin () const -> const_reverse_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1235 of file xview.hpp.

+ +
+
+ +

◆ linear_rend() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_rend () -> reverse_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1227 of file xview.hpp.

+ +
+
+ +

◆ linear_rend() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + + + +
auto xt::xview< CT, S >::linear_rend () const -> const_reverse_linear_iterator + requires(has_data_interface_concept<T> and strided_view_concept<CT, S...>) +
+
+ +

Definition at line 1243 of file xview.hpp.

+ +
+
+ +

◆ load_simd()

+ +
+
+
+template<class CT, class... S>
+
+template<class align, class requested_type, std::size_t N, class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::load_simd (size_type i) const -> simd_return_type<requested_type> + requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Definition at line 1486 of file xview.hpp.

+ +
+
+ +

◆ make_index()

+ +
+
+
+template<class CT, class... S>
+
+template<class It>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::make_index (It first,
It last ) const -> base_index_type +
+ 		+inline
+
+ +

Definition at line 1686 of file xview.hpp.

+ +
+
+ +

◆ operator const_reference()

+ +
+
+
+template<class CT, class... S>
+
+template<xscalar_concept ST = self_type>
+ + + + + +
+ + + + + + + +
xt::xview< CT, S >::operator const_reference () const
+ 		+inline
+
+ +

Definition at line 606 of file xview.hpp.

+ +
+
+ +

◆ operator reference()

+ +
+
+
+template<class CT, class... S>
+
+template<xscalar_concept ST = self_type>
+ + + + + +
+ + + + + + + +
xt::xview< CT, S >::operator reference ()
+ 		+inline
+
+ +

Definition at line 600 of file xview.hpp.

+ +
+
+ +

◆ operator&() [1/3]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator& () &
+ 		+inline
+
+ +

Definition at line 1357 of file xview.hpp.

+ +
+
+ +

◆ operator&() [2/3]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator& () &&
+ 		+inline
+
+ +

Definition at line 1369 of file xview.hpp.

+ +
+
+ +

◆ operator&() [3/3]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator& () const &
+ 		+inline
+
+ +

Definition at line 1363 of file xview.hpp.

+ +
+
+ +

◆ operator()() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator() (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the view.
+
+
+ +

Definition at line 1033 of file xview.hpp.

+ +
+
+ +

◆ operator()() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator() (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices should be equal or greater than the number of dimensions of the view.
+
+
+ +

Definition at line 1086 of file xview.hpp.

+ +
+
+ +

◆ operator=() [1/3]

+ +
+
+
+template<class CT, class... S>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator= (const E & e) -> disable_xexpression<E, self_type>& +
+ 		+inline
+
+ +

Definition at line 942 of file xview.hpp.

+ +
+
+ +

◆ operator=() [2/3]

+ +
+
+
+template<class CT, class... S>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator= (const xexpression< E > & e) -> self_type& +
+ 		+inline
+
+ +

The extended assignment operator.

+ +

Definition at line 933 of file xview.hpp.

+ +
+
+ +

◆ operator=() [3/3]

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::operator= (const xview< CT, S > & rhs)
+ 		+inline
+
+ +

Definition at line 918 of file xview.hpp.

+ +
+
+ +

◆ shape()

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::shape () const
+ 		+inlinenoexcept
+
+ +

Returns the shape of the view.

+ +

Definition at line 956 of file xview.hpp.

+ +
+
+ +

◆ sliced_access() [1/3]

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type I, class T, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::sliced_access (const T & squeeze,
Args...  ) const -> size_type + requires(!is_xslice<T>::value) +
+ 		+inline
+
+ +

Definition at line 1678 of file xview.hpp.

+ +
+
+ +

◆ sliced_access() [2/3]

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type I, class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::sliced_access (const xslice< T > & slice) const -> size_type +
+ 		+inline
+
+ +

Definition at line 1661 of file xview.hpp.

+ +
+
+ +

◆ sliced_access() [3/3]

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type I, class T, class Arg, class... Args>
+ + + + + +
+ + + + + + + + + + + + + + + + +
auto xt::xview< CT, S >::sliced_access (const xslice< T > & slice,
Arg arg,
Args... args ) const -> size_type +
+ 		+inline
+
+ +

Definition at line 1668 of file xview.hpp.

+ +
+
+ +

◆ slices()

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::slices () const
+ 		+inlinenoexcept
+
+ +

Returns the slices of the view.

+ +

Definition at line 965 of file xview.hpp.

+ +
+
+ +

◆ stepper_begin() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::stepper_begin (const ST & shape) -> stepper +
+ 		+inline
+
+ +

Definition at line 1937 of file xview.hpp.

+ +
+
+ +

◆ stepper_begin() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class ST>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::stepper_begin (const ST & shape) const -> const_stepper +
+ 		+inline
+
+ +

Definition at line 1967 of file xview.hpp.

+ +
+
+ +

◆ stepper_end() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::stepper_end (const ST & shape,
layout_type l ) -> stepper +
+ 		+inline
+
+ +

Definition at line 1952 of file xview.hpp.

+ +
+
+ +

◆ stepper_end() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class ST>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::stepper_end (const ST & shape,
layout_type l ) const -> const_stepper +
+ 		+inline
+
+ +

Definition at line 1983 of file xview.hpp.

+ +
+
+ +

◆ storage() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::storage () -> storage_type& + requires(has_data_interface_concept<T>) +
+ 		+inline
+
+ +

Returns the data holder of the underlying container (only if the view is on a realized container).

+

xt::eval will make sure that the underlying xexpression is on a realized container.

+ +

Definition at line 1155 of file xview.hpp.

+ +
+
+ +

◆ storage() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::storage () const -> const storage_type& + requires(has_data_interface_concept<T>) +
+ 		+inline
+
+ +

Definition at line 1163 of file xview.hpp.

+ +
+
+ +

◆ store_simd()

+ +
+
+
+template<class CT, class... S>
+
+template<class align, class simd, class T>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::store_simd (size_type i,
const simd & e ) -> void + requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>) +
+ 		+inline
+
+ +

Definition at line 1478 of file xview.hpp.

+ +
+
+ +

◆ strides()

+ +
+
+
+template<class CT, class... S>
+
+template<class T>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::strides () const -> const inner_strides_type& requires(has_data_interface_concept<T>and strided_view_concept<CT, S...>)
+ 		+inline
+
+ +

Return the strides for the underlying container of the view.

+ +

Definition at line 1270 of file xview.hpp.

+ +
+
+ +

◆ unchecked() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::unchecked (Args... args) -> reference +
+ 		+inline
+
+ +

Returns a reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the view, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.unchecked(0, 1);
+
xt::xarray
xarray_container< uvector< T, A >, L, xt::svector< typename uvector< T, A >::size_type, 4, SA, true > > xarray
Alias template on xarray_container with default parameters for data container type and shape / stride...
Definition xtensor_forward.hpp:82
+
+ +

Definition at line 1063 of file xview.hpp.

+ +
+
+ +

◆ unchecked() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<class... Args>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::unchecked (Args... args) const -> const_reference +
+ 		+inline
+
+ +

Returns a constant reference to the element at the specified position in the view.

+
Parameters
+ + +
argsa list of indices specifying the position in the view. Indices must be unsigned integers, the number of indices must be equal to the number of dimensions of the view, else the behavior is undefined.
+
+
+
Warning
This method is meant for performance, for expressions with a dynamic number of dimensions (i.e. not known at compile time). Since it may have undefined behavior (see parameters), operator() should be preferred whenever it is possible.
+
+This method is NOT compatible with broadcasting, meaning the following code has undefined behavior:
xt::xarray<double> a = {{0, 1}, {2, 3}};
+
xt::xarray<double> b = {0, 1};
+
auto fd = a + b;
+
double res = fd.unchecked(0, 1);
+
+ +

Definition at line 1116 of file xview.hpp.

+ +
+
+ +

◆ unchecked_impl() [1/2]

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type... I, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::unchecked_impl (std::index_sequence< I... > ,
Args... args ) -> reference +
+ 		+inline
+
+ +

Definition at line 1615 of file xview.hpp.

+ +
+
+ +

◆ unchecked_impl() [2/2]

+ +
+
+
+template<class CT, class... S>
+
+template<typename std::decay_t< CT >::size_type... I, class... Args>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview< CT, S >::unchecked_impl (std::index_sequence< I... > ,
Args... args ) const -> const_reference +
+ 		+inline
+
+ +

Definition at line 1622 of file xview.hpp.

+ +
+
+ +

◆ underlying_size()

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview< CT, S >::underlying_size (size_type dim) const
+ 		+inline
+
+ +

Definition at line 1351 of file xview.hpp.

+ +
+
+

Friends And Related Symbol Documentation

+ +

◆ xview_semantic< xview< CT, S... > >

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
friend class xview_semantic< xview< CT, S... > >
+ 		+friend
+
+ +

Definition at line 743 of file xview.hpp.

+ +
+
+

Member Data Documentation

+ +

◆ contiguous_layout

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
bool xt::xview< CT, S >::contiguous_layout = static_layout != layout_type::dynamic
+ 		+staticconstexpr
+
+ +

Definition at line 391 of file xview.hpp.

+ +
+
+ +

◆ has_trivial_strides

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
bool xt::xview< CT, S >::has_trivial_strides
+ 		+staticconstexpr
+
+Initial value:
= is_contiguous_view
+
&& !std::disjunction<detail::is_xrange<S>...>::value
+
+

Definition at line 412 of file xview.hpp.

+ +
+
+ +

◆ is_const

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
bool xt::xview< CT, S >::is_const = std::is_const<std::remove_reference_t<CT>>::value
+ 		+staticconstexpr
+
+ +

Definition at line 378 of file xview.hpp.

+ +
+
+ +

◆ is_contiguous_view

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
bool xt::xview< CT, S >::is_contiguous_view = contiguous_layout
+ 		+staticconstexpr
+
+ +

Definition at line 394 of file xview.hpp.

+ +
+
+ +

◆ is_strided_view

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
bool xt::xview< CT, S >::is_strided_view = detail::is_strided_view<xexpression_type, S...>::value
+ 		+staticconstexpr
+
+ +

Definition at line 393 of file xview.hpp.

+ +
+
+ +

◆ rank

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
std::size_t xt::xview< CT, S >::rank = SIZE_MAX
+ 		+staticconstexpr
+
+ +

Definition at line 453 of file xview.hpp.

+ +
+
+ +

◆ static_layout

+ +
+
+
+template<class CT, class... S>
+ + + + + +
+ + + + +
layout_type xt::xview< CT, S >::static_layout = inner_types::layout
+ 		+staticconstexpr
+
+ +

Definition at line 390 of file xview.hpp.

+ +
+
+
The documentation for this class was generated from the following files:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xtensor_forward.hpp
    • +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xview.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xview.js b/classxt_1_1xview.js new file mode 100644 index 000000000..8e04b59cf --- /dev/null +++ b/classxt_1_1xview.js @@ -0,0 +1,21 @@ +var classxt_1_1xview = +[ + [ "xview", "classxt_1_1xview.html#a05ff5fb7b81610a17123a91729525c5c", null ], + [ "broadcast_shape", "classxt_1_1xview.html#a4fb1f607e8b93152ef8426c5ef524c3e", null ], + [ "data", "classxt_1_1xview.html#a2315b4504cabd5c6a0c6f80c782d1d8b", null ], + [ "data_offset", "classxt_1_1xview.html#a869e2398c747ba94deaf0878bb348649", null ], + [ "expression", "classxt_1_1xview.html#a9c5da820e15f25932c740862e0f3150f", null ], + [ "expression", "classxt_1_1xview.html#a5ecd9f1273f10421fdd4c5d64c262585", null ], + [ "fill", "classxt_1_1xview.html#a76141e6f7f637ae7e070d860a08fc678", null ], + [ "has_linear_assign", "classxt_1_1xview.html#a1249c703f1c218ce7998627aa91c10a6", null ], + [ "layout", "classxt_1_1xview.html#aface2a61c07630c793d71241d13de29d", null ], + [ "operator()", "classxt_1_1xview.html#a16ffe8d0c8b973c2fa28e75c2f353437", null ], + [ "operator()", "classxt_1_1xview.html#a9bfc52bb7a7844eb976a096875d6a5a6", null ], + [ "operator=", "classxt_1_1xview.html#af7f042302a75ce76b1ce094b38529188", null ], + [ "shape", "classxt_1_1xview.html#a4f26067384dd1d379fcd476127386966", null ], + [ "slices", "classxt_1_1xview.html#a10687f1d5229c3d4f0b0af8766d9d64b", null ], + [ "storage", "classxt_1_1xview.html#a7ed8a9e636959290636894572d1d2282", null ], + [ "strides", "classxt_1_1xview.html#a806d78f80c3cbf6624009bcb66a2ee5f", null ], + [ "unchecked", "classxt_1_1xview.html#afc28e491c5db09bcfe54e5eea176a5ec", null ], + [ "unchecked", "classxt_1_1xview.html#a8860cdb3a358dfee3af68fafdb5c7010", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xview.png b/classxt_1_1xview.png new file mode 100644 index 000000000..fce18655f Binary files /dev/null and b/classxt_1_1xview.png differ diff --git a/classxt_1_1xview__semantic-members.html b/classxt_1_1xview__semantic-members.html new file mode 100644 index 000000000..75718859b --- /dev/null +++ b/classxt_1_1xview__semantic-members.html @@ -0,0 +1,194 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xview_semantic< D > Member List
+
+
+ +

This is the complete list of members for xt::xview_semantic< D >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
assign_temporary(temporary_type &&)xt::xview_semantic< D >inline
assign_xexpression(const xexpression< E > &e) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
assign_xexpression(const xexpression< E > &e) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
base_type typedef (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
bit_and_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_and_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_or_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_or_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
bit_xor_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
bit_xor_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
computed_assign(const xexpression< E > &e) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
computed_assign(const xexpression< E > &e) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
derived_type typedef (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
divides_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
divides_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
minus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
minus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
modulus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
modulus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
multiplies_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
multiplies_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator%=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator%=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator%=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator&=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator&=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator&=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator*=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator*=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator*=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator+=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator+=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator+=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator-=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator-=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator-=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator/=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator/=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator/=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator=(const xview_semantic &)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
operator=(xview_semantic &&)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
operator=(const xexpression< E > &) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
operator=(const xexpression< E > &rhs) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
operator=(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator=(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
operator^=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator^=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator^=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
operator|=(const E &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
operator|=(const E &e) -> disable_xexpression< E, derived_type & >xt::xsemantic_base< D >inline
operator|=(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
plus_assign(const xexpression< E > &) (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >
plus_assign(const xexpression< E > &e) -> derived_type &xt::xsemantic_base< D >inline
scalar_computed_assign(const E &e, F &&f) (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
scalar_computed_assign(const E &e, F &&f) -> derived_type & (defined in xt::xview_semantic< D >)xt::xview_semantic< D >inline
temporary_type typedef (defined in xt::xview_semantic< D >)xt::xview_semantic< D >
xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(const xsemantic_base &)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xsemantic_base(xsemantic_base &&)=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
xview_semantic()=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic(const xview_semantic &)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
xview_semantic(xview_semantic &&)=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
~xsemantic_base()=default (defined in xt::xsemantic_base< D >)xt::xsemantic_base< D >protected
~xview_semantic()=default (defined in xt::xview_semantic< D >)xt::xview_semantic< D >protected
+
+ + + + diff --git a/classxt_1_1xview__semantic.html b/classxt_1_1xview__semantic.html new file mode 100644 index 000000000..95c311e58 --- /dev/null +++ b/classxt_1_1xview__semantic.html @@ -0,0 +1,696 @@ + + + + + + + +xtensor: xt::xview_semantic< D > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +Public Member Functions | +Protected Member Functions | +List of all members
+
xt::xview_semantic< D > Class Template Reference
+
+
+ +

Implementation of the xsemantic_base interface for multidimensional views. + More...

+ +

#include <xsemantic.hpp>

+
+Inheritance diagram for xt::xview_semantic< D >:
+
+
+ + +xt::xsemantic_base< D > +xt::xdynamic_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xdynamic_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xdynamic_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xdynamic_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xdynamic_view< CT, S, L, FST > +xt::xdynamic_view< E, S, L, typename FST::template rebind_t< E > > +xt::xfunctor_view< F, uvt > +xt::xfunctor_view< F, ucvt > +xt::xfunctor_view< F, E > +xt::xindex_view< uvt, I > +xt::xindex_view< uft, I > +xt::xindex_view< ucvt, I > +xt::xindex_view< ucft, I > +xt::xindex_view< E, I > +xt::xstrided_view< uvt, S, L, typename FST::template rebind_t< uvt > > +xt::xstrided_view< uft, S, L, typename FST::template rebind_t< uft > > +xt::xstrided_view< ucvt, S, L, typename FST::template rebind_t< ucvt > > +xt::xstrided_view< ucft, S, L, typename FST::template rebind_t< ucft > > +xt::xstrided_view< CT, shape_type > +xt::xstrided_view< CT, S, L, FST > +xt::xstrided_view< E, S, L, typename FST::template rebind_t< E > > +xt::xtensor_view< EC, N, L, xoptional_expression_tag > +xt::xview< uvt, S... > +xt::xview< uft, S... > +xt::xview< ucvt, S... > +xt::xview< ucft, S... > +xt::xview< UnderlyingContainer, Slices... > +xt::xview< E, S... > +xt::xdynamic_view< CT, S, L, FST > +xt::xstrided_view< CT, S, L, FST > + +
+ + + + + + + + + + + + + + + +

+Public Types

using base_type = xsemantic_base<D>
 
using derived_type = D
 
using temporary_type = typename base_type::temporary_type
 
- Public Types inherited from xt::xsemantic_base< D >
using base_type = select_expression_base_t<D>
 
using derived_type = typename base_type::derived_type
 
using temporary_type = typename xcontainer_inner_types<D>::temporary_type
 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions

+template<class E>
derived_type & assign_xexpression (const xexpression< E > &e)
 
+template<class E>
derived_type & computed_assign (const xexpression< E > &e)
 
+template<class E, class F>
derived_type & scalar_computed_assign (const E &e, F &&f)
 
Assign functions
derived_type & assign_temporary (temporary_type &&)
 Assigns the temporary tmp to *this.
 
template<class E>
auto assign_xexpression (const xexpression< E > &e) -> derived_type &
 
template<class E>
auto computed_assign (const xexpression< E > &e) -> derived_type &
 
template<class E, class F>
auto scalar_computed_assign (const E &e, F &&f) -> derived_type &
 
template<class E>
auto operator= (const xexpression< E > &rhs) -> derived_type &
 
- Public Member Functions inherited from xt::xsemantic_base< D >
+template<class E>
disable_xexpression< E, derived_type & > operator+= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator-= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator*= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator/= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator%= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator&= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator|= (const E &)
 
+template<class E>
disable_xexpression< E, derived_type & > operator^= (const E &)
 
+template<class E>
derived_type & operator+= (const xexpression< E > &)
 
+template<class E>
derived_type & operator-= (const xexpression< E > &)
 
+template<class E>
derived_type & operator*= (const xexpression< E > &)
 
+template<class E>
derived_type & operator/= (const xexpression< E > &)
 
+template<class E>
derived_type & operator%= (const xexpression< E > &)
 
+template<class E>
derived_type & operator&= (const xexpression< E > &)
 
+template<class E>
derived_type & operator|= (const xexpression< E > &)
 
+template<class E>
derived_type & operator^= (const xexpression< E > &)
 
+template<class E>
derived_type & assign (const xexpression< E > &)
 
+template<class E>
derived_type & plus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & minus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & multiplies_assign (const xexpression< E > &)
 
+template<class E>
derived_type & divides_assign (const xexpression< E > &)
 
+template<class E>
derived_type & modulus_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_and_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_or_assign (const xexpression< E > &)
 
+template<class E>
derived_type & bit_xor_assign (const xexpression< E > &)
 
template<class E>
auto operator+= (const E &e) -> disable_xexpression< E, derived_type & >
 Adds the scalar e to *this.
 
template<class E>
auto operator-= (const E &e) -> disable_xexpression< E, derived_type & >
 Subtracts the scalar e from *this.
 
template<class E>
auto operator*= (const E &e) -> disable_xexpression< E, derived_type & >
 Multiplies *this with the scalar e.
 
template<class E>
auto operator/= (const E &e) -> disable_xexpression< E, derived_type & >
 Divides *this by the scalar e.
 
template<class E>
auto operator%= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the remainder of *this after division by the scalar e.
 
template<class E>
auto operator&= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise and of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator|= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise or of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator^= (const E &e) -> disable_xexpression< E, derived_type & >
 Computes the bitwise xor of *this and the scalar e and assigns it to *this.
 
template<class E>
auto operator+= (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto operator-= (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e from *this.
 
template<class E>
auto operator*= (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto operator/= (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto operator%= (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto operator&= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator|= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto operator^= (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of *this and the xexpression e and assigns it to *this.
 
template<class E>
auto assign (const xexpression< E > &e) -> derived_type &
 Assigns the xexpression e to *this.
 
template<class E>
auto plus_assign (const xexpression< E > &e) -> derived_type &
 Adds the xexpression e to *this.
 
template<class E>
auto minus_assign (const xexpression< E > &e) -> derived_type &
 Subtracts the xexpression e to *this.
 
template<class E>
auto multiplies_assign (const xexpression< E > &e) -> derived_type &
 Multiplies *this with the xexpression e.
 
template<class E>
auto divides_assign (const xexpression< E > &e) -> derived_type &
 Divides *this by the xexpression e.
 
template<class E>
auto modulus_assign (const xexpression< E > &e) -> derived_type &
 Computes the remainder of *this after division by the xexpression e.
 
template<class E>
auto bit_and_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise and of e to *this.
 
template<class E>
auto bit_or_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise or of e to *this.
 
template<class E>
auto bit_xor_assign (const xexpression< E > &e) -> derived_type &
 Computes the bitwise xor of e to *this.
 
template<class E>
auto operator= (const xexpression< E > &e) -> derived_type &
 
+ + + + + + + + + + + + + + + + + + + + + + + + +

+Protected Member Functions

+ xview_semantic (const xview_semantic &)=default
 
+xview_semantic & operator= (const xview_semantic &)=default
 
+ xview_semantic (xview_semantic &&)=default
 
+xview_semantic & operator= (xview_semantic &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
- Protected Member Functions inherited from xt::xsemantic_base< D >
+ xsemantic_base (const xsemantic_base &)=default
 
+xsemantic_base & operator= (const xsemantic_base &)=default
 
+ xsemantic_base (xsemantic_base &&)=default
 
+xsemantic_base & operator= (xsemantic_base &&)=default
 
+template<class E>
derived_type & operator= (const xexpression< E > &)
 
+

Detailed Description

+
template<class D>
+class xt::xview_semantic< D >

Implementation of the xsemantic_base interface for multidimensional views.

+

The xview_semantic is an implementation of the xsemantic_base interface for multidimensional views.

+
Template Parameters
+ + +
Dthe derived type
+
+
+ +

Definition at line 254 of file xsemantic.hpp.

+

Member Typedef Documentation

+ +

◆ base_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xview_semantic< D >::base_type = xsemantic_base<D>
+
+ +

Definition at line 258 of file xsemantic.hpp.

+ +
+
+ +

◆ derived_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xview_semantic< D >::derived_type = D
+
+ +

Definition at line 259 of file xsemantic.hpp.

+ +
+
+ +

◆ temporary_type

+ +
+
+
+template<class D>
+ + + + +
using xt::xview_semantic< D >::temporary_type = typename base_type::temporary_type
+
+ +

Definition at line 260 of file xsemantic.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ assign_temporary()

+ +
+
+
+template<class D>
+ + + + + +
+ + + + + + + +
auto xt::xview_semantic< D >::assign_temporary (temporary_type && tmp)
+ 		+inline
+
+ +

Assigns the temporary tmp to *this.

+
Parameters
+ + +
tmpthe temporary to assign.
+
+
+
Returns
a reference to *this.
+ +

Definition at line 698 of file xsemantic.hpp.

+ +
+
+ +

◆ assign_xexpression()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xview_semantic< D >::assign_xexpression (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 726 of file xsemantic.hpp.

+ +
+
+ +

◆ computed_assign()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xview_semantic< D >::computed_assign (const xexpression< E > & e) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 735 of file xsemantic.hpp.

+ +
+
+ +

◆ operator=()

+ +
+
+
+template<class D>
+
+template<class E>
+ + + + + +
+ + + + + + + +
auto xt::xview_semantic< D >::operator= (const xexpression< E > & rhs) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 775 of file xsemantic.hpp.

+ +
+
+ +

◆ scalar_computed_assign()

+ +
+
+
+template<class D>
+
+template<class E, class F>
+ + + + + +
+ + + + + + + + + + + +
auto xt::xview_semantic< D >::scalar_computed_assign (const E & e,
F && f ) -> derived_type& +
+ 		+inline
+
+ +

Definition at line 759 of file xsemantic.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/core/xsemantic.hpp
    • +
+
+
+ + + + diff --git a/classxt_1_1xview__semantic.js b/classxt_1_1xview__semantic.js new file mode 100644 index 000000000..51e5ada08 --- /dev/null +++ b/classxt_1_1xview__semantic.js @@ -0,0 +1,4 @@ +var classxt_1_1xview__semantic = +[ + [ "assign_temporary", "classxt_1_1xview__semantic.html#abaa88fce8540e36bf148047aa3110af9", null ] +]; \ No newline at end of file diff --git a/classxt_1_1xview__semantic.png b/classxt_1_1xview__semantic.png new file mode 100644 index 000000000..b00682907 Binary files /dev/null and b/classxt_1_1xview__semantic.png differ diff --git a/classxt_1_1xview__stepper-members.html b/classxt_1_1xview__stepper-members.html new file mode 100644 index 000000000..df260878e --- /dev/null +++ b/classxt_1_1xview__stepper-members.html @@ -0,0 +1,139 @@ + + + + + + + +xtensor: Member List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xview_stepper< is_const, CT, S > Member List
+
+
+ +

This is the complete list of members for xt::xview_stepper< is_const, CT, S >, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + +
difference_type typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
operator*() const (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
pointer typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
reference typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
reset(size_type dim) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
reset_back(size_type dim) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
shape_type typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
size_type typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
step(size_type dim) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
step(size_type dim, size_type n) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
step_back(size_type dim) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
step_back(size_type dim, size_type n) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
substepper_type typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
to_begin() (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
to_end(layout_type l) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
value_type typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
view_type typedef (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
xview_stepper()=default (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >
xview_stepper(view_type *view, substepper_type it, size_type offset, bool end=false, layout_type l=::xt::layout_type::row_major) (defined in xt::xview_stepper< is_const, CT, S >)xt::xview_stepper< is_const, CT, S >inline
+
+ + + + diff --git a/classxt_1_1xview__stepper.html b/classxt_1_1xview__stepper.html new file mode 100644 index 000000000..bcb1264a1 --- /dev/null +++ b/classxt_1_1xview__stepper.html @@ -0,0 +1,634 @@ + + + + + + + +xtensor: xt::xview_stepper< is_const, CT, S > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
+Public Types | +List of all members
+
xt::xview_stepper< is_const, CT, S > Class Template Reference
+
+
+ + + + + + + + + + + + + + + + + + +

+Public Types

using view_type = std::conditional_t<is_const, const xview<CT, S...>, xview<CT, S...>>
 
using substepper_type = get_stepper<view_type>
 
using value_type = typename substepper_type::value_type
 
using reference = typename substepper_type::reference
 
using pointer = typename substepper_type::pointer
 
using difference_type = typename substepper_type::difference_type
 
using size_type = typename view_type::size_type
 
using shape_type = typename substepper_type::shape_type
 
+ + + + + + + + + + + + + + + + + + + + + +

Broadcasting

 xview_stepper (view_type *view, substepper_type it, size_type offset, bool end=false, layout_type l=::xt::layout_type::row_major)
 
reference operator* () const
 
void step (size_type dim)
 
void step_back (size_type dim)
 
void step (size_type dim, size_type n)
 
void step_back (size_type dim, size_type n)
 
void reset (size_type dim)
 
void reset_back (size_type dim)
 
void to_begin ()
 
void to_end (layout_type l)
 
+

Detailed Description

+
template<bool is_const, class CT, class... S>
+class xt::xview_stepper< is_const, CT, S >
+

Definition at line 782 of file xview.hpp.

+

Member Typedef Documentation

+ +

◆ difference_type

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::difference_type = typename substepper_type::difference_type
+
+ +

Definition at line 792 of file xview.hpp.

+ +
+
+ +

◆ pointer

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::pointer = typename substepper_type::pointer
+
+ +

Definition at line 791 of file xview.hpp.

+ +
+
+ +

◆ reference

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::reference = typename substepper_type::reference
+
+ +

Definition at line 790 of file xview.hpp.

+ +
+
+ +

◆ shape_type

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::shape_type = typename substepper_type::shape_type
+
+ +

Definition at line 795 of file xview.hpp.

+ +
+
+ +

◆ size_type

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::size_type = typename view_type::size_type
+
+ +

Definition at line 793 of file xview.hpp.

+ +
+
+ +

◆ substepper_type

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::substepper_type = get_stepper<view_type>
+
+ +

Definition at line 787 of file xview.hpp.

+ +
+
+ +

◆ value_type

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::value_type = typename substepper_type::value_type
+
+ +

Definition at line 789 of file xview.hpp.

+ +
+
+ +

◆ view_type

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + +
using xt::xview_stepper< is_const, CT, S >::view_type = std::conditional_t<is_const, const xview<CT, S...>, xview<CT, S...>>
+
+ +

Definition at line 786 of file xview.hpp.

+ +
+
+

Constructor & Destructor Documentation

+ +

◆ xview_stepper()

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
xt::xview_stepper< is_const, CT, S >::xview_stepper (view_type * view,
substepper_type it,
size_type offset,
bool end = false,
layout_type l = ::xt::layout_type::row_major )
+ 		+inline
+
+ +

Definition at line 2002 of file xview.hpp.

+ +
+
+

Member Function Documentation

+ +

◆ operator*()

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + +
auto xt::xview_stepper< is_const, CT, S >::operator* () const
+ 		+inline
+
+ +

Definition at line 2037 of file xview.hpp.

+ +
+
+ +

◆ reset()

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + +
void xt::xview_stepper< is_const, CT, S >::reset (size_type dim)
+ 		+inline
+
+ +

Definition at line 2083 of file xview.hpp.

+ +
+
+ +

◆ reset_back()

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + +
void xt::xview_stepper< is_const, CT, S >::reset_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 2093 of file xview.hpp.

+ +
+
+ +

◆ step() [1/2]

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + +
void xt::xview_stepper< is_const, CT, S >::step (size_type dim)
+ 		+inline
+
+ +

Definition at line 2043 of file xview.hpp.

+ +
+
+ +

◆ step() [2/2]

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xview_stepper< is_const, CT, S >::step (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 2063 of file xview.hpp.

+ +
+
+ +

◆ step_back() [1/2]

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + +
void xt::xview_stepper< is_const, CT, S >::step_back (size_type dim)
+ 		+inline
+
+ +

Definition at line 2053 of file xview.hpp.

+ +
+
+ +

◆ step_back() [2/2]

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + + + + + +
void xt::xview_stepper< is_const, CT, S >::step_back (size_type dim,
size_type n )
+ 		+inline
+
+ +

Definition at line 2073 of file xview.hpp.

+ +
+
+ +

◆ to_begin()

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + +
void xt::xview_stepper< is_const, CT, S >::to_begin ()
+ 		+inline
+
+ +

Definition at line 2103 of file xview.hpp.

+ +
+
+ +

◆ to_end()

+ +
+
+
+template<bool is_const, class CT, class... S>
+ + + + + +
+ + + + + + + +
void xt::xview_stepper< is_const, CT, S >::to_end (layout_type l)
+ 		+inline
+
+ +

Definition at line 2110 of file xview.hpp.

+ +
+
+
The documentation for this class was generated from the following file:
    +
  • /home/runner/work/xtensor/xtensor/include/xtensor/views/xview.hpp
    • +
+
+
+ + + + diff --git a/classxt__simd_1_1aligned__allocator.html b/classxt__simd_1_1aligned__allocator.html new file mode 100644 index 000000000..79418170f --- /dev/null +++ b/classxt__simd_1_1aligned__allocator.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xt_simd::aligned_allocator< T, A > Class Template Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt_simd::aligned_allocator< T, A > Class Template Reference
+
+
+

Detailed Description

+
template<class T, std::size_t A>
+class xt_simd::aligned_allocator< T, A >
+

Definition at line 91 of file xtensor_simd.hpp.

+
The documentation for this class was generated from the following file: +
+
+ + + + diff --git a/clipboard.js b/clipboard.js new file mode 100644 index 000000000..9da9f3ca4 --- /dev/null +++ b/clipboard.js @@ -0,0 +1,61 @@ +/** + +The code below is based on the Doxygen Awesome project, see +https://github.com/jothepro/doxygen-awesome-css + +MIT License + +Copyright (c) 2021 - 2022 jothepro + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +*/ + +let clipboard_title = "Copy to clipboard" +let clipboard_icon = `` +let clipboard_successIcon = `` +let clipboard_successDuration = 1000 + +$(function() { + if(navigator.clipboard) { + const fragments = document.getElementsByClassName("fragment") + for(const fragment of fragments) { + const clipboard_div = document.createElement("div") + clipboard_div.classList.add("clipboard") + clipboard_div.innerHTML = clipboard_icon + clipboard_div.title = clipboard_title + $(clipboard_div).click(function() { + const content = this.parentNode.cloneNode(true) + // filter out line number and folded fragments from file listings + content.querySelectorAll(".lineno, .ttc, .foldclosed").forEach((node) => { node.remove() }) + let text = content.textContent + // remove trailing newlines and trailing spaces from empty lines + text = text.replace(/^\s*\n/gm,'\n').replace(/\n*$/,'') + navigator.clipboard.writeText(text); + this.classList.add("success") + this.innerHTML = clipboard_successIcon + window.setTimeout(() => { // switch back to normal icon after timeout + this.classList.remove("success") + this.innerHTML = clipboard_icon + }, clipboard_successDuration); + }) + fragment.insertBefore(clipboard_div, fragment.firstChild) + } + } +}) diff --git a/closed.png b/closed.png new file mode 100644 index 000000000..98cc2c909 Binary files /dev/null and b/closed.png differ diff --git a/cmake/FindTBB.cmake b/cmake/FindTBB.cmake deleted file mode 100644 index 0fafa84f7..000000000 --- a/cmake/FindTBB.cmake +++ /dev/null @@ -1,308 +0,0 @@ -# The MIT License (MIT) -# -# Copyright (c) 2015 Justus Calvin -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -# -# FindTBB -# ------- -# -# Find TBB include directories and libraries. -# -# Usage: -# -# find_package(TBB [major[.minor]] [EXACT] -# [QUIET] [REQUIRED] -# [[COMPONENTS] [components...]] -# [OPTIONAL_COMPONENTS components...]) -# -# where the allowed components are tbbmalloc and tbb_preview. Users may modify -# the behavior of this module with the following variables: -# -# * TBB_ROOT_DIR - The base directory the of TBB installation. -# * TBB_INCLUDE_DIR - The directory that contains the TBB headers files. -# * TBB_LIBRARY - The directory that contains the TBB library files. -# * TBB__LIBRARY - The path of the TBB the corresponding TBB library. -# These libraries, if specified, override the -# corresponding library search results, where -# may be tbb, tbb_debug, tbbmalloc, tbbmalloc_debug, -# tbb_preview, or tbb_preview_debug. -# * TBB_USE_DEBUG_BUILD - The debug version of tbb libraries, if present, will -# be used instead of the release version. -# -# Users may modify the behavior of this module with the following environment -# variables: -# -# * TBB_INSTALL_DIR -# * TBBROOT -# * LIBRARY_PATH -# -# This module will set the following variables: -# -# * TBB_FOUND - Set to false, or undefined, if we haven’t found, or -# don’t want to use TBB. -# * TBB__FOUND - If False, optional part of TBB sytem is -# not available. -# * TBB_VERSION - The full version string -# * TBB_VERSION_MAJOR - The major version -# * TBB_VERSION_MINOR - The minor version -# * TBB_INTERFACE_VERSION - The interface version number defined in -# tbb/tbb_stddef.h. -# * TBB__LIBRARY_RELEASE - The path of the TBB release version of -# , where may be tbb, tbb_debug, -# tbbmalloc, tbbmalloc_debug, tbb_preview, or -# tbb_preview_debug. -# * TBB__LIBRARY_DEGUG - The path of the TBB release version of -# , where may be tbb, tbb_debug, -# tbbmalloc, tbbmalloc_debug, tbb_preview, or -# tbb_preview_debug. -# -# The following varibles should be used to build and link with TBB: -# -# * TBB_INCLUDE_DIRS - The include directory for TBB. -# * TBB_LIBRARIES - The libraries to link against to use TBB. -# * TBB_LIBRARIES_RELEASE - The release libraries to link against to use TBB. -# * TBB_LIBRARIES_DEBUG - The debug libraries to link against to use TBB. -# * TBB_DEFINITIONS - Definitions to use when compiling code that uses -# TBB. -# * TBB_DEFINITIONS_RELEASE - Definitions to use when compiling release code that -# uses TBB. -# * TBB_DEFINITIONS_DEBUG - Definitions to use when compiling debug code that -# uses TBB. -# -# This module will also create the "tbb" target that may be used when building -# executables and libraries. - -include(FindPackageHandleStandardArgs) - -if(NOT TBB_FOUND) - - ################################## - # Check the build type - ################################## - - if(NOT DEFINED TBB_USE_DEBUG_BUILD) - if(CMAKE_BUILD_TYPE MATCHES "(Debug|DEBUG|debug|RelWithDebInfo|RELWITHDEBINFO|relwithdebinfo)") - set(TBB_BUILD_TYPE DEBUG) - else() - set(TBB_BUILD_TYPE RELEASE) - endif() - elseif(TBB_USE_DEBUG_BUILD) - set(TBB_BUILD_TYPE DEBUG) - else() - set(TBB_BUILD_TYPE RELEASE) - endif() - - ################################## - # Set the TBB search directories - ################################## - - # Define search paths based on user input and environment variables - set(TBB_SEARCH_DIR ${TBB_ROOT_DIR} $ENV{TBB_INSTALL_DIR} $ENV{TBBROOT}) - - # Define the search directories based on the current platform - if(CMAKE_SYSTEM_NAME STREQUAL "Windows") - set(TBB_DEFAULT_SEARCH_DIR "C:/Program Files/Intel/TBB" - "C:/Program Files (x86)/Intel/TBB") - - # Set the target architecture - if(CMAKE_SIZEOF_VOID_P EQUAL 8) - set(TBB_ARCHITECTURE "intel64") - else() - set(TBB_ARCHITECTURE "ia32") - endif() - - # Set the TBB search library path search suffix based on the version of VC - if(WINDOWS_STORE) - set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc11_ui") - elseif(MSVC14) - set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc14") - elseif(MSVC12) - set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc12") - elseif(MSVC11) - set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc11") - elseif(MSVC10) - set(TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc10") - endif() - - # Add the library path search suffix for the VC independent version of TBB - list(APPEND TBB_LIB_PATH_SUFFIX "lib/${TBB_ARCHITECTURE}/vc_mt") - - elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") - # OS X - set(TBB_DEFAULT_SEARCH_DIR "/opt/intel/tbb") - - # TODO: Check to see which C++ library is being used by the compiler. - if(NOT ${CMAKE_SYSTEM_VERSION} VERSION_LESS 13.0) - # The default C++ library on OS X 10.9 and later is libc++ - set(TBB_LIB_PATH_SUFFIX "lib/libc++" "lib") - else() - set(TBB_LIB_PATH_SUFFIX "lib") - endif() - elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") - # Linux - set(TBB_DEFAULT_SEARCH_DIR "/opt/intel/tbb") - - # TODO: Check compiler version to see the suffix should be /gcc4.1 or - # /gcc4.1. For now, assume that the compiler is more recent than - # gcc 4.4.x or later. - if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") - set(TBB_LIB_PATH_SUFFIX "lib/intel64/gcc4.4") - elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^i.86$") - set(TBB_LIB_PATH_SUFFIX "lib/ia32/gcc4.4") - endif() - endif() - - ################################## - # Find the TBB include dir - ################################## - - find_path(TBB_INCLUDE_DIRS tbb/tbb.h - HINTS ${TBB_INCLUDE_DIR} ${TBB_SEARCH_DIR} - PATHS ${TBB_DEFAULT_SEARCH_DIR} - PATH_SUFFIXES include) - - ################################## - # Set version strings - ################################## - - if(TBB_INCLUDE_DIRS) - if(EXISTS "${TBB_INCLUDE_DIRS}/tbb/version.h") - # since version 2021.1 - file(READ "${TBB_INCLUDE_DIRS}/oneapi/tbb/version.h" _tbb_version_file) - else() - file(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _tbb_version_file) - endif() - string(REGEX REPLACE ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1" - TBB_VERSION_MAJOR "${_tbb_version_file}") - string(REGEX REPLACE ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1" - TBB_VERSION_MINOR "${_tbb_version_file}") - string(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" - TBB_INTERFACE_VERSION "${_tbb_version_file}") - set(TBB_VERSION "${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR}") - endif() - - ################################## - # Find TBB components - ################################## - - if(TBB_VERSION VERSION_LESS 4.3) - set(TBB_SEARCH_COMPOMPONENTS tbb_preview tbbmalloc tbb) - else() - set(TBB_SEARCH_COMPOMPONENTS tbb_preview tbbmalloc_proxy tbbmalloc tbb) - endif() - - # Find each component - foreach(_comp ${TBB_SEARCH_COMPOMPONENTS}) - if(";${TBB_FIND_COMPONENTS};tbb;" MATCHES ";${_comp};") - - # Search for the libraries - find_library(TBB_${_comp}_LIBRARY_RELEASE ${_comp} - HINTS ${TBB_LIBRARY} ${TBB_SEARCH_DIR} - PATHS ${TBB_DEFAULT_SEARCH_DIR} ENV LIBRARY_PATH - PATH_SUFFIXES ${TBB_LIB_PATH_SUFFIX}) - - find_library(TBB_${_comp}_LIBRARY_DEBUG ${_comp}_debug - HINTS ${TBB_LIBRARY} ${TBB_SEARCH_DIR} - PATHS ${TBB_DEFAULT_SEARCH_DIR} ENV LIBRARY_PATH - PATH_SUFFIXES ${TBB_LIB_PATH_SUFFIX}) - - if(TBB_${_comp}_LIBRARY_DEBUG) - list(APPEND TBB_LIBRARIES_DEBUG "${TBB_${_comp}_LIBRARY_DEBUG}") - endif() - if(TBB_${_comp}_LIBRARY_RELEASE) - list(APPEND TBB_LIBRARIES_RELEASE "${TBB_${_comp}_LIBRARY_RELEASE}") - endif() - if(TBB_${_comp}_LIBRARY_${TBB_BUILD_TYPE} AND NOT TBB_${_comp}_LIBRARY) - set(TBB_${_comp}_LIBRARY "${TBB_${_comp}_LIBRARY_${TBB_BUILD_TYPE}}") - endif() - - if(TBB_${_comp}_LIBRARY AND EXISTS "${TBB_${_comp}_LIBRARY}") - set(TBB_${_comp}_FOUND TRUE) - else() - set(TBB_${_comp}_FOUND FALSE) - endif() - - # Mark internal variables as advanced - mark_as_advanced(TBB_${_comp}_LIBRARY_RELEASE) - mark_as_advanced(TBB_${_comp}_LIBRARY_DEBUG) - mark_as_advanced(TBB_${_comp}_LIBRARY) - - endif() - endforeach() - - ################################## - # Set compile flags and libraries - ################################## - - set(TBB_DEFINITIONS_RELEASE "") - set(TBB_DEFINITIONS_DEBUG "-DTBB_USE_DEBUG=1") - - if(TBB_LIBRARIES_${TBB_BUILD_TYPE}) - set(TBB_DEFINITIONS "${TBB_DEFINITIONS_${TBB_BUILD_TYPE}}") - set(TBB_LIBRARIES "${TBB_LIBRARIES_${TBB_BUILD_TYPE}}") - elseif(TBB_LIBRARIES_RELEASE) - set(TBB_DEFINITIONS "${TBB_DEFINITIONS_RELEASE}") - set(TBB_LIBRARIES "${TBB_LIBRARIES_RELEASE}") - elseif(TBB_LIBRARIES_DEBUG) - set(TBB_DEFINITIONS "${TBB_DEFINITIONS_DEBUG}") - set(TBB_LIBRARIES "${TBB_LIBRARIES_DEBUG}") - endif() - - find_package_handle_standard_args(TBB - REQUIRED_VARS TBB_INCLUDE_DIRS TBB_LIBRARIES - HANDLE_COMPONENTS - VERSION_VAR TBB_VERSION) - - ################################## - # Create targets - ################################## - - if(NOT CMAKE_VERSION VERSION_LESS 3.0 AND TBB_FOUND) - add_library(tbb SHARED IMPORTED) - set_target_properties(tbb PROPERTIES - INTERFACE_INCLUDE_DIRECTORIES ${TBB_INCLUDE_DIRS} - IMPORTED_LOCATION ${TBB_LIBRARIES}) - if(TBB_LIBRARIES_RELEASE AND TBB_LIBRARIES_DEBUG) - set_target_properties(tbb PROPERTIES - INTERFACE_COMPILE_DEFINITIONS "$<$,$>:TBB_USE_DEBUG=1>" - IMPORTED_LOCATION_DEBUG ${TBB_LIBRARIES_DEBUG} - IMPORTED_LOCATION_RELWITHDEBINFO ${TBB_LIBRARIES_DEBUG} - IMPORTED_LOCATION_RELEASE ${TBB_LIBRARIES_RELEASE} - IMPORTED_LOCATION_MINSIZEREL ${TBB_LIBRARIES_RELEASE} - ) - elseif(TBB_LIBRARIES_RELEASE) - set_target_properties(tbb PROPERTIES IMPORTED_LOCATION ${TBB_LIBRARIES_RELEASE}) - else() - set_target_properties(tbb PROPERTIES - INTERFACE_COMPILE_DEFINITIONS "${TBB_DEFINITIONS_DEBUG}" - IMPORTED_LOCATION ${TBB_LIBRARIES_DEBUG} - ) - endif() - endif() - - mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARIES) - - unset(TBB_ARCHITECTURE) - unset(TBB_BUILD_TYPE) - unset(TBB_LIB_PATH_SUFFIX) - unset(TBB_DEFAULT_SEARCH_DIR) - -endif() diff --git a/concepts.html b/concepts.html new file mode 100644 index 000000000..fc7c47280 --- /dev/null +++ b/concepts.html @@ -0,0 +1,140 @@ + + + + + + + +xtensor: Concepts + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Concepts
+
+
+
Here is a list of all documented concepts with brief descriptions:
+
[detail level 12]
+ + + + + + + + + + + + + + + + + + + +
 ▼NxtStandard mathematical functions for xexpressions
 Rxscalar_concept
 Rxexpression_concept
 Rfixed_shape_container_concept
 Rxgenerator_concept
 Rhas_simd_interface_concept
 Rhas_data_interface_concept
 Rhas_iterator_interface_concept
 Riterator_concept
 Rwith_memory_address_concept
 Rwithout_memory_address_concept
 Rxbroadcast_concept
 Rcontiguous_view_concept
 Rstrided_view_concept
 ▼Nxtl
 Rintegral_concept
 Rnon_integral_concept
 Rcomplex_concept
 Rpointer_concept
+
+
+
+ + + + diff --git a/concepts.js b/concepts.js new file mode 100644 index 000000000..5e625cee9 --- /dev/null +++ b/concepts.js @@ -0,0 +1,24 @@ +var concepts = +[ + [ "xt", "namespacext.html", [ + [ "xscalar_concept", "conceptxt_1_1xscalar__concept.html", null ], + [ "xexpression_concept", "conceptxt_1_1xexpression__concept.html", null ], + [ "fixed_shape_container_concept", "conceptxt_1_1fixed__shape__container__concept.html", null ], + [ "xgenerator_concept", "conceptxt_1_1xgenerator__concept.html", null ], + [ "has_simd_interface_concept", "conceptxt_1_1has__simd__interface__concept.html", null ], + [ "has_data_interface_concept", "conceptxt_1_1has__data__interface__concept.html", null ], + [ "has_iterator_interface_concept", "conceptxt_1_1has__iterator__interface__concept.html", null ], + [ "iterator_concept", "conceptxt_1_1iterator__concept.html", null ], + [ "with_memory_address_concept", "conceptxt_1_1with__memory__address__concept.html", null ], + [ "without_memory_address_concept", "conceptxt_1_1without__memory__address__concept.html", null ], + [ "xbroadcast_concept", "conceptxt_1_1xbroadcast__concept.html", null ], + [ "contiguous_view_concept", "conceptxt_1_1contiguous__view__concept.html", null ], + [ "strided_view_concept", "conceptxt_1_1strided__view__concept.html", null ] + ] ], + [ "xtl", null, [ + [ "integral_concept", "conceptxtl_1_1integral__concept.html", null ], + [ "non_integral_concept", "conceptxtl_1_1non__integral__concept.html", null ], + [ "complex_concept", "conceptxtl_1_1complex__concept.html", null ], + [ "pointer_concept", "conceptxtl_1_1pointer__concept.html", null ] + ] ] +]; \ No newline at end of file diff --git a/conceptxt_1_1contiguous__view__concept.html b/conceptxt_1_1contiguous__view__concept.html new file mode 100644 index 000000000..c546a792e --- /dev/null +++ b/conceptxt_1_1contiguous__view__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xt::contiguous_view_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::contiguous_view_concept Concept Reference
+
+
+

Concept definition

+
template<class E, class... S>
+
concept xt::contiguous_view_concept = detail::is_contiguous_view<E, S...>::value
+
xt::contiguous_view_concept
Definition xview.hpp:293
+

Detailed Description

+
+

Definition at line 293 of file xview.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1fixed__shape__container__concept.html b/conceptxt_1_1fixed__shape__container__concept.html new file mode 100644 index 000000000..625e7b668 --- /dev/null +++ b/conceptxt_1_1fixed__shape__container__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xt::fixed_shape_container_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::fixed_shape_container_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xt::fixed_shape_container_concept = detail::is_fixed<typename std::decay_t<T>::shape_type>::value
+
xt::fixed_shape_container_concept
Definition xshape.hpp:509
+

Detailed Description

+
+

Definition at line 509 of file xshape.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1has__data__interface__concept.html b/conceptxt_1_1has__data__interface__concept.html new file mode 100644 index 000000000..f1d965c7a --- /dev/null +++ b/conceptxt_1_1has__data__interface__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::has_data_interface_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::has_data_interface_concept Concept Reference
+
+
+

Concept definition

+
template<class E>
+
concept xt::has_data_interface_concept = has_data_interface<E>::value
+
xt::has_data_interface_concept
Definition xutils.hpp:572
+
xt::has_data_interface
Definition xutils.hpp:563
+

Detailed Description

+
+

Definition at line 572 of file xutils.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1has__iterator__interface__concept.html b/conceptxt_1_1has__iterator__interface__concept.html new file mode 100644 index 000000000..00bc47806 --- /dev/null +++ b/conceptxt_1_1has__iterator__interface__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::has_iterator_interface_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::has_iterator_interface_concept Concept Reference
+
+
+

Concept definition

+
template<class E>
+
concept xt::has_iterator_interface_concept = has_iterator_interface<E>::value
+
xt::has_iterator_interface_concept
Definition xutils.hpp:595
+
xt::has_iterator_interface
Definition xutils.hpp:586
+

Detailed Description

+
+

Definition at line 595 of file xutils.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1has__simd__interface__concept.html b/conceptxt_1_1has__simd__interface__concept.html new file mode 100644 index 000000000..fd39d16e3 --- /dev/null +++ b/conceptxt_1_1has__simd__interface__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::has_simd_interface_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::has_simd_interface_concept Concept Reference
+
+
+

Concept definition

+
template<class E>
+
concept xt::has_simd_interface_concept = has_simd_interface<E>::value
+
xt::has_simd_interface_concept
Definition xtensor_simd.hpp:273
+
xt::has_simd_interface
Definition xtensor_simd.hpp:269
+

Detailed Description

+
+

Definition at line 273 of file xtensor_simd.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1iterator__concept.html b/conceptxt_1_1iterator__concept.html new file mode 100644 index 000000000..c0df2b31c --- /dev/null +++ b/conceptxt_1_1iterator__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::iterator_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::iterator_concept Concept Reference
+
+
+

Concept definition

+
template<typename E>
+
concept xt::iterator_concept = is_iterator<E>::value
+
xt::iterator_concept
Definition xutils.hpp:616
+
xt::is_iterator
Definition xutils.hpp:603
+

Detailed Description

+
+

Definition at line 616 of file xutils.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1strided__view__concept.html b/conceptxt_1_1strided__view__concept.html new file mode 100644 index 000000000..8984fd0d3 --- /dev/null +++ b/conceptxt_1_1strided__view__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xt::strided_view_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::strided_view_concept Concept Reference
+
+
+

Concept definition

+
template<class E, class... S>
+
concept xt::strided_view_concept = detail::is_strided_view<std::decay_t<E>, S...>::value
+
xt::strided_view_concept
Definition xview.hpp:295
+

Detailed Description

+
+

Definition at line 295 of file xview.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1with__memory__address__concept.html b/conceptxt_1_1with__memory__address__concept.html new file mode 100644 index 000000000..345b1b970 --- /dev/null +++ b/conceptxt_1_1with__memory__address__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::with_memory_address_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::with_memory_address_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xt::with_memory_address_concept = has_memory_address<std::decay_t<T>>::value
+
xt::with_memory_address_concept
Definition xutils.hpp:805
+
xt::has_memory_address
Definition xutils.hpp:796
+

Detailed Description

+
+

Definition at line 805 of file xutils.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1without__memory__address__concept.html b/conceptxt_1_1without__memory__address__concept.html new file mode 100644 index 000000000..7a5bbd644 --- /dev/null +++ b/conceptxt_1_1without__memory__address__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::without_memory_address_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::without_memory_address_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xt::without_memory_address_concept = !has_memory_address<std::decay_t<T>>::value
+
xt::without_memory_address_concept
Definition xutils.hpp:807
+
xt::has_memory_address
Definition xutils.hpp:796
+

Detailed Description

+
+

Definition at line 807 of file xutils.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1xbroadcast__concept.html b/conceptxt_1_1xbroadcast__concept.html new file mode 100644 index 000000000..b9e54af00 --- /dev/null +++ b/conceptxt_1_1xbroadcast__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::xbroadcast_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xbroadcast_concept Concept Reference
+
+
+

Concept definition

+
template<class E>
+
concept xt::xbroadcast_concept = is_specialization_of<xbroadcast, E>::value
+
xt::xbroadcast_concept
Definition xbroadcast.hpp:74
+
xt::is_specialization_of
Definition xutils.hpp:126
+

Detailed Description

+
+

Definition at line 74 of file xbroadcast.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1xexpression__concept.html b/conceptxt_1_1xexpression__concept.html new file mode 100644 index 000000000..220ff5ea5 --- /dev/null +++ b/conceptxt_1_1xexpression__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xt::xexpression_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xexpression_concept Concept Reference
+
+
+

Concept definition

+
template<class E>
+
concept xt::xexpression_concept = is_xexpression<E>::value
+
xt::xexpression_concept
Definition xexpression.hpp:181
+

Detailed Description

+
+

Definition at line 181 of file xexpression.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1xgenerator__concept.html b/conceptxt_1_1xgenerator__concept.html new file mode 100644 index 000000000..6903aba93 --- /dev/null +++ b/conceptxt_1_1xgenerator__concept.html @@ -0,0 +1,126 @@ + + + + + + + +xtensor: xt::xgenerator_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xgenerator_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xt::xgenerator_concept = is_specialization_of<xgenerator, std::decay_t<T>>::value
+
xt::xgenerator_concept
Definition xgenerator.hpp:62
+
xt::is_specialization_of
Definition xutils.hpp:126
+

Detailed Description

+
+

Definition at line 62 of file xgenerator.hpp.

+
+
+ + + + diff --git a/conceptxt_1_1xscalar__concept.html b/conceptxt_1_1xscalar__concept.html new file mode 100644 index 000000000..789fa5846 --- /dev/null +++ b/conceptxt_1_1xscalar__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xt::xscalar_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xt::xscalar_concept Concept Reference
+
+
+

Concept definition

+
template<class E>
+
concept xt::xscalar_concept = is_xscalar<std::decay_t<E>>::value
+
xt::xscalar_concept
Definition xscalar.hpp:320
+

Detailed Description

+
+

Definition at line 320 of file xscalar.hpp.

+
+
+ + + + diff --git a/conceptxtl_1_1complex__concept.html b/conceptxtl_1_1complex__concept.html new file mode 100644 index 000000000..86bde089f --- /dev/null +++ b/conceptxtl_1_1complex__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xtl::complex_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xtl::complex_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xtl::complex_concept = xtl::is_complex<typename std::decay<T>::type::value_type>::value
+
xtl::complex_concept
Definition xtl_concepts.hpp:25
+

Detailed Description

+
+

Definition at line 25 of file xtl_concepts.hpp.

+
+
+ + + + diff --git a/conceptxtl_1_1integral__concept.html b/conceptxtl_1_1integral__concept.html new file mode 100644 index 000000000..ad2cee655 --- /dev/null +++ b/conceptxtl_1_1integral__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xtl::integral_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xtl::integral_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xtl::integral_concept = xtl::is_integral<T>::value
+
xtl::integral_concept
Definition xtl_concepts.hpp:19
+

Detailed Description

+
+

Definition at line 19 of file xtl_concepts.hpp.

+
+
+ + + + diff --git a/conceptxtl_1_1non__integral__concept.html b/conceptxtl_1_1non__integral__concept.html new file mode 100644 index 000000000..ddabee0b0 --- /dev/null +++ b/conceptxtl_1_1non__integral__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xtl::non_integral_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xtl::non_integral_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xtl::non_integral_concept = !xtl::is_integral<T>::value
+
xtl::non_integral_concept
Definition xtl_concepts.hpp:22
+

Detailed Description

+
+

Definition at line 22 of file xtl_concepts.hpp.

+
+
+ + + + diff --git a/conceptxtl_1_1pointer__concept.html b/conceptxtl_1_1pointer__concept.html new file mode 100644 index 000000000..fc8e19dab --- /dev/null +++ b/conceptxtl_1_1pointer__concept.html @@ -0,0 +1,125 @@ + + + + + + + +xtensor: xtl::pointer_concept Concept Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xtl::pointer_concept Concept Reference
+
+
+

Concept definition

+
template<typename T>
+
concept xtl::pointer_concept = std::is_pointer<T>::value
+
xtl::pointer_concept
Definition xtl_concepts.hpp:28
+

Detailed Description

+
+

Definition at line 28 of file xtl_concepts.hpp.

+
+
+ + + + diff --git a/cookie.js b/cookie.js new file mode 100644 index 000000000..53ad21d98 --- /dev/null +++ b/cookie.js @@ -0,0 +1,58 @@ +/*! + Cookie helper functions + Copyright (c) 2023 Dimitri van Heesch + Released under MIT license. +*/ +let Cookie = { + cookie_namespace: 'doxygen_', + + readSetting(cookie,defVal) { + if (window.chrome) { + const val = localStorage.getItem(this.cookie_namespace+cookie) || + sessionStorage.getItem(this.cookie_namespace+cookie); + if (val) return val; + } else { + let myCookie = this.cookie_namespace+cookie+"="; + if (document.cookie) { + const index = document.cookie.indexOf(myCookie); + if (index != -1) { + const valStart = index + myCookie.length; + let valEnd = document.cookie.indexOf(";", valStart); + if (valEnd == -1) { + valEnd = document.cookie.length; + } + return document.cookie.substring(valStart, valEnd); + } + } + } + return defVal; + }, + + writeSetting(cookie,val,days=10*365) { // default days='forever', 0=session cookie, -1=delete + if (window.chrome) { + if (days==0) { + sessionStorage.setItem(this.cookie_namespace+cookie,val); + } else { + localStorage.setItem(this.cookie_namespace+cookie,val); + } + } else { + let date = new Date(); + date.setTime(date.getTime()+(days*24*60*60*1000)); + const expiration = days!=0 ? "expires="+date.toGMTString()+";" : ""; + document.cookie = this.cookie_namespace + cookie + "=" + + val + "; SameSite=Lax;" + expiration + "path=/"; + } + }, + + eraseSetting(cookie) { + if (window.chrome) { + if (localStorage.getItem(this.cookie_namespace+cookie)) { + localStorage.removeItem(this.cookie_namespace+cookie); + } else if (sessionStorage.getItem(this.cookie_namespace+cookie)) { + sessionStorage.removeItem(this.cookie_namespace+cookie); + } + } else { + this.writeSetting(cookie,'',-1); + } + }, +} diff --git a/deprecated.html b/deprecated.html new file mode 100644 index 000000000..b69950336 --- /dev/null +++ b/deprecated.html @@ -0,0 +1,122 @@ + + + + + + + +xtensor: Deprecated List + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
Deprecated List
+
+
+
+
Member xt::reshape_view (E &&e, S &&shape, layout_type)
+
+
+
+
+
+ + + + diff --git a/dir_0d75396b9e02a3c29319113837a95cad.html b/dir_0d75396b9e02a3c29319113837a95cad.html new file mode 100644 index 000000000..024136c1a --- /dev/null +++ b/dir_0d75396b9e02a3c29319113837a95cad.html @@ -0,0 +1,132 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/reducers Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
reducers Directory Reference
+
+
+ + + + + + + + + + + + +

+Files

 xaccumulator.hpp
 
 xblockwise_reducer.hpp
 
 xblockwise_reducer_functors.hpp
 
 xnorm.hpp
 
 xreducer.hpp
 
+
+
+ + + + diff --git a/dir_0d75396b9e02a3c29319113837a95cad.js b/dir_0d75396b9e02a3c29319113837a95cad.js new file mode 100644 index 000000000..9d5d607cf --- /dev/null +++ b/dir_0d75396b9e02a3c29319113837a95cad.js @@ -0,0 +1,8 @@ +var dir_0d75396b9e02a3c29319113837a95cad = +[ + [ "xaccumulator.hpp", "xaccumulator_8hpp_source.html", null ], + [ "xblockwise_reducer.hpp", "xblockwise__reducer_8hpp_source.html", null ], + [ "xblockwise_reducer_functors.hpp", "xblockwise__reducer__functors_8hpp_source.html", null ], + [ "xnorm.hpp", "xnorm_8hpp_source.html", null ], + [ "xreducer.hpp", "xreducer_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_5dbc63e3e208067190e586da41725baf.html b/dir_5dbc63e3e208067190e586da41725baf.html new file mode 100644 index 000000000..e398b0d39 --- /dev/null +++ b/dir_5dbc63e3e208067190e586da41725baf.html @@ -0,0 +1,160 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/core Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
core Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

 xaccessible.hpp
 
 xassign.hpp
 
 xeval.hpp
 
 xexpression.hpp
 
 xexpression_traits.hpp
 
 xfunction.hpp
 
 xiterable.hpp
 
 xiterator.hpp
 
 xlayout.hpp
 
 xmath.hpp
 
 xmultiindex_iterator.hpp
 
 xnoalias.hpp
 
 xoperation.hpp
 
 xsemantic.hpp
 
 xshape.hpp
 
 xstrides.hpp
 
 xtensor_config.hpp
 
 xtensor_forward.hpp
 
 xvectorize.hpp
 
+
+
+ + + + diff --git a/dir_5dbc63e3e208067190e586da41725baf.js b/dir_5dbc63e3e208067190e586da41725baf.js new file mode 100644 index 000000000..741688a2e --- /dev/null +++ b/dir_5dbc63e3e208067190e586da41725baf.js @@ -0,0 +1,22 @@ +var dir_5dbc63e3e208067190e586da41725baf = +[ + [ "xaccessible.hpp", "xaccessible_8hpp_source.html", null ], + [ "xassign.hpp", "xassign_8hpp_source.html", null ], + [ "xeval.hpp", "xeval_8hpp_source.html", null ], + [ "xexpression.hpp", "xexpression_8hpp_source.html", null ], + [ "xexpression_traits.hpp", "xexpression__traits_8hpp_source.html", null ], + [ "xfunction.hpp", "xfunction_8hpp_source.html", null ], + [ "xiterable.hpp", "xiterable_8hpp_source.html", null ], + [ "xiterator.hpp", "xiterator_8hpp_source.html", null ], + [ "xlayout.hpp", "xlayout_8hpp_source.html", null ], + [ "xmath.hpp", "xmath_8hpp_source.html", null ], + [ "xmultiindex_iterator.hpp", "xmultiindex__iterator_8hpp_source.html", null ], + [ "xnoalias.hpp", "xnoalias_8hpp_source.html", null ], + [ "xoperation.hpp", "xoperation_8hpp_source.html", null ], + [ "xsemantic.hpp", "xsemantic_8hpp_source.html", null ], + [ "xshape.hpp", "xshape_8hpp_source.html", null ], + [ "xstrides.hpp", "xstrides_8hpp_source.html", null ], + [ "xtensor_config.hpp", "xtensor__config_8hpp_source.html", null ], + [ "xtensor_forward.hpp", "xtensor__forward_8hpp_source.html", null ], + [ "xvectorize.hpp", "xvectorize_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_72c9924f54f34c9a9a500349a94b928a.html b/dir_72c9924f54f34c9a9a500349a94b928a.html new file mode 100644 index 000000000..74053a25d --- /dev/null +++ b/dir_72c9924f54f34c9a9a500349a94b928a.html @@ -0,0 +1,128 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/generators Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
generators Directory Reference
+
+
+ + + + + + + + +

+Files

 xbuilder.hpp
 
 xgenerator.hpp
 
 xrandom.hpp
 
+
+
+ + + + diff --git a/dir_72c9924f54f34c9a9a500349a94b928a.js b/dir_72c9924f54f34c9a9a500349a94b928a.js new file mode 100644 index 000000000..7bc05f8c5 --- /dev/null +++ b/dir_72c9924f54f34c9a9a500349a94b928a.js @@ -0,0 +1,6 @@ +var dir_72c9924f54f34c9a9a500349a94b928a = +[ + [ "xbuilder.hpp", "xbuilder_8hpp_source.html", null ], + [ "xgenerator.hpp", "xgenerator_8hpp_source.html", null ], + [ "xrandom.hpp", "xrandom_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_7614d47be9b26b68b6e19faab3d8cf3d.html b/dir_7614d47be9b26b68b6e19faab3d8cf3d.html new file mode 100644 index 000000000..4e38fc7b9 --- /dev/null +++ b/dir_7614d47be9b26b68b6e19faab3d8cf3d.html @@ -0,0 +1,130 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/optional Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
optional Directory Reference
+
+
+ + + + + + + + + + +

+Files

 xoptional.hpp
 
 xoptional_assembly.hpp
 
 xoptional_assembly_base.hpp
 
 xoptional_assembly_storage.hpp
 
+
+
+ + + + diff --git a/dir_7614d47be9b26b68b6e19faab3d8cf3d.js b/dir_7614d47be9b26b68b6e19faab3d8cf3d.js new file mode 100644 index 000000000..b355d8b17 --- /dev/null +++ b/dir_7614d47be9b26b68b6e19faab3d8cf3d.js @@ -0,0 +1,7 @@ +var dir_7614d47be9b26b68b6e19faab3d8cf3d = +[ + [ "xoptional.hpp", "xoptional_8hpp_source.html", null ], + [ "xoptional_assembly.hpp", "xoptional__assembly_8hpp_source.html", null ], + [ "xoptional_assembly_base.hpp", "xoptional__assembly__base_8hpp_source.html", null ], + [ "xoptional_assembly_storage.hpp", "xoptional__assembly__storage_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_8a589290beb6e41d95922675c5a252d5.html b/dir_8a589290beb6e41d95922675c5a252d5.html new file mode 100644 index 000000000..ecfcefc29 --- /dev/null +++ b/dir_8a589290beb6e41d95922675c5a252d5.html @@ -0,0 +1,134 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/io Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
io Directory Reference
+
+
+ + + + + + + + + + + + + + +

+Files

 xcsv.hpp
 
 xinfo.hpp
 
 xio.hpp
 
 xjson.hpp
 
 xmime.hpp
 
 xnpy.hpp
 
+
+
+ + + + diff --git a/dir_8a589290beb6e41d95922675c5a252d5.js b/dir_8a589290beb6e41d95922675c5a252d5.js new file mode 100644 index 000000000..b727b2833 --- /dev/null +++ b/dir_8a589290beb6e41d95922675c5a252d5.js @@ -0,0 +1,9 @@ +var dir_8a589290beb6e41d95922675c5a252d5 = +[ + [ "xcsv.hpp", "xcsv_8hpp_source.html", null ], + [ "xinfo.hpp", "xinfo_8hpp_source.html", null ], + [ "xio.hpp", "xio_8hpp_source.html", null ], + [ "xjson.hpp", "xjson_8hpp_source.html", null ], + [ "xmime.hpp", "xmime_8hpp_source.html", null ], + [ "xnpy.hpp", "xnpy_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_a756a6382b5a8aa8dbc0087dac27d23d.html b/dir_a756a6382b5a8aa8dbc0087dac27d23d.html new file mode 100644 index 000000000..4dbb9b170 --- /dev/null +++ b/dir_a756a6382b5a8aa8dbc0087dac27d23d.html @@ -0,0 +1,152 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/views Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
views Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Files

 index_mapper.hpp
 
 xaxis_iterator.hpp
 
 xaxis_slice_iterator.hpp
 
 xbroadcast.hpp
 
 xdynamic_view.hpp
 
 xfunctor_view.hpp
 
 xindex_view.hpp
 
 xmasked_view.hpp
 
 xoffset_view.hpp
 
 xrepeat.hpp
 
 xslice.hpp
 
 xstrided_view.hpp
 
 xstrided_view_base.hpp
 
 xview.hpp
 
 xview_utils.hpp
 
+
+
+ + + + diff --git a/dir_a756a6382b5a8aa8dbc0087dac27d23d.js b/dir_a756a6382b5a8aa8dbc0087dac27d23d.js new file mode 100644 index 000000000..de3906b45 --- /dev/null +++ b/dir_a756a6382b5a8aa8dbc0087dac27d23d.js @@ -0,0 +1,18 @@ +var dir_a756a6382b5a8aa8dbc0087dac27d23d = +[ + [ "index_mapper.hpp", "index__mapper_8hpp_source.html", null ], + [ "xaxis_iterator.hpp", "xaxis__iterator_8hpp_source.html", null ], + [ "xaxis_slice_iterator.hpp", "xaxis__slice__iterator_8hpp_source.html", null ], + [ "xbroadcast.hpp", "xbroadcast_8hpp_source.html", null ], + [ "xdynamic_view.hpp", "xdynamic__view_8hpp_source.html", null ], + [ "xfunctor_view.hpp", "xfunctor__view_8hpp_source.html", null ], + [ "xindex_view.hpp", "xindex__view_8hpp_source.html", null ], + [ "xmasked_view.hpp", "xmasked__view_8hpp_source.html", null ], + [ "xoffset_view.hpp", "xoffset__view_8hpp_source.html", null ], + [ "xrepeat.hpp", "xrepeat_8hpp_source.html", null ], + [ "xslice.hpp", "xslice_8hpp_source.html", null ], + [ "xstrided_view.hpp", "xstrided__view_8hpp_source.html", null ], + [ "xstrided_view_base.hpp", "xstrided__view__base_8hpp_source.html", null ], + [ "xview.hpp", "xview_8hpp_source.html", null ], + [ "xview_utils.hpp", "xview__utils_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_c04393294c6204f6f7005e440fd4c48c.html b/dir_c04393294c6204f6f7005e440fd4c48c.html new file mode 100644 index 000000000..9eb2cb749 --- /dev/null +++ b/dir_c04393294c6204f6f7005e440fd4c48c.html @@ -0,0 +1,138 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/containers Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
containers Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + +

+Files

 xadapt.hpp
 
 xarray.hpp
 
 xbuffer_adaptor.hpp
 
 xcontainer.hpp
 
 xfixed.hpp
 
 xscalar.hpp
 
 xstorage.hpp
 
 xtensor.hpp
 
+
+
+ + + + diff --git a/dir_c04393294c6204f6f7005e440fd4c48c.js b/dir_c04393294c6204f6f7005e440fd4c48c.js new file mode 100644 index 000000000..c1267f7fc --- /dev/null +++ b/dir_c04393294c6204f6f7005e440fd4c48c.js @@ -0,0 +1,11 @@ +var dir_c04393294c6204f6f7005e440fd4c48c = +[ + [ "xadapt.hpp", "xadapt_8hpp_source.html", null ], + [ "xarray.hpp", "xarray_8hpp_source.html", null ], + [ "xbuffer_adaptor.hpp", "xbuffer__adaptor_8hpp_source.html", null ], + [ "xcontainer.hpp", "xcontainer_8hpp_source.html", null ], + [ "xfixed.hpp", "xfixed_8hpp_source.html", null ], + [ "xscalar.hpp", "xscalar_8hpp_source.html", null ], + [ "xstorage.hpp", "xstorage_8hpp_source.html", null ], + [ "xtensor.hpp", "xtensor_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_c7391fa963006b3dcc74b1e23f2b5aa5.html b/dir_c7391fa963006b3dcc74b1e23f2b5aa5.html new file mode 100644 index 000000000..ef37db003 --- /dev/null +++ b/dir_c7391fa963006b3dcc74b1e23f2b5aa5.html @@ -0,0 +1,128 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/utils Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
utils Directory Reference
+
+
+ + + + + + + + +

+Files

 xexception.hpp
 
 xtensor_simd.hpp
 
 xutils.hpp
 
+
+
+ + + + diff --git a/dir_c7391fa963006b3dcc74b1e23f2b5aa5.js b/dir_c7391fa963006b3dcc74b1e23f2b5aa5.js new file mode 100644 index 000000000..18325924b --- /dev/null +++ b/dir_c7391fa963006b3dcc74b1e23f2b5aa5.js @@ -0,0 +1,6 @@ +var dir_c7391fa963006b3dcc74b1e23f2b5aa5 = +[ + [ "xexception.hpp", "xexception_8hpp_source.html", null ], + [ "xtensor_simd.hpp", "xtensor__simd_8hpp_source.html", null ], + [ "xutils.hpp", "xutils_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_cd476e4823af9724af1911969b947d0c.html b/dir_cd476e4823af9724af1911969b947d0c.html new file mode 100644 index 000000000..93e9113ce --- /dev/null +++ b/dir_cd476e4823af9724af1911969b947d0c.html @@ -0,0 +1,140 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/misc Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
misc Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + +

+Files

 xcomplex.hpp
 
 xexpression_holder.hpp
 
 xfft.hpp
 
 xhistogram.hpp
 
 xmanipulation.hpp
 
 xpad.hpp
 
 xset_operation.hpp
 
 xsort.hpp
 
 xtl_concepts.hpp
 
+
+
+ + + + diff --git a/dir_cd476e4823af9724af1911969b947d0c.js b/dir_cd476e4823af9724af1911969b947d0c.js new file mode 100644 index 000000000..93758553c --- /dev/null +++ b/dir_cd476e4823af9724af1911969b947d0c.js @@ -0,0 +1,12 @@ +var dir_cd476e4823af9724af1911969b947d0c = +[ + [ "xcomplex.hpp", "xcomplex_8hpp_source.html", null ], + [ "xexpression_holder.hpp", "xexpression__holder_8hpp_source.html", null ], + [ "xfft.hpp", "xfft_8hpp_source.html", null ], + [ "xhistogram.hpp", "xhistogram_8hpp_source.html", null ], + [ "xmanipulation.hpp", "xmanipulation_8hpp_source.html", null ], + [ "xpad.hpp", "xpad_8hpp_source.html", null ], + [ "xset_operation.hpp", "xset__operation_8hpp_source.html", null ], + [ "xsort.hpp", "xsort_8hpp_source.html", null ], + [ "xtl_concepts.hpp", "xtl__concepts_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/dir_d44c64559bbebec7f509842c48db8b23.html b/dir_d44c64559bbebec7f509842c48db8b23.html new file mode 100644 index 000000000..c3bc5e1eb --- /dev/null +++ b/dir_d44c64559bbebec7f509842c48db8b23.html @@ -0,0 +1,118 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
include Directory Reference
+
+
+
+
+ + + + diff --git a/dir_d44c64559bbebec7f509842c48db8b23.js b/dir_d44c64559bbebec7f509842c48db8b23.js new file mode 100644 index 000000000..1ec67b6c4 --- /dev/null +++ b/dir_d44c64559bbebec7f509842c48db8b23.js @@ -0,0 +1,4 @@ +var dir_d44c64559bbebec7f509842c48db8b23 = +[ + [ "xtensor", "dir_ea185b87f60949e3b1bf14314f33a519.html", "dir_ea185b87f60949e3b1bf14314f33a519" ] +]; \ No newline at end of file diff --git a/dir_ea185b87f60949e3b1bf14314f33a519.html b/dir_ea185b87f60949e3b1bf14314f33a519.html new file mode 100644 index 000000000..ad44c7f55 --- /dev/null +++ b/dir_ea185b87f60949e3b1bf14314f33a519.html @@ -0,0 +1,142 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
xtensor Directory Reference
+
+
+ + + + + + + + + + + + + + + + + + + + + + +

+Directories

 chunk
 
 containers
 
 core
 
 generators
 
 io
 
 misc
 
 optional
 
 reducers
 
 utils
 
 views
 
+
+
+ + + + diff --git a/dir_ea185b87f60949e3b1bf14314f33a519.js b/dir_ea185b87f60949e3b1bf14314f33a519.js new file mode 100644 index 000000000..1fb6e0f21 --- /dev/null +++ b/dir_ea185b87f60949e3b1bf14314f33a519.js @@ -0,0 +1,13 @@ +var dir_ea185b87f60949e3b1bf14314f33a519 = +[ + [ "chunk", "dir_eadb0ec9a1f66a1e2a37a75175ba90a3.html", "dir_eadb0ec9a1f66a1e2a37a75175ba90a3" ], + [ "containers", "dir_c04393294c6204f6f7005e440fd4c48c.html", "dir_c04393294c6204f6f7005e440fd4c48c" ], + [ "core", "dir_5dbc63e3e208067190e586da41725baf.html", "dir_5dbc63e3e208067190e586da41725baf" ], + [ "generators", "dir_72c9924f54f34c9a9a500349a94b928a.html", "dir_72c9924f54f34c9a9a500349a94b928a" ], + [ "io", "dir_8a589290beb6e41d95922675c5a252d5.html", "dir_8a589290beb6e41d95922675c5a252d5" ], + [ "misc", "dir_cd476e4823af9724af1911969b947d0c.html", "dir_cd476e4823af9724af1911969b947d0c" ], + [ "optional", "dir_7614d47be9b26b68b6e19faab3d8cf3d.html", "dir_7614d47be9b26b68b6e19faab3d8cf3d" ], + [ "reducers", "dir_0d75396b9e02a3c29319113837a95cad.html", "dir_0d75396b9e02a3c29319113837a95cad" ], + [ "utils", "dir_c7391fa963006b3dcc74b1e23f2b5aa5.html", "dir_c7391fa963006b3dcc74b1e23f2b5aa5" ], + [ "views", "dir_a756a6382b5a8aa8dbc0087dac27d23d.html", "dir_a756a6382b5a8aa8dbc0087dac27d23d" ] +]; \ No newline at end of file diff --git a/dir_eadb0ec9a1f66a1e2a37a75175ba90a3.html b/dir_eadb0ec9a1f66a1e2a37a75175ba90a3.html new file mode 100644 index 000000000..68a33529a --- /dev/null +++ b/dir_eadb0ec9a1f66a1e2a37a75175ba90a3.html @@ -0,0 +1,128 @@ + + + + + + + +xtensor: /home/runner/work/xtensor/xtensor/include/xtensor/chunk Directory Reference + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+
xtensor +
+
+ +   + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+
+
+
+
+
Loading...
+
Searching...
+
No Matches
+
+
+
+
+ +
+
chunk Directory Reference
+
+
+ + + + + + + + +

+Files

 xchunked_array.hpp
 
 xchunked_assign.hpp
 
 xchunked_view.hpp
 
+
+
+ + + + diff --git a/dir_eadb0ec9a1f66a1e2a37a75175ba90a3.js b/dir_eadb0ec9a1f66a1e2a37a75175ba90a3.js new file mode 100644 index 000000000..a2b4194f4 --- /dev/null +++ b/dir_eadb0ec9a1f66a1e2a37a75175ba90a3.js @@ -0,0 +1,6 @@ +var dir_eadb0ec9a1f66a1e2a37a75175ba90a3 = +[ + [ "xchunked_array.hpp", "xchunked__array_8hpp_source.html", null ], + [ "xchunked_assign.hpp", "xchunked__assign_8hpp_source.html", null ], + [ "xchunked_view.hpp", "xchunked__view_8hpp_source.html", null ] +]; \ No newline at end of file diff --git a/doc.svg b/doc.svg new file mode 100644 index 000000000..0b928a531 --- /dev/null +++ b/doc.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + diff --git a/docd.svg b/docd.svg new file mode 100644 index 000000000..ac18b2755 --- /dev/null +++ b/docd.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + diff --git a/docs/Doxyfile b/docs/Doxyfile deleted file mode 100644 index d0b8d6e08..000000000 --- a/docs/Doxyfile +++ /dev/null @@ -1,23 +0,0 @@ -PROJECT_NAME = "xtensor" -XML_OUTPUT = xml -INPUT = ../include -GENERATE_LATEX = NO -GENERATE_MAN = NO -GENERATE_RTF = NO -CASE_SENSE_NAMES = NO -GENERATE_HTML = YES -GENERATE_XML = YES -RECURSIVE = YES -QUIET = YES -JAVADOC_AUTOBRIEF = YES -WARN_IF_UNDOCUMENTED = NO -MACRO_EXPANSION = YES -PREDEFINED = IN_DOXYGEN -EXCLUDE_SYMBOLS = detail -GENERATE_TREEVIEW = YES -SOURCE_BROWSER = YES -# WARN_IF_UNDOCUMENTED = YES - -# Allow for rst directives and advanced functions e.g. grid tables -ALIASES = "rst=\verbatim embed:rst:leading-asterisk" -ALIASES += "endrst=\endverbatim" diff --git a/docs/Makefile b/docs/Makefile deleted file mode 100644 index 835afeee8..000000000 --- a/docs/Makefile +++ /dev/null @@ -1,187 +0,0 @@ -# You can set these variables from the command line. -SPHINXOPTS = -SPHINXBUILD = sphinx-build -PAPER = -BUILDDIR = build - -# User-friendly check for sphinx-build -ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) -$(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/) -endif - -# Internal variables. -PAPEROPT_a4 = -D latex_paper_size=a4 -PAPEROPT_letter = -D latex_paper_size=letter -ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source -# the i18n builder cannot share the environment and doctrees with the others -I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source - -.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext api - -default: html - -help: - @echo "Please use \`make ' where is one of" - @echo " html to make standalone HTML files" - @echo " dirhtml to make HTML files named index.html in directories" - @echo " singlehtml to make a single large HTML file" - @echo " pickle to make pickle files" - @echo " json to make JSON files" - @echo " htmlhelp to make HTML files and a HTML help project" - @echo " qthelp to make HTML files and a qthelp project" - @echo " applehelp to make an Apple Help Book" - @echo " devhelp to make HTML files and a Devhelp project" - @echo " epub to make an epub" - @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" - @echo " latexpdf to make LaTeX files and run them through pdflatex" - @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" - @echo " text to make text files" - @echo " man to make manual pages" - @echo " texinfo to make Texinfo files" - @echo " info to make Texinfo files and run them through makeinfo" - @echo " gettext to make PO message catalogs" - @echo " changes to make an overview of all changed/added/deprecated items" - @echo " xml to make Docutils-native XML files" - @echo " pseudoxml to make pseudoxml-XML files for display purposes" - @echo " linkcheck to check all external links for integrity" - @echo " doctest to run all doctests embedded in the documentation (if enabled)" - @echo " coverage to run coverage check of the documentation (if enabled)" - -clean: - rm -rf $(BUILDDIR)/* - rm -rf xml - -html: - doxygen - $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html - @echo - @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." - -dirhtml: - doxygen - $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml - @echo - @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." - -singlehtml: - doxygen - $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml - @echo - @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." - -pickle: - doxygen - $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle - @echo - @echo "Build finished; now you can process the pickle files." - -json: - doxygen - $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json - @echo - @echo "Build finished; now you can process the JSON files." - -htmlhelp: - doxygen - $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp - @echo - @echo "Build finished; now you can run HTML Help Workshop with the" \ - ".hhp project file in $(BUILDDIR)/htmlhelp." - -epub: - doxygen - $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub - @echo - @echo "Build finished. The epub file is in $(BUILDDIR)/epub." - -latex: - doxygen - $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex - @echo - @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." - @echo "Run \`make' in that directory to run these through (pdf)latex" \ - "(use \`make latexpdf' here to do that automatically)." - -latexpdf: - doxygen - $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex - @echo "Running LaTeX files through pdflatex..." - $(MAKE) -C $(BUILDDIR)/latex all-pdf - @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." - -latexpdfja: - doxygen - $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex - @echo "Running LaTeX files through platex and dvipdfmx..." - $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja - @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." - -text: - doxygen - $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text - @echo - @echo "Build finished. The text files are in $(BUILDDIR)/text." - -man: - doxygen - $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man - @echo - @echo "Build finished. The manual pages are in $(BUILDDIR)/man." - -texinfo: - doxygen - $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo - @echo - @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." - @echo "Run \`make' in that directory to run these through makeinfo" \ - "(use \`make info' here to do that automatically)." - -info: - doxygen - $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo - @echo "Running Texinfo files through makeinfo..." - make -C $(BUILDDIR)/texinfo info - @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." - -gettext: - doxygen - $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale - @echo - @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." - -changes: - doxygen - $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes - @echo - @echo "The overview file is in $(BUILDDIR)/changes." - -linkcheck: - doxygen - $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck - @echo - @echo "Link check complete; look for any errors in the above output " \ - "or in $(BUILDDIR)/linkcheck/output.txt." - -doctest: - doxygen - $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest - @echo "Testing of doctests in the sources finished, look at the " \ - "results in $(BUILDDIR)/doctest/output.txt." - -coverage: - doxygen - $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage - @echo "Testing of coverage in the sources finished, look at the " \ - "results in $(BUILDDIR)/coverage/python.txt." - -xml: - doxygen - $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml - @echo - @echo "Build finished. The XML files are in $(BUILDDIR)/xml." - -pseudoxml: - doxygen - $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml - @echo - @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." diff --git a/docs/ghp_environment.yml b/docs/ghp_environment.yml deleted file mode 100644 index 9584ae39d..000000000 --- a/docs/ghp_environment.yml +++ /dev/null @@ -1,4 +0,0 @@ -channels: -- conda-forge -dependencies: -- doxygen diff --git a/docs/make.bat b/docs/make.bat deleted file mode 100644 index 07de3322c..000000000 --- a/docs/make.bat +++ /dev/null @@ -1,264 +0,0 @@ -@ECHO OFF - -REM Command file for Sphinx documentation - -if "%SPHINXBUILD%" == "" ( - set SPHINXBUILD=sphinx-build -) -set BUILDDIR=build -set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% source -set I18NSPHINXOPTS=%SPHINXOPTS% source -if NOT "%PAPER%" == "" ( - set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% - set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% -) - -if "%1" == "" goto help - -if "%1" == "help" ( - :help - echo.Please use `make ^` where ^ is one of - echo. html to make standalone HTML files - echo. dirhtml to make HTML files named index.html in directories - echo. singlehtml to make a single large HTML file - echo. pickle to make pickle files - echo. json to make JSON files - echo. htmlhelp to make HTML files and a HTML help project - echo. qthelp to make HTML files and a qthelp project - echo. devhelp to make HTML files and a Devhelp project - echo. epub to make an epub - echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter - echo. text to make text files - echo. man to make manual pages - echo. texinfo to make Texinfo files - echo. gettext to make PO message catalogs - echo. changes to make an overview over all changed/added/deprecated items - echo. xml to make Docutils-native XML files - echo. pseudoxml to make pseudoxml-XML files for display purposes - echo. linkcheck to check all external links for integrity - echo. doctest to run all doctests embedded in the documentation if enabled - echo. coverage to run coverage check of the documentation if enabled - goto end -) - -if "%1" == "clean" ( - for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i - del /q /s %BUILDDIR%\* - goto end -) - - -REM Check if sphinx-build is available and fallback to Python version if any -%SPHINXBUILD% 1>NUL 2>NUL -if errorlevel 9009 goto sphinx_python -goto sphinx_ok - -:sphinx_python - -set SPHINXBUILD=python -m sphinx.__init__ -%SPHINXBUILD% 2> nul -if errorlevel 9009 ( - echo. - echo.The 'sphinx-build' command was not found. Make sure you have Sphinx - echo.installed, then set the SPHINXBUILD environment variable to point - echo.to the full path of the 'sphinx-build' executable. Alternatively you - echo.may add the Sphinx directory to PATH. - echo. - echo.If you don't have Sphinx installed, grab it from - echo.http://sphinx-doc.org/ - exit /b 1 -) - -:sphinx_ok - - -if "%1" == "html" ( - doxygen - %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The HTML pages are in %BUILDDIR%/html. - goto end -) - -if "%1" == "dirhtml" ( - %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. - goto end -) - -if "%1" == "singlehtml" ( - %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. - goto end -) - -if "%1" == "pickle" ( - %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle - if errorlevel 1 exit /b 1 - echo. - echo.Build finished; now you can process the pickle files. - goto end -) - -if "%1" == "json" ( - %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json - if errorlevel 1 exit /b 1 - echo. - echo.Build finished; now you can process the JSON files. - goto end -) - -if "%1" == "htmlhelp" ( - %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp - if errorlevel 1 exit /b 1 - echo. - echo.Build finished; now you can run HTML Help Workshop with the ^ -.hhp project file in %BUILDDIR%/htmlhelp. - goto end -) - -if "%1" == "qthelp" ( - %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp - if errorlevel 1 exit /b 1 - echo. - echo.Build finished; now you can run "qcollectiongenerator" with the ^ -.qhcp project file in %BUILDDIR%/qthelp, like this: - echo.^> qcollectiongenerator %BUILDDIR%\qthelp\packagename.qhcp - echo.To view the help file: - echo.^> assistant -collectionFile %BUILDDIR%\qthelp\packagename.ghc - goto end -) - -if "%1" == "devhelp" ( - %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. - goto end -) - -if "%1" == "epub" ( - %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The epub file is in %BUILDDIR%/epub. - goto end -) - -if "%1" == "latex" ( - %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex - if errorlevel 1 exit /b 1 - echo. - echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. - goto end -) - -if "%1" == "latexpdf" ( - %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex - cd %BUILDDIR%/latex - make all-pdf - cd %~dp0 - echo. - echo.Build finished; the PDF files are in %BUILDDIR%/latex. - goto end -) - -if "%1" == "latexpdfja" ( - %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex - cd %BUILDDIR%/latex - make all-pdf-ja - cd %~dp0 - echo. - echo.Build finished; the PDF files are in %BUILDDIR%/latex. - goto end -) - -if "%1" == "text" ( - %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The text files are in %BUILDDIR%/text. - goto end -) - -if "%1" == "man" ( - %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The manual pages are in %BUILDDIR%/man. - goto end -) - -if "%1" == "texinfo" ( - %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. - goto end -) - -if "%1" == "gettext" ( - %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The message catalogs are in %BUILDDIR%/locale. - goto end -) - -if "%1" == "changes" ( - %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes - if errorlevel 1 exit /b 1 - echo. - echo.The overview file is in %BUILDDIR%/changes. - goto end -) - -if "%1" == "linkcheck" ( - %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck - if errorlevel 1 exit /b 1 - echo. - echo.Link check complete; look for any errors in the above output ^ -or in %BUILDDIR%/linkcheck/output.txt. - goto end -) - -if "%1" == "doctest" ( - %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest - if errorlevel 1 exit /b 1 - echo. - echo.Testing of doctests in the sources finished, look at the ^ -results in %BUILDDIR%/doctest/output.txt. - goto end -) - -if "%1" == "coverage" ( - %SPHINXBUILD% -b coverage %ALLSPHINXOPTS% %BUILDDIR%/coverage - if errorlevel 1 exit /b 1 - echo. - echo.Testing of coverage in the sources finished, look at the ^ -results in %BUILDDIR%/coverage/python.txt. - goto end -) - -if "%1" == "xml" ( - %SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The XML files are in %BUILDDIR%/xml. - goto end -) - -if "%1" == "pseudoxml" ( - %SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml - if errorlevel 1 exit /b 1 - echo. - echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml. - goto end -) - -:end diff --git a/docs/rtd_environment.yml b/docs/rtd_environment.yml deleted file mode 100644 index 54fb700ca..000000000 --- a/docs/rtd_environment.yml +++ /dev/null @@ -1,8 +0,0 @@ -name: xtensor-docs - -channels: -- conda-forge - -dependencies: -- breathe -- sphinx_rtd_theme diff --git a/docs/source/_static/goatcounter.js b/docs/source/_static/goatcounter.js deleted file mode 100644 index a26dd2a26..000000000 --- a/docs/source/_static/goatcounter.js +++ /dev/null @@ -1,9 +0,0 @@ -(function() { - window.counter = 'https://xtensor_readthedocs_io.goatcounter.com/count' - - var script = document.createElement('script'); - script.async = 1; - script.src = '//gc.zgo.at/count.js'; - var ins = document.getElementsByTagName('script')[0]; - ins.parentNode.insertBefore(script, ins) -})(); diff --git a/docs/source/_static/main_stylesheet.css b/docs/source/_static/main_stylesheet.css deleted file mode 100644 index dc4199e3e..000000000 --- a/docs/source/_static/main_stylesheet.css +++ /dev/null @@ -1,4 +0,0 @@ -.wy-nav-content{ - max-width: 1000px; - margin: auto; -} diff --git a/docs/source/adaptor.rst b/docs/source/adaptor.rst deleted file mode 100644 index 64fd7caf3..000000000 --- a/docs/source/adaptor.rst +++ /dev/null @@ -1,232 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Adapting 1-D containers -======================= - -*xtensor* can adapt one-dimensional containers in place, and provide them a tensor interface. -Only random access containers can be adapted. - -Adapting std::vector --------------------- - -The following example shows how to bring an ``std::vector`` into the expression system of -*xtensor*: - -.. code:: - - #include - #include - #include - #include - - std::vector v = {1., 2., 3., 4., 5., 6. }; - std::vector shape = { 2, 3 }; - auto a1 = xt::adapt(v, shape); - - xt::xarray a2 = {{ 1., 2., 3.}, - { 4., 5., 6.}}; - - xt::xarray res = a1 + a2; - // res = {{ 2., 4., 6. }, { 8., 10., 12. }}; - -``v`` is not copied into ``a1``, so if you change a value in ``a1``, you're actually changing -the corresponding value in ``v``: - -.. code:: - - a1(0, 0) = 20.; - // now v is { 20., 2., 3., 4., 5., 6. } - -Adapting C-style arrays ------------------------ - -*xtensor* provides two ways for adapting a C-style array; the first one does not take the -ownership of the array: - -.. code:: - - #include - #include - - void compute(double* data, std::size_t size) - { - std::vector shape = { size }; - auto a = xt::adapt(data, size, xt::no_ownership(), shape); - a = a + a; // does not modify the size - } - - int main() - { - std::size_t size = 2; - double* data = new double[size]; - for (int i = 0; i < size; i++) - data[i] = i; - std::cout << data << std::endl; - // prints e.g. 0x557a363b7c20 - compute(data, size); - std::cout << data << std::endl; - // prints e.g. 0x557a363b7c20 (same pointer) - for (int i = 0; i < size; i++) - std::cout << data[i] << " "; - std::cout << std::endl; - // prints 0 2 (data is still available here) - } - -However if you replace :cpp:enumerator:`xt::no_ownership` with :cpp:enumerator:`xt::acquire_ownership`, the adaptor will take -the ownership of the array, meaning it will be deleted when the adaptor is destroyed: - -.. code:: - - #include - #include - #include - - void compute(double*& data, std::size_t size) - { - // data pointer can be changed, hence double*& - std::vector shape = { size }; - auto a = xt::adapt(data, size, xt::acquire_ownership(), shape); - xt::xarray b {1., 2.}; - b.reshape({2, 1}); - a = a * b; // size has changed, shape is now { 2, 2 } - } - - int main() - { - std::size_t size = 2; - double* data = new double[size]; - for (int i = 0; i < size; i++) - data[i] = i; - std::cout << data << std::endl; - // prints e.g. 0x557a363b7c20 - compute(data, size); - std::cout << data << std::endl; - // prints e.g. 0x557a363b8220 (pointer has changed) - for (int i = 0; i < size * size; i++) - std::cout << data[i] << " "; - std::cout << std::endl; - // prints e.g. 4.65504e-310 1 0 2 (data has been deleted and is now corrupted) - } - -To safely get the computed data out of the function, you could pass an additional output parameter -to ``compute`` in which you copy the result before exiting the function. Or you can create the -adaptor before calling ``compute`` and pass it to the function: - -.. code:: - - #include - #include - #include - - template - void compute(A& a) - { - xt::xarray b {1., 2.}; - b.reshape({2, 1}); - a = a * b; // size has changed, shape is now { 2, 2 } - } - - int main() - { - std::size_t size = 2; - double* data = new double[size]; - for (int i = 0; i < size; i++) - data[i] = i; - std::vector shape = { size }; - auto a = xt::adapt(data, size, xt::acquire_ownership(), shape); - compute(a); - for (int i = 0; i < size * size; i++) - std::cout << data[i] << " "; - std::cout << std::endl; - // prints 0 1 0 2 - } - -Adapting stack-allocated arrays -------------------------------- - -Adapting C arrays allocated on the stack is as simple as adapting ``std::vector``: - -.. code:: - - #include - #include - #include - #include - - double v[6] = {1., 2., 3., 4., 5., 6. }; - std::vector shape = { 2, 3 }; - auto a1 = xt::adapt(v, shape); - - xt::xarray a2 = {{ 1., 2., 3.}, - { 4., 5., 6.}}; - - xt::xarray res = a1 + a2; - // res = {{ 2., 4., 6. }, { 8., 10., 12. }}; - -``v`` is not copied into ``a1``, so if you change a value in ``a1``, you're actually changing -the corresponding value in ``v``: - -.. code:: - - a1(0, 0) = 20.; - // now v is { 20., 2., 3., 4., 5., 6. } - -Adapting C++ smart pointers ---------------------------- - -If you want to manage your data with shared or unique pointers, you can use the -:cpp:func:`xt::adapt_smart_ptr` function of xtensor. -It will automatically increment the reference count of shared pointers upon creation, and decrement upon deletion. - -.. code:: - - #include - #include - #include - - std::shared_ptr sptr(new double[8], std::default_delete()); - sptr.get()[2] = 321.; - auto xptr = xt::adapt_smart_ptr(sptr, {4, 2}); - xptr(1, 3) = 123.; - std::cout << xptr; - -Or if you operate on shared pointers that do not directly point to the underlying -buffer, you can pass the data pointer and the smart pointer (to manage the underlying -memory) as follows: - -.. code:: - - #include - #include - #include - - struct Buffer { - Buffer(std::vector& buf) : m_buf(buf) {} - ~Buffer() { std::cout << "deleted" << std::endl; } - std::vector m_buf; - }; - - auto data = std::vector{1,2,3,4,5,6,7,8}; - auto shared_buf = std::make_shared(data); - auto unique_buf = std::make_unique(data); - - std::cout << shared_buf.use_count() << std::endl; - { - auto obj = xt::adapt_smart_ptr(shared_buf.get()->m_buf.data(), - {2, 4}, shared_buf); - // Use count increased to 2 - std::cout << shared_buf.use_count() << std::endl; - std::cout << obj << std::endl; - } - // Use count reset to 1 - std::cout << shared_buf.use_count() << std::endl; - - { - auto obj = xt::adapt_smart_ptr(unique_buf.get()->m_buf.data(), - {2, 4}, std::move(unique_buf)); - std::cout << obj << std::endl; - } diff --git a/docs/source/api/accumulating_functions.rst b/docs/source/api/accumulating_functions.rst deleted file mode 100644 index 1842912e1..000000000 --- a/docs/source/api/accumulating_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Accumulating functions -====================== - -**xtensor** provides the following accumulating functions for xexpressions: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: acc_functions - :members: diff --git a/docs/source/api/basic_functions.rst b/docs/source/api/basic_functions.rst deleted file mode 100644 index c6e8020b8..000000000 --- a/docs/source/api/basic_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Basic functions -=============== - -**xtensor** provides the following basic functions for xexpressions and scalars: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: basic_functions - :members: diff --git a/docs/source/api/classif_functions.rst b/docs/source/api/classif_functions.rst deleted file mode 100644 index f39602b2b..000000000 --- a/docs/source/api/classif_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Classification functions -======================== - -**xtensor** provides the following classification functions for xexpressions and scalars: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: classif_functions - :members: diff --git a/docs/source/api/container_index.rst b/docs/source/api/container_index.rst deleted file mode 100644 index ef8c0ba84..000000000 --- a/docs/source/api/container_index.rst +++ /dev/null @@ -1,36 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Containers and views -==================== - -Containers are in-memory expressions that share a common implementation of most of the methods of the xexpression API. -The final container classes (:cpp:type:`xt::xarray`, :cpp:type:`xt::xtensor`) mainly implement constructors and value semantic, most of the -xexpression API is actually implemented in ``xstrided_container`` and ``xcontainer``. - -.. toctree:: - - xcontainer - xaccessible - xiterable - xarray - xarray_adaptor - xchunked_array - xtensor - xtensor_adaptor - xfixed - xadapt - xoptional_assembly_base - xoptional_assembly - xoptional_assembly_adaptor - xmasked_view - xview - xstrided_view - xbroadcast - xindex_view - xfunctor_view - xrepeat - xfft diff --git a/docs/source/api/error_functions.rst b/docs/source/api/error_functions.rst deleted file mode 100644 index be2312f08..000000000 --- a/docs/source/api/error_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Error and gamma functions -========================= - -**xtensor** provides the following error and gamma functions for xexpressions: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: err_functions - :members: diff --git a/docs/source/api/exponential_functions.rst b/docs/source/api/exponential_functions.rst deleted file mode 100644 index 65caeed74..000000000 --- a/docs/source/api/exponential_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Exponential functions -===================== - -**xtensor** provides the following exponential functions for xexpressions: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: exp_functions - :members: diff --git a/docs/source/api/expression_index.rst b/docs/source/api/expression_index.rst deleted file mode 100644 index c257117db..000000000 --- a/docs/source/api/expression_index.rst +++ /dev/null @@ -1,20 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Expressions and semantic -======================== - -:cpp:type:`xt::xexpression` and the semantic classes contain all the methods required to perform evaluation and -assignment of expressions. They define the computed assignment operators, the assignment methods for -``noalias`` and the downcast methods. - -.. toctree:: - - xexpression - xsemantic_base - xcontainer_semantic - xview_semantic - xeval diff --git a/docs/source/api/function_index.rst b/docs/source/api/function_index.rst deleted file mode 100644 index b4e3a22cf..000000000 --- a/docs/source/api/function_index.rst +++ /dev/null @@ -1,22 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Functions and generators -======================== - -.. toctree:: - - xfunction - xreducer - xaccumulator - xgenerator - xbuilder - xmanipulation - xsort - xset_operation - xrandom - xhistogram - xpad diff --git a/docs/source/api/hyperbolic_functions.rst b/docs/source/api/hyperbolic_functions.rst deleted file mode 100644 index 757c77409..000000000 --- a/docs/source/api/hyperbolic_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Hyperbolic functions -==================== - -**xtensor** provides the following hyperbolic functions for xexpressions: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: hyper_functions - :members: diff --git a/docs/source/api/index_related.rst b/docs/source/api/index_related.rst deleted file mode 100644 index f7de8fdc2..000000000 --- a/docs/source/api/index_related.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Index related functions -======================= - -Defined in ``xtensor/core/xoperation.hpp`` - -The logical operator group documents the index-producing overloads of -``xt::where``, ``xt::nonzero`` and ``xt::argwhere``. - -``xt::from_indices`` is documented on the ``xtensor`` API page. diff --git a/docs/source/api/io_index.rst b/docs/source/api/io_index.rst deleted file mode 100644 index 0e780e391..000000000 --- a/docs/source/api/io_index.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -IO Operations -============= - -.. toctree:: - - xio - xnpy - xcsv - xjson diff --git a/docs/source/api/iterator_index.rst b/docs/source/api/iterator_index.rst deleted file mode 100644 index 7640a740a..000000000 --- a/docs/source/api/iterator_index.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Iterators -========= - -In addition to the iterators defined in the different types of expressions, *xtensor* provides -classes that allow to iterate over slices of an expression along a specified axis. - -.. toctree:: - - xaxis_iterator - xaxis_slice_iterator diff --git a/docs/source/api/nan_functions.rst b/docs/source/api/nan_functions.rst deleted file mode 100644 index 918039bce..000000000 --- a/docs/source/api/nan_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -NaN functions -============= - -**xtensor** provides the following functions that deal with NaNs in xexpressions: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: nan_functions - :members: diff --git a/docs/source/api/nearint_operations.rst b/docs/source/api/nearint_operations.rst deleted file mode 100644 index 59dd61d19..000000000 --- a/docs/source/api/nearint_operations.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Nearest integer floating point operations -========================================= - -**xtensor** provides the following rounding operations for xexpressions: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: nearint_functions - :members: diff --git a/docs/source/api/operators.rst b/docs/source/api/operators.rst deleted file mode 100644 index 00df9458d..000000000 --- a/docs/source/api/operators.rst +++ /dev/null @@ -1,25 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Operators and related functions -=============================== - -Defined in ``xtensor/core/xmath.hpp`` and ``xtensor/core/xoperation.hpp`` - -.. doxygengroup:: arithmetic_operators - :members: - -.. doxygengroup:: logical_operators - :members: - -.. doxygengroup:: comparison_operators - :members: - -.. doxygengroup:: bitwise_operators - :members: - -.. doxygengroup:: casting_operators - :members: diff --git a/docs/source/api/power_functions.rst b/docs/source/api/power_functions.rst deleted file mode 100644 index 5ac5a1546..000000000 --- a/docs/source/api/power_functions.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - - -Power functions -=============== - -**xtensor** provides the following power functions for xexpressions and scalars: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: pow_functions - :members: diff --git a/docs/source/api/reducing_functions.rst b/docs/source/api/reducing_functions.rst deleted file mode 100644 index 89c0baff5..000000000 --- a/docs/source/api/reducing_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Reducing functions -================== - -**xtensor** provides the following reducing functions for xexpressions: - -Defined in ``xtensor/core/xmath.hpp`` and ``xtensor/reducers/xnorm.hpp``. - -.. doxygengroup:: red_functions - :members: diff --git a/docs/source/api/shape.rst b/docs/source/api/shape.rst deleted file mode 100644 index a35434ac9..000000000 --- a/docs/source/api/shape.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Shape/index manipulation -======================== - -.. toctree:: - - xshape - xstrides diff --git a/docs/source/api/trigonometric_functions.rst b/docs/source/api/trigonometric_functions.rst deleted file mode 100644 index e76d151b5..000000000 --- a/docs/source/api/trigonometric_functions.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Trigonometric functions -======================= - -**xtensor** provides the following trigonometric functions for xexpressions and scalars: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygengroup:: trigo_functions - :members: diff --git a/docs/source/api/xaccessible.rst b/docs/source/api/xaccessible.rst deleted file mode 100644 index 237fc029d..000000000 --- a/docs/source/api/xaccessible.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xaccessible -=========== - -Defined in ``xtensor/core/xaccessible.hpp`` - -.. doxygenclass:: xt::xconst_accessible - :members: - -.. doxygenclass:: xt::xaccessible - :members: diff --git a/docs/source/api/xaccumulator.rst b/docs/source/api/xaccumulator.rst deleted file mode 100644 index 906f5288e..000000000 --- a/docs/source/api/xaccumulator.rst +++ /dev/null @@ -1,14 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xaccumulator -============ - -Defined in ``xtensor/reducers/xaccumulator.hpp`` - -.. doxygenfunction:: xt::accumulate(F&&, E&&, EVS) - -.. doxygenfunction:: xt::accumulate(F&&, E&&, std::ptrdiff_t, EVS) diff --git a/docs/source/api/xadapt.rst b/docs/source/api/xadapt.rst deleted file mode 100644 index 86f9e4eb2..000000000 --- a/docs/source/api/xadapt.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xadapt -====== - -Defined in ``xtensor/containers/xadapt.hpp`` - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xadapt - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xarray.rst b/docs/source/api/xarray.rst deleted file mode 100644 index 18e06692e..000000000 --- a/docs/source/api/xarray.rst +++ /dev/null @@ -1,17 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xarray -====== - -Defined in ``xtensor/containers/xarray.hpp`` - -.. doxygenclass:: xt::xarray_container - :members: - -.. doxygentypedef:: xt::xarray - -.. doxygentypedef:: xt::xarray_optional diff --git a/docs/source/api/xarray_adaptor.rst b/docs/source/api/xarray_adaptor.rst deleted file mode 100644 index d1110c7ba..000000000 --- a/docs/source/api/xarray_adaptor.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xarray_adaptor -============== - -Defined in ``xtensor/containers/xarray.hpp`` - -.. doxygenclass:: xt::xarray_adaptor - :members: diff --git a/docs/source/api/xaxis_iterator.rst b/docs/source/api/xaxis_iterator.rst deleted file mode 100644 index e43bae3ee..000000000 --- a/docs/source/api/xaxis_iterator.rst +++ /dev/null @@ -1,26 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xaxis_iterator -============== - -Defined in ``xtensor/views/xaxis_iterator.hpp`` - -.. doxygenclass:: xt::xaxis_iterator - :members: - -.. doxygenfunction:: operator==(const xaxis_iterator&, const xaxis_iterator&) - - -.. doxygenfunction:: operator!=(const xaxis_iterator&, const xaxis_iterator&) - -.. doxygenfunction:: axis_begin(E&&) - -.. doxygenfunction:: axis_begin(E&&, typename std::decay_t::size_type) - -.. doxygenfunction:: axis_end(E&&) - -.. doxygenfunction:: axis_end(E&&, typename std::decay_t::size_type) diff --git a/docs/source/api/xaxis_slice_iterator.rst b/docs/source/api/xaxis_slice_iterator.rst deleted file mode 100644 index 4882fc292..000000000 --- a/docs/source/api/xaxis_slice_iterator.rst +++ /dev/null @@ -1,27 +0,0 @@ - -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xaxis_slice_iterator -==================== - -Defined in ``xtensor/views/xaxis_slice_iterator.hpp`` - -.. doxygenclass:: xt::xaxis_slice_iterator - :members: - -.. doxygenfunction:: operator==(const xaxis_slice_iterator&, const xaxis_slice_iterator&) - - -.. doxygenfunction:: operator!=(const xaxis_slice_iterator&, const xaxis_slice_iterator&) - -.. doxygenfunction:: axis_slice_begin(E&&) - -.. doxygenfunction:: axis_slice_begin(E&&, typename std::decay_t::size_type) - -.. doxygenfunction:: axis_slice_end(E&&) - -.. doxygenfunction:: axis_slice_end(E&&, typename std::decay_t::size_type) diff --git a/docs/source/api/xbroadcast.rst b/docs/source/api/xbroadcast.rst deleted file mode 100644 index e5fe1790f..000000000 --- a/docs/source/api/xbroadcast.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xbroadcast -========== - -Defined in ``xtensor/views/xbroadcast.hpp`` - -.. doxygenclass:: xt::xbroadcast - :members: - -.. doxygenfunction:: xt::broadcast(E&&, const S&) diff --git a/docs/source/api/xbuilder.rst b/docs/source/api/xbuilder.rst deleted file mode 100644 index b315c3730..000000000 --- a/docs/source/api/xbuilder.rst +++ /dev/null @@ -1,58 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xbuilder -======== - -Defined in ``xtensor/generators/xbuilder.hpp`` - -.. doxygenfunction:: xt::ones(S) - -.. doxygenfunction:: xt::ones(const I (&)[L]) - -.. doxygenfunction:: xt::zeros(S) - -.. doxygenfunction:: xt::zeros(const I (&)[L]) - -.. doxygenfunction:: xt::empty(const S&) - -.. doxygenfunction:: xt::full_like(const xexpression&, typename E::value_type) - -.. doxygenfunction:: xt::empty_like(const xexpression&) - -.. doxygenfunction:: xt::zeros_like(const xexpression&) - -.. doxygenfunction:: xt::ones_like(const xexpression&) - -.. doxygenfunction:: xt::eye(const std::vector&, int) - -.. doxygenfunction:: xt::eye(std::size_t, int) - -.. doxygenfunction:: xt::arange(T, T, S) - -.. doxygenfunction:: xt::arange(T) - -.. doxygenfunction:: xt::linspace - -.. doxygenfunction:: xt::logspace - -.. doxygenfunction:: xt::concatenate(std::tuple&&, std::size_t) - -.. doxygenfunction:: xt::stack - -.. doxygenfunction:: xt::hstack - -.. doxygenfunction:: xt::vstack - -.. doxygenfunction:: xt::meshgrid - -.. doxygenfunction:: xt::diag - -.. doxygenfunction:: xt::diagonal - -.. doxygenfunction:: xt::tril - -.. doxygenfunction:: xt::triu diff --git a/docs/source/api/xchunked_array.rst b/docs/source/api/xchunked_array.rst deleted file mode 100644 index f3971bf4f..000000000 --- a/docs/source/api/xchunked_array.rst +++ /dev/null @@ -1,14 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvaidan Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xchunked_array -============== - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xchunked_array - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xcontainer.rst b/docs/source/api/xcontainer.rst deleted file mode 100644 index 24fbf6c47..000000000 --- a/docs/source/api/xcontainer.rst +++ /dev/null @@ -1,30 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -layout -====== - -Defined in ``xtensor/core/xlayout.hpp`` - -.. doxygenenum:: xt::layout_type - -.. doxygenfunction:: xt::compute_layout(Args... args) - -xcontainer -========== - -Defined in ``xtensor/containers/xcontainer.hpp`` - -.. doxygenclass:: xt::xcontainer - :members: - -xstrided_container -================== - -Defined in ``xtensor/containers/xcontainer.hpp`` - -.. doxygenclass:: xt::xstrided_container - :members: diff --git a/docs/source/api/xcontainer_semantic.rst b/docs/source/api/xcontainer_semantic.rst deleted file mode 100644 index c69866083..000000000 --- a/docs/source/api/xcontainer_semantic.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xcontainer_semantic -=================== - -Defined in ``xtensor/core/xsemantic.hpp`` - -.. doxygenclass:: xt::xcontainer_semantic - :members: diff --git a/docs/source/api/xcsv.rst b/docs/source/api/xcsv.rst deleted file mode 100644 index bc762b00f..000000000 --- a/docs/source/api/xcsv.rst +++ /dev/null @@ -1,14 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xcsv: read/write CSV files -========================== - -Defined in ``xtensor/io/xcsv.hpp`` - -.. doxygenfunction:: xt::load_csv - -.. doxygenfunction:: xt::dump_csv diff --git a/docs/source/api/xeval.rst b/docs/source/api/xeval.rst deleted file mode 100644 index c70420965..000000000 --- a/docs/source/api/xeval.rst +++ /dev/null @@ -1,14 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xeval -===== - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xeval - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xexpression.rst b/docs/source/api/xexpression.rst deleted file mode 100644 index 61f117592..000000000 --- a/docs/source/api/xexpression.rst +++ /dev/null @@ -1,22 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xexpression -=========== - -Defined in ``xtensor/core/xexpression.hpp`` - -.. doxygenclass:: xt::xexpression - :members: - -.. doxygenclass:: xt::xshared_expression - :members: - -.. doxygenfunction:: make_xshared - -.. doxygenfunction:: share(xexpression&) - -.. doxygenfunction:: share(xexpression&&) diff --git a/docs/source/api/xfft.rst b/docs/source/api/xfft.rst deleted file mode 100644 index a05766ff7..000000000 --- a/docs/source/api/xfft.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xfft -==== - -Defined in ``xtensor/misc/xfft.hpp`` - -.. doxygenfunction:: xt::fft::fft(E&&, std::ptrdiff_t) - -.. doxygenfunction:: xt::fft::ifft(E&&, std::ptrdiff_t) - -.. doxygenfunction:: xt::fft::convolve(E1&&, E2&&, std::ptrdiff_t) diff --git a/docs/source/api/xfixed.rst b/docs/source/api/xfixed.rst deleted file mode 100644 index b9afc6d7b..000000000 --- a/docs/source/api/xfixed.rst +++ /dev/null @@ -1,15 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xtensor_fixed -============= - -Defined in ``xtensor/containers/xfixed.hpp`` - -.. doxygenclass:: xt::xfixed_container - :members: - -.. doxygentypedef:: xt::xtensor_fixed diff --git a/docs/source/api/xfunction.rst b/docs/source/api/xfunction.rst deleted file mode 100644 index e572e463b..000000000 --- a/docs/source/api/xfunction.rst +++ /dev/null @@ -1,17 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xfunction -========= - -Defined in ``xtensor/core/xfunction.hpp`` - -.. doxygenclass:: xt::xfunction - :members: - -Defined in ``xtensor/core/xmath.hpp`` - -.. doxygenfunction:: make_lambda_xfunction diff --git a/docs/source/api/xfunctor_view.rst b/docs/source/api/xfunctor_view.rst deleted file mode 100644 index 53ee7573d..000000000 --- a/docs/source/api/xfunctor_view.rst +++ /dev/null @@ -1,18 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xfunctor_view -============= - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xfunctor_view - :members: - :undoc-members: - -.. doxygengroup:: xt_xcomplex - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xgenerator.rst b/docs/source/api/xgenerator.rst deleted file mode 100644 index 8d96da7f3..000000000 --- a/docs/source/api/xgenerator.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xgenerator -========== - -Defined in ``xtensor/generators/xgenerator.hpp`` - -.. doxygenclass:: xt::xgenerator - :members: diff --git a/docs/source/api/xhistogram.rst b/docs/source/api/xhistogram.rst deleted file mode 100644 index 4d1e3e639..000000000 --- a/docs/source/api/xhistogram.rst +++ /dev/null @@ -1,22 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xhistogram -========== - -Defined in ``xtensor/misc/xhistogram.hpp`` - -.. doxygengroup:: digitize - :members: - -.. doxygengroup:: histogram - :members: - -.. doxygenfunction:: xt::bincount(E1&&, E2&&, std::size_t) - -.. doxygenfunction:: xt::bin_items(size_t, E&&) - -.. doxygenfunction:: xt::bin_items(size_t, size_t) diff --git a/docs/source/api/xindex_view.rst b/docs/source/api/xindex_view.rst deleted file mode 100644 index d47ab3733..000000000 --- a/docs/source/api/xindex_view.rst +++ /dev/null @@ -1,22 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xindex_view -=========== - -Defined in ``xtensor/views/xindex_view.hpp`` - -.. doxygenclass:: xt::xindex_view - :members: - -.. doxygenclass:: xt::xfiltration - :members: - -.. doxygenfunction:: xt::index_view(E&&, I&&) - -.. doxygenfunction:: xt::filter - -.. doxygenfunction:: xt::filtration diff --git a/docs/source/api/xio.rst b/docs/source/api/xio.rst deleted file mode 100644 index 7af4c5d09..000000000 --- a/docs/source/api/xio.rst +++ /dev/null @@ -1,52 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xio: pretty printing -==================== - -Defined in ``xtensor/io/xio.hpp`` - -This file defines functions for pretty printing xexpressions. It defines appropriate -overloads for the ``<<`` operator for std::ostreams and xexpressions. - -.. code:: - - #include - #include - - int main() - { - xt::xarray a = {{1,2,3}, {4,5,6}}; - std::cout << a << std::endl; - return 0; - } - -Will print - -.. code:: - - {{ 1., 2., 3.}, - { 4., 5., 6.}} - -With the following functions, the global print options can be set: - -.. doxygenfunction:: xt::print_options::set_line_width - -.. doxygenfunction:: xt::print_options::set_threshold - -.. doxygenfunction:: xt::print_options::set_edge_items - -.. doxygenfunction:: xt::print_options::set_precision - -On can also locally overwrite the print options with io manipulators: - -.. doxygenclass:: xt::print_options::line_width - -.. doxygenclass:: xt::print_options::threshold - -.. doxygenclass:: xt::print_options::edge_items - -.. doxygenclass:: xt::print_options::precision diff --git a/docs/source/api/xiterable.rst b/docs/source/api/xiterable.rst deleted file mode 100644 index f0ad5637d..000000000 --- a/docs/source/api/xiterable.rst +++ /dev/null @@ -1,19 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xiterable -========= - -Defined in ``xtensor/core/xiterable.hpp`` - -.. doxygenclass:: xt::xconst_iterable - :members: - -.. doxygenclass:: xt::xiterable - :members: - -.. doxygenclass:: xt::xcontiguous_iterable - :members: diff --git a/docs/source/api/xjson.rst b/docs/source/api/xjson.rst deleted file mode 100644 index 138c5b9de..000000000 --- a/docs/source/api/xjson.rst +++ /dev/null @@ -1,18 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xjson: serialize to/from JSON -============================= - -Defined in ``xtensor/io/xjson.hpp`` - -Available overload families ---------------------------- - -- ``xt::to_json(nlohmann::basic_json&, const E&)`` -- ``xt::from_json(const nlohmann::basic_json&, E&)`` - -``xt::from_json`` is provided for both container and view semantics. diff --git a/docs/source/api/xmanipulation.rst b/docs/source/api/xmanipulation.rst deleted file mode 100644 index 779010da5..000000000 --- a/docs/source/api/xmanipulation.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay, Wolf Vollprecht and Martin Renou - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xmanipulation -============= - -Defined in ``xtensor/misc/xmanipulation.hpp`` - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xmanipulation - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xmasked_view.rst b/docs/source/api/xmasked_view.rst deleted file mode 100644 index b7df88ec3..000000000 --- a/docs/source/api/xmasked_view.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xmasked_view -============ - -Defined in ``xtensor/views/xmasked_view.hpp`` - -.. doxygenclass:: xt::xmasked_view - :members: diff --git a/docs/source/api/xmath.rst b/docs/source/api/xmath.rst deleted file mode 100644 index 934879b8a..000000000 --- a/docs/source/api/xmath.rst +++ /dev/null @@ -1,385 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -.. raw:: html - - - -Mathematical functions -====================== - -.. toctree:: - - operators - -.. table:: - :widths: 30 70 - - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator+` | identity | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator-` | opposite | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator+` | addition | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator-` | substraction | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator*` | multiplication | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator/` | division | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator||` | logical or | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator&&` | logical and | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator!` | logical not | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::where` | ternary selection | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::any` | return true if any value is truthy | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::all` | return true if all the values are truthy | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator\<` | element-wise lesser than | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator\<=` | element-wise less or equal | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator>` | element-wise greater than | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator>=` | element-wise greater or equal | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator==` | expression equality | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator!=` | expression inequality | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::equal` | element-wise equality | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::not_equal` | element-wise inequality | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::less` | element-wise lesser than | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::less_equal` | element-wise less or equal | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::greater` | element-wise greater than | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::greater_equal` | element-wise greater or equal | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::cast` | element-wise ``static_cast`` | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator&` | bitwise and | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator|` | bitwise or | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator^` | bitwise xor | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator~` | bitwise not | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::left_shift` | bitwise shift left | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::right_shift` | bitwise shift right | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator\<\<` | bitwise shift left | - +-------------------------------+------------------------------------------+ - | :cpp:func:`xt::operator\>\>` | bitwise shift right | - +-------------------------------+------------------------------------------+ - -.. toctree:: - - index_related - -.. table:: - :widths: 30 70 - - +------------------------------+----------------------+ - | :cpp:func:`xt::where` | indices selection | - +------------------------------+----------------------+ - | :cpp:func:`xt::nonzero` | indices selection | - +------------------------------+----------------------+ - | :cpp:func:`xt::argwhere` | indices selection | - +------------------------------+----------------------+ - | :cpp:func:`xt::from_indices` | biulder from indices | - +------------------------------+----------------------+ - -.. toctree:: - - basic_functions - -.. table:: - :widths: 30 70 - - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::abs` | absolute value | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::fabs` | absolute value | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::fmod` | remainder of the floating point division operation | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::remainder` | signed remainder of the division operation | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::fma` | fused multiply-add operation | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::minimum` | element-wise minimum | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::maximum` | element-wise maximum | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::fmin` | element-wise minimum for floating point values | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::fmax` | element-wise maximum for floating point values | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::fdim` | element-wise positive difference | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::clip` | element-wise clipping operation | - +---------------------------+----------------------------------------------------+ - | :cpp:func:`xt::sign` | element-wise indication of the sign | - +---------------------------+----------------------------------------------------+ - -.. toctree:: - - exponential_functions - -.. table:: - :widths: 30 70 - - +-----------------------+-----------------------------------------+ - | :cpp:func:`xt::exp` | natural exponential function | - +-----------------------+-----------------------------------------+ - | :cpp:func:`xt::exp2` | base 2 exponential function | - +-----------------------+-----------------------------------------+ - | :cpp:func:`xt::expm1` | natural exponential function, minus one | - +-----------------------+-----------------------------------------+ - | :cpp:func:`xt::log` | natural logarithm function | - +-----------------------+-----------------------------------------+ - | :cpp:func:`xt::log2` | base 2 logarithm function | - +-----------------------+-----------------------------------------+ - | :cpp:func:`xt::log10` | base 10 logarithm function | - +-----------------------+-----------------------------------------+ - | :cpp:func:`xt::log1p` | natural logarithm of one plus function | - +-----------------------+-----------------------------------------+ - -.. toctree:: - - power_functions - -.. table:: - :widths: 30 70 - - +-----------------------+----------------------+ - | :cpp:func:`xt::pow` | power function | - +-----------------------+----------------------+ - | :cpp:func:`xt::sqrt` | square root function | - +-----------------------+----------------------+ - | :cpp:func:`xt::cbrt` | cubic root function | - +-----------------------+----------------------+ - | :cpp:func:`xt::hypot` | hypotenuse function | - +-----------------------+----------------------+ - -.. toctree:: - - trigonometric_functions - -.. table:: - :widths: 30 70 - - +-----------------------+---------------------------------------------+ - | :cpp:func:`xt::sin` | sine function | - +-----------------------+---------------------------------------------+ - | :cpp:func:`xt::cos` | cosine function | - +-----------------------+---------------------------------------------+ - | :cpp:func:`xt::tan` | tangent function | - +-----------------------+---------------------------------------------+ - | :cpp:func:`xt::asin` | arc sine function | - +-----------------------+---------------------------------------------+ - | :cpp:func:`xt::acos` | arc cosine function | - +-----------------------+---------------------------------------------+ - | :cpp:func:`xt::atan` | arc tangent function | - +-----------------------+---------------------------------------------+ - | :cpp:func:`xt::atan2` | arc tangent function, determining quadrants | - +-----------------------+---------------------------------------------+ - -.. toctree:: - - hyperbolic_functions - -.. table:: - :widths: 30 70 - - +-----------------------+-------------------------------------+ - | :cpp:func:`xt::sinh` | hyperbolic sine function | - +-----------------------+-------------------------------------+ - | :cpp:func:`xt::cosh` | hyperbolic cosine function | - +-----------------------+-------------------------------------+ - | :cpp:func:`xt::tanh` | hyperbolic tangent function | - +-----------------------+-------------------------------------+ - | :cpp:func:`xt::asinh` | inverse hyperbolic sine function | - +-----------------------+-------------------------------------+ - | :cpp:func:`xt::acosh` | inverse hyperbolic cosine function | - +-----------------------+-------------------------------------+ - | :cpp:func:`xt::atanh` | inverse hyperbolic tangent function | - +-----------------------+-------------------------------------+ - -.. toctree:: - - error_functions - -.. table:: - :widths: 30 70 - - +------------------------+-----------------------------------------+ - | :cpp:func:`xt::erf` | error function | - +------------------------+-----------------------------------------+ - | :cpp:func:`xt::erfc` | complementary error function | - +------------------------+-----------------------------------------+ - | :cpp:func:`xt::tgamma` | gamma function | - +------------------------+-----------------------------------------+ - | :cpp:func:`xt::lgamma` | natural logarithm of the gamma function | - +------------------------+-----------------------------------------+ - -.. toctree:: - - nearint_operations - -.. table:: - :widths: 30 70 - - +---------------------------+----------------------------------------------+ - | :cpp:func:`xt::ceil` | nearest integers not less | - +---------------------------+----------------------------------------------+ - | :cpp:func:`xt::floor` | nearest integers not greater | - +---------------------------+----------------------------------------------+ - | :cpp:func:`xt::trunc` | nearest integers not greater in magnitude | - +---------------------------+----------------------------------------------+ - | :cpp:func:`xt::round` | nearest integers, rounding away from zero | - +---------------------------+----------------------------------------------+ - | :cpp:func:`xt::nearbyint` | nearest integers using current rounding mode | - +---------------------------+----------------------------------------------+ - | :cpp:func:`xt::rint` | nearest integers using current rounding mode | - +---------------------------+----------------------------------------------+ - -.. toctree:: - - classif_functions - -.. table:: - :widths: 30 70 - - +--------------------------+----------------------------------+ - | :cpp:func:`xt::isfinite` | checks for finite values | - +--------------------------+----------------------------------+ - | :cpp:func:`xt::isinf` | checks for infinite values | - +--------------------------+----------------------------------+ - | :cpp:func:`xt::isnan` | checks for NaN values | - +--------------------------+----------------------------------+ - | :cpp:func:`xt::isclose` | element-wise closeness detection | - +--------------------------+----------------------------------+ - | :cpp:func:`xt::allclose` | closeness reduction | - +--------------------------+----------------------------------+ - -.. toctree:: - - reducing_functions - -.. table:: - :widths: 30 70 - - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::sum` | sum of elements over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::prod` | product of elements over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::mean` | mean of elements over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::average` | weighted average along the specified axis | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::variance` | variance of elements over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::stddev` | standard deviation of elements over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::diff` | Calculate the n-th discrete difference along the given axis | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::amax` | amax of elements over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::amin` | amin of elements over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::trapz` | Integrate along the given axis using the composite trapezoidal rule | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_l0` | L0 pseudo-norm over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_l1` | L1 norm over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_sq` | Squared L2 norm over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_l2` | L2 norm over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_linf` | Infinity norm over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_lp_to_p` | p_th power of Lp norm over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_lp` | Lp norm over given axes | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_induced_l1` | Induced L1 norm of a matrix | - +-----------------------------------+---------------------------------------------------------------------+ - | :cpp:func:`xt::norm_induced_linf` | Induced L-infinity norm of a matrix | - +-----------------------------------+---------------------------------------------------------------------+ - -.. toctree:: - - accumulating_functions - -.. table:: - :widths: 30 70 - - +-------------------------+------------------------------------------------+ - | :cpp:func:`xt::cumsum` | Cumulative sum of elements over a given axis | - +-------------------------+------------------------------------------------+ - | :cpp:func:`xt::cumprod` | Cumulative product of elements over given axes | - +-------------------------+------------------------------------------------+ - -.. toctree:: - - nan_functions - -.. table:: - :widths: 30 70 - - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nan_to_num` | Convert NaN and +/- inf to finite numbers | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nanmin` | Min of elements over a given axis, ignoring NaNs | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nanmax` | Max of elements over a given axis, ignoring NaNs | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nansum` | Sum of elements over a given axis, replacing NaN with 0 | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nanprod` | Product of elements over given axes, replacing NaN with 1 | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nancumsum` | Cumulative sum of elements over a given axis, replacing NaN with 0 | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nancumprod` | Cumulative product of elements over given axes, replacing NaN with 1 | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nanmean` | Mean of elements over given axes, ignoring NaNs | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nanvar` | Variance of elements over given axes, ignoring NaNs | - +----------------------------+----------------------------------------------------------------------+ - | :cpp:func:`xt::nanstd` | Standard deviation of elements over given axes, ignoring NaNs | - +----------------------------+----------------------------------------------------------------------+ diff --git a/docs/source/api/xnpy.rst b/docs/source/api/xnpy.rst deleted file mode 100644 index 0c1f3320a..000000000 --- a/docs/source/api/xnpy.rst +++ /dev/null @@ -1,18 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xnpy: read/write NPY files -========================== - -Defined in ``xtensor/io/xnpy.hpp`` - -.. doxygenfunction:: xt::load_npy(std::istream&) - -.. doxygenfunction:: xt::load_npy(const std::string&) - -.. doxygenfunction:: xt::dump_npy(const std::string&, const xexpression&) - -.. doxygenfunction:: xt::dump_npy(const xexpression&) diff --git a/docs/source/api/xoptional_assembly.rst b/docs/source/api/xoptional_assembly.rst deleted file mode 100644 index e40d6bd9a..000000000 --- a/docs/source/api/xoptional_assembly.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xoptional_assembly -================== - -Defined in ``xtensor/optional/xoptional_assembly.hpp`` - -.. doxygenclass:: xt::xoptional_assembly - :members: diff --git a/docs/source/api/xoptional_assembly_adaptor.rst b/docs/source/api/xoptional_assembly_adaptor.rst deleted file mode 100644 index f58c06690..000000000 --- a/docs/source/api/xoptional_assembly_adaptor.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xoptional_assembly_adaptor -========================== - -Defined in ``xtensor/optional/xoptional_assembly.hpp`` - -.. doxygenclass:: xt::xoptional_assembly_adaptor - :members: diff --git a/docs/source/api/xoptional_assembly_base.rst b/docs/source/api/xoptional_assembly_base.rst deleted file mode 100644 index 37fa07427..000000000 --- a/docs/source/api/xoptional_assembly_base.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xoptional_assembly_base -======================= - -Defined in ``xtensor/optional/xoptional_assembly_base.hpp`` - -.. doxygenclass:: xt::xoptional_assembly_base - :members: diff --git a/docs/source/api/xpad.rst b/docs/source/api/xpad.rst deleted file mode 100644 index 971a14d04..000000000 --- a/docs/source/api/xpad.rst +++ /dev/null @@ -1,22 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xpad -==== - -Defined in ``xtensor/misc/xpad.hpp`` - -.. doxygenenum:: xt::pad_mode - -.. doxygenfunction:: xt::pad(E&& , const std::vector>&, pad_mode, V) - -.. doxygenfunction:: xt::pad(E&& , const std::vector&, pad_mode, V) - -.. doxygenfunction:: xt::pad(E&& , S, pad_mode, V) - -.. doxygenfunction:: xt::tile(E&& , std::initializer_list) - -.. doxygenfunction:: xt::tile(E&& , S) diff --git a/docs/source/api/xrandom.rst b/docs/source/api/xrandom.rst deleted file mode 100644 index c2040e48c..000000000 --- a/docs/source/api/xrandom.rst +++ /dev/null @@ -1,55 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xrandom -======= - -Defined in ``xtensor/generators/xrandom.hpp`` - -.. warning:: xtensor uses a lazy generator for random numbers. You need to assign them or use ``eval`` to keep the generated values consistent. - -.. doxygenfunction:: xt::random::get_default_random_engine - -.. doxygenfunction:: xt::random::seed - -.. doxygenfunction:: xt::random::rand(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::randint(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::randn(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::binomial(const S&, T, D, E&) - -.. doxygenfunction:: xt::random::geometric(const S&, D, E&) - -.. doxygenfunction:: xt::random::negative_binomial(const S&, T, D, E&) - -.. doxygenfunction:: xt::random::poisson(const S&, D, E&) - -.. doxygenfunction:: xt::random::exponential(const S&, T, E&) - -.. doxygenfunction:: xt::random::gamma(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::weibull(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::extreme_value(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::lognormal(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::chi_squared(const S&, T, E&) - -.. doxygenfunction:: xt::random::cauchy(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::fisher_f(const S&, T, T, E&) - -.. doxygenfunction:: xt::random::student_t(const S&, T, E&) - -.. doxygenfunction:: xt::random::choice(const xexpression&, std::size_t, bool, E&) -.. doxygenfunction:: xt::random::choice(const xexpression&, std::size_t, const xexpression&, bool, E&) - -.. doxygenfunction:: xt::random::shuffle - -.. doxygenfunction:: xt::random::permutation(T, E&) diff --git a/docs/source/api/xreducer.rst b/docs/source/api/xreducer.rst deleted file mode 100644 index 4e896e099..000000000 --- a/docs/source/api/xreducer.rst +++ /dev/null @@ -1,20 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xreducer -======== - -Defined in ``xtensor/reducers/xreducer.hpp`` - -.. doxygenclass:: xt::xreducer - :members: - -Available overload families ---------------------------- - -- ``xt::reduce(f, e, axes, options)`` -- ``xt::reduce(f, e, options)`` -- ``xt::reduce(f, e, const I (&axes)[N], options)`` diff --git a/docs/source/api/xrepeat.rst b/docs/source/api/xrepeat.rst deleted file mode 100644 index 5e3db7c82..000000000 --- a/docs/source/api/xrepeat.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xrepeat -======= - -Defined in ``xtensor/views/xrepeat.hpp`` - -.. doxygenclass:: xt::xrepeat - :members: diff --git a/docs/source/api/xsemantic_base.rst b/docs/source/api/xsemantic_base.rst deleted file mode 100644 index c6062cf91..000000000 --- a/docs/source/api/xsemantic_base.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xsemantic_base -============== - -Defined in ``xtensor/core/xsemantic.hpp`` - -.. doxygenclass:: xt::xsemantic_base - :members: diff --git a/docs/source/api/xset_operation.rst b/docs/source/api/xset_operation.rst deleted file mode 100644 index 14ea65cda..000000000 --- a/docs/source/api/xset_operation.rst +++ /dev/null @@ -1,21 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xset_operation -============== - -Defined in ``xtensor/misc/xset_operation.hpp`` - -``xt::searchsorted(a, v, right)`` returns insertion indices for values ``v`` -in the sorted array ``a``. - -Available functions -------------------- - -- ``xt::isin(element, test_elements)`` -- ``xt::in1d(element, test_elements)`` -- ``xt::isin(element, begin, end)`` -- ``xt::in1d(element, begin, end)`` diff --git a/docs/source/api/xshape.rst b/docs/source/api/xshape.rst deleted file mode 100644 index 72f28b2ea..000000000 --- a/docs/source/api/xshape.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xshape -====== - -Defined in ``xtensor/core/xshape.hpp`` - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xshape - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xsort.rst b/docs/source/api/xsort.rst deleted file mode 100644 index 082532d52..000000000 --- a/docs/source/api/xsort.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xsort -===== - -Defined in ``xtensor/misc/xsort.hpp`` - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xsort - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xstrided_view.rst b/docs/source/api/xstrided_view.rst deleted file mode 100644 index 351b09da9..000000000 --- a/docs/source/api/xstrided_view.rst +++ /dev/null @@ -1,21 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xstrided_view -============= - -Defined in ``xtensor/views/xstrided_view.hpp`` - -.. doxygenclass:: xt::xstrided_view - :members: - -.. doxygentypedef:: xt::xstrided_slice_vector - -.. doxygenfunction:: xt::strided_view(E&&, S&&, X&&, std::size_t, layout_type) - -.. doxygenfunction:: xt::strided_view(E&&, const xstrided_slice_vector&) - -.. doxygenfunction:: xt::reshape_view(E&&, S&&, layout_type) diff --git a/docs/source/api/xstrides.rst b/docs/source/api/xstrides.rst deleted file mode 100644 index a09540557..000000000 --- a/docs/source/api/xstrides.rst +++ /dev/null @@ -1,16 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xstrides -======== - -Defined in ``xtensor/core/xstrides.hpp`` - -.. cpp:namespace-push:: xt - -.. doxygengroup:: xt_xstrides - -.. cpp:namespace-pop:: diff --git a/docs/source/api/xtensor.rst b/docs/source/api/xtensor.rst deleted file mode 100644 index f896da812..000000000 --- a/docs/source/api/xtensor.rst +++ /dev/null @@ -1,23 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xtensor -======= - -Defined in ``xtensor/containers/xtensor.hpp`` - -.. doxygenclass:: xt::xtensor_container - :members: - -.. doxygentypedef:: xt::xtensor - -.. doxygentypedef:: xt::xtensor_optional - -.. doxygenfunction:: xt::from_indices - -.. doxygenfunction:: xt::flatten_indices - -.. doxygenfunction:: xt::ravel_indices diff --git a/docs/source/api/xtensor_adaptor.rst b/docs/source/api/xtensor_adaptor.rst deleted file mode 100644 index 84e21f23e..000000000 --- a/docs/source/api/xtensor_adaptor.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xtensor_adaptor -=============== - -Defined in ``xtensor/containers/xtensor.hpp`` - -.. doxygenclass:: xt::xtensor_adaptor - :members: diff --git a/docs/source/api/xview.rst b/docs/source/api/xview.rst deleted file mode 100644 index d9e72ad72..000000000 --- a/docs/source/api/xview.rst +++ /dev/null @@ -1,34 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xview -===== - -Defined in ``xtensor/views/xview.hpp`` - -.. doxygenclass:: xt::xview - -.. doxygenfunction:: xt::view - -.. doxygenfunction:: xt::row - -.. doxygenfunction:: xt::col - -Defined in ``xtensor/views/xslice.hpp`` - -.. doxygenfunction:: xt::range(A, B) - -.. doxygenfunction:: xt::range(A, B, C) - -.. doxygenfunction:: xt::all - -.. doxygenfunction:: xt::newaxis - -.. doxygenfunction:: xt::ellipsis - -.. doxygenfunction:: xt::keep(T&&) - -.. doxygenfunction:: xt::drop(T&&) diff --git a/docs/source/api/xview_semantic.rst b/docs/source/api/xview_semantic.rst deleted file mode 100644 index 211b27223..000000000 --- a/docs/source/api/xview_semantic.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -xview_semantic -============== - -Defined in ``xtensor/core/xsemantic.hpp`` - -.. doxygenclass:: xt::xview_semantic - :members: diff --git a/docs/source/binder-logo.svg b/docs/source/binder-logo.svg deleted file mode 100644 index d288b74fd..000000000 --- a/docs/source/binder-logo.svg +++ /dev/null @@ -1,36 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/source/bindings.rst b/docs/source/bindings.rst deleted file mode 100644 index 54a2a09f0..000000000 --- a/docs/source/bindings.rst +++ /dev/null @@ -1,286 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Designing language bindings with xtensor -======================================== - -xtensor and its :ref:`related-projects` make it easy to implement a feature once in C++ and expose it -to the main languages of data science, such as Python, Julia and R with little extra work. Although, -if that sounds simple in principle, difficulties may appear when it comes to define the API of the -C++ library. -The following illustrates the different options we have with the case of a single function ``compute`` -that must be callable from all the languages. - -Generic API ------------ - -Since the xtensor bindings provide different container types for holding tensors (pytensor, rtensor -and jltensor), if we want our function to be callable from all the languages, it must accept a generic -argument: - -.. code:: - - template - void compute(E&& e); - -However, this is a bit too generic and we may want to enforce that this function only accepts xtensor -arguments. Since all xtensor containers inherit from the “xexpression” CRTP base class, we can easily -express that constraint with the following signature: - -.. code:: - - template - void compute(const xexpression& e) - { - // Now the implementation must use e() instead of e - } - -Notice that with this change, we lose the ability to call the function with non-constant references or -rvalue references. If we want them back, we need to add the following overloads: - -.. code:: - - template - void compute(xexpression& e); - - template - void compute(xexpression&& e); - -In the following we assume that the constant reference overload is enough. We can now expose the compute -function to the other languages, let’s illustrate this with Python bindings: - -.. code:: - - PYBIND11_MODULE(pymod, m) - { - xt::import_numpy(); - - m.def("compute", &compute>); - } - -Full qualified API ------------------- - -Accepting any kind of expression can still be too permissive; assume we want to restrict this function to -2-dimensional tensor containers only. In that case, a solution is to provide an API function that forwards -the call to a common generic implementation: - -.. code:: - - namespace detail - { - template - void compute_impl(E&&); - } - - template - void compute(const xtensor& t) - { - detail::compute_impl(t); - } - -Exposing it to the Python is just as simple: - -.. code:: - - template - void compute(const pytensor& t) - { - detail::compute_impl(t); - } - - PYBIND11_MODULE(pymod, m) - { - xt::import_numpy(); - - m.def("compute", &compute); - } - -Although this solution is really simple, it requires writing four additional functions for the API. Besides, -if later, you decide to support array containers, you need to add four more functions. Therefore this solution -should be considered for libraries with a small number of functions to expose, and whose APIs are unlikely to -change in the future. - -Container selection -------------------- - -A way to keep the restriction on the parameter type while limiting the required amount of typing in the bindings -is to rely on additional structures that will “select” the right type for us. - -The idea is to define a structure for selecting the type of containers (tensor, array) and a structure to select -the library implementation of that container (xtensor, pytensor in the case of a tensor container): - -.. code:: - - // library container selector - struct xtensor_c - { - }; - - // container selector, must be specialized for each - // library container selector - template - struct tensor_container; - - // Specialization for xtensor library (or C++) - template - struct tensor_container - { - using type = xt::xtensor; - }; - - template - using tensor_container_t = typename tensor_container::type; - -The function signature then becomes - -.. code:: - - template - void compute(const tensor_container_t& t); - -The Python bindings only require that we specialize the ``tensor_container`` structure - -.. code:: - - struct pytensor_c - { - }; - - template - struct tensor_container - { - using type = pytensor; - }; - - PYBIND11_MODULE(pymod, m) - { - xt::import_numpy(); - - m.def("compute", &compute); - } - -Even if we need to specialize the “tensor_container” structure for each language, the specialization can be -reused for other functions and thus reduce the amount of typing required. This comes at a cost though: we’ve -lost type inference on the C++ side. - -.. code:: - - xt::xtensor t {{1., 2., 3.}, {4., 5., 6.}}; - - compute(t); // works - compute(t); // error (couldn't infer template argument 'T') - -Besides, if later we want to support arrays, we need to add an “array_container” structure and its specializations, -and an overload of the compute function: - -.. code:: - - template - struct array_container; - - template - struct array_container - { - using type = xt::xarray; - }; - - template - using array_container_t = typename array_container::type; - - template - void compute(const array_container_t& t); - -Type restriction with SFINAE ----------------------------- - -The major drawback of the previous option is the loss of type inference in C++. The only means to get it back -is to reintroduce a generic parameter type. However, we can make the compiler generate an invalid type so the -function is removed from the overload resolution set when the actual type of the argument does not satisfy -some constraint. This principle is known as SFINAE (Substitution Failure Is Not An Error). Modern C++ provide -metafunctions to help us make use of SFINAE: - -.. code:: - - template - struct is_tensor : std::false_type - { - }; - - template - struct is_tensor> : std::true_type - { - }; - - template class C = is_tensor, - std::enable_if_t::value, bool> = true> - void compute(const T& t); - -Here when ``C::value`` is true, the ``enable_if_t`` invocation generates the bool type. Otherwise, it does -not generate anything, leading to an invalid function declaration. The compiler removes this declaration from -the overload resolution set and no error happens if another “compute” overload is a good match for the call. -Otherwise, the compiler emits an error. - -The default value is here to avoid the need to pass a boolean value when invoking the ``compute`` function; this -value is of no use, we only rely on the SFINAE trick. - -This declaration has a slight problem: adding ``enable_if_t`` to the signature of each function we want to expose -is cumbersome. Let’s make this part more expressive: - -.. code:: - - template class C, class T> - using check_constraints = std::enable_if_t::value, bool>; - template class C = is_tensor, - check_constraints = true> - void compute(const T& t); - -All good, we have type inference and an expressive syntax for declaring our function. Besides, if we want to relax -the constraint so the function can accept both tensors and arrays, all we have to do is to replace the default value -for C: - -.. code:: - - // Equivalent to is_tensor::value || is_array::value - template - struct is_container : xtl::disjunction, is_array> - { - }; - - template class C = is_container, - check_constraints = true> - void compute(const T& t); - -This is far more flexible than the previous option. This flexibility comes at a minor cost: exposing the function to -the Python is slightly more verbose: - -.. code:: - - template - struct is_tensor> : std::true_type - { - }; - - PYBIND11_MODULE(pymod, m) - { - xt::import_numpy(); - - m.def("compute", &compute>); - } - -Conclusion ----------- - -Each solution has its pros and cons and choosing one of them should be done according to the flexibility you want to -impose on your API and the constraints you are imposed by the implementation. For instance, a method that requires a -lot of typing in the bindings might not suit for libraries with a huge number of functions to expose, while a full -generic API might be problematic if the implementation expects containers only. Below is a summary of the advantages -and drawbacks of the different options: - -- Generic API: full genericity, no additional typing required in the bindings, but maybe too permissive. -- Full qualified API: simple, accepts only the specified parameter type, but requires a lot of typing for the bindings. -- Container selection: quite simple, requires less typing than the previous method, but loses type inference on the C++ side and lacks some flexibility. -- Type restriction with SFINAE: more flexible than the previous option, gets type inference back, but slightly more complex to implement. diff --git a/docs/source/build-options.rst b/docs/source/build-options.rst deleted file mode 100644 index 25e32ceb9..000000000 --- a/docs/source/build-options.rst +++ /dev/null @@ -1,123 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -.. _build-configuration: - -Build and configuration -======================= - -Configuration -------------- - -*xtensor* can be configured via macros which must be defined *before* including -any of its headers. This can be achieved the following ways: - -- either define them in the CMakeLists of your project, with ``target_compile_definitions`` - cmake command. -- or create a header where you define all the macros you want and then include the headers you - need. Then include this header whenever you need *xtensor* in your project. - -The following macros are already defined in *xtensor* but can be overwritten: - -- ``XTENSOR_DEFAULT_DATA_CONTAINER(T, A)``: defines the type used as the default data container for tensors and arrays. ``T`` - is the ``value_type`` of the container and ``A`` its ``allocator_type``. -- ``XTENSOR_DEFAULT_SHAPE_CONTAINER(T, EA, SA)``: defines the type used as the default shape container for tensors and arrays. - ``T`` is the ``value_type`` of the data container, ``EA`` its ``allocator_type``, and ``SA`` is the ``allocator_type`` - of the shape container. -- ``XTENSOR_DEFAULT_LAYOUT``: defines the default layout (row_major, column_major, dynamic) for tensors and arrays. We *strongly* - discourage using this macro, which is provided for testing purpose. Prefer defining alias types on tensor and array - containers instead. -- ``XTENSOR_DEFAULT_TRAVERSAL``: defines the default traversal order (row_major, column_major) for algorithms and iterators on tensors - and arrays. We *strongly* discourage using this macro, which is provided for testing purpose. - -The following macros are helpers for debugging, they are not defined by default: - -- ``XTENSOR_ENABLE_ASSERT``: enables assertions in *xtensor*, such as bound check. -- ``XTENSOR_ENABLE_CHECK_DIMENSION``: enables the dimensions check in *xtensor*. Note that this option should not be turned - on if you expect ``operator()`` to perform broadcasting. - -.. _external-dependencies: - -External dependencies ---------------------- - -The last group of macros is for using external libraries to achieve maximum performance (see next section for additional -requirements): - -- ``XTENSOR_USE_XSIMD``: enables SIMD acceleration in *xtensor*. This requires that you have xsimd_ installed - on your system. -- ``XTENSOR_USE_TBB``: enables parallel assignment loop. This requires that you have tbb_ installed - on your system. -- ``XTENSOR_DISABLE_EXCEPTIONS``: disables c++ exceptions. -- ``XTENSOR_USE_OPENMP``: enables parallel assignment loop using OpenMP. This requires that OpenMP is available on your system. - -Defining these macros in the CMakeLists of your project before searching for *xtensor* will trigger automatic finding -of dependencies, so you don't have to include the ``find_package(xsimd)`` and ``find_package(TBB)`` commands in your -CMakeLists: - -.. code:: cmake - - set(XTENSOR_USE_XSIMD 1) - set(XTENSOR_USE_TBB 1) - # xsimd and TBB dependencies are automatically - # searched when the following is executed - find_package(xtensor REQUIRED) - - # the target now sets the proper defines (e.g. "XTENSOR_USE_XSIMD") - target_link_libraries(... xtensor) - - -Build and optimization ----------------------- - -Windows -~~~~~~~ - -Windows users must activate the ``/bigobj`` flag, otherwise it's almost certain that the compilation fails. More generally, -the following options are recommended: - -.. code:: cmake - - target_link_libraries(... xtensor xtensor::optimize) - set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO) - - # OR - - target_compile_options(target_name PRIVATE /EHsc /MP /bigobj) - set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO) - -If you defined ``XTENSOR_USE_XSIMD``, you must also specify which instruction set you target: - -.. code:: cmake - - target_compile_options(target_name PRIVATE /arch:AVX2) - # OR - target_compile_options(target_name PRIVATE /arch:AVX) - # OR - target_compile_options(target_name PRIVATE /arch:ARMv7VE) - -If you build on an old system that does not support any of these instruction sets, you don't have to specify -anything, the system will do its best to enable the most recent supported instruction set. - -Linux/OSX -~~~~~~~~~ - -Whether you enabled ``XTENSOR_USE_XSIMD`` or not, it is highly recommended to build with ``-march=native`` option, -if your compiler supports it: - -.. code:: cmake - - target_link_libraries(... xtensor xtensor::optimize) - - # OR - - target_compile_options(target_name PRIVATE -march=native) - -Notice that this option prevents building on a machine and distributing the resulting binary on another machine with -a different architecture (i.e. not supporting the same instruction set). - -.. _xsimd: https://github.com/xtensor-stack/xsimd -.. _tbb: https://github.com/uxlfoundation/oneTBB diff --git a/docs/source/builder.rst b/docs/source/builder.rst deleted file mode 100644 index 04b193def..000000000 --- a/docs/source/builder.rst +++ /dev/null @@ -1,82 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Expression builders -=================== - -*xtensor* provides functions to ease the build of common N-dimensional expressions. The expressions -returned by these functions implement the laziness of *xtensor*, that is, they don't hold any value. -Values are computed upon request. - -Ones and zeros --------------- - -- :cpp:func:`xt::zeros(shape) `: generates an expression containing zeros of the specified shape. -- :cpp:func:`xt::ones(shape) `: generates an expression containing ones of the specified shape. -- :cpp:func:`xt::eye(shape, k=0) `: generates an expression of the specified shape, with ones on the k-th diagonal. -- :cpp:func:`xt::eye(n, k = 0) `: generates an expression of shape ``(n, n)`` with ones on the k-th diagonal. - -Numerical ranges ----------------- - -- :cpp:func:`xt::arange(start=0, stop, step=1) `: generates numbers evenly spaced within given half-open interval. -- :cpp:func:`xt::linspace(start, stop, num_samples) `: generates num_samples evenly spaced numbers over given interval. -- :cpp:func:`xt::logspace(start, stop, num_samples) `: generates num_samples evenly spaced on a log scale over given interval - -Joining expressions -------------------- - -- :cpp:func:`xt::concatenate(tuple, axis=0) `: concatenates a list of expressions along the given axis. -- :cpp:func:`xt::stack(tuple, axis=0) `: stacks a list of expressions along the given axis. -- :cpp:func:`xt::hstack(tuple) `: stacks expressions in sequence horizontally (i.e. column-wise). -- :cpp:func:`xt::vstack(tuple) `: stacks expressions in sequence vertically (i.e. row wise). - -Random distributions --------------------- - -.. warning:: xtensor uses a lazy generator for random numbers. - You need to assign them or use :cpp:func:`xt::eval` to keep the generated values consistent. - -- :cpp:func:`xt::random::rand(shape, lower, upper) `: generates an expression of the specified - shape, containing uniformly distributed random numbers in the half-open interval [lower, upper). -- :cpp:func:`xt::random::randint(shape, lower, upper) `: generates an expression of the specified - shape, containing uniformly distributed random integers in the half-open interval [lower, upper). -- :cpp:func:`xt::random::randn(shape, mean, std_dev) `: generates an expression of the specified - shape, containing numbers sampled from the Normal random number distribution. -- :cpp:func:`xt::random::binomial(shape, trials, prob) `: generates an expression of the specified - shape, containing numbers sampled from the binomial random number distribution. -- :cpp:func:`xt::random::geometric(shape, prob) `: generates an expression of the specified shape, - containing numbers sampled from the geometric random number distribution. -- :cpp:func:`xt::random::negative_binomial(shape, k, prob) `: generates an expression - of the specified shape, containing numbers sampled from the negative binomial random number distribution. -- :cpp:func:`xt::random::poisson(shape, rate) `: generates an expression of the specified shape, - containing numbers sampled from the Poisson random number distribution. -- :cpp:func:`xt::random::exponential(shape, rate) `: generates an expression of the specified - shape, containing numbers sampled from the exponential random number distribution. -- :cpp:func:`xt::random::gamma(shape, alpha, beta) `: generates an expression of the specified shape, - containing numbers sampled from the gamma random number distribution. -- :cpp:func:`xt::random::weibull(shape, a, b) `: generates an expression of the specified shape, - containing numbers sampled from the Weibull random number distribution. -- :cpp:func:`xt::random::extreme_value(shape, a, b) `: generates an expression of the - specified shape, containing numbers sampled from the extreme value random number distribution. -- :cpp:func:`xt::random::lognormal(shape, a, b) `: generates an expression of the specified - shape, containing numbers sampled from the Log-Normal random number distribution. -- :cpp:func:`xt::random::chi_squared(shape, a, b) `: generates an expression of the specified - shape, containing numbers sampled from the chi-squared random number distribution. -- :cpp:func:`xt::random::cauchy(shape, a, b) `: generates an expression of the specified shape, - containing numbers sampled from the Cauchy random number distribution. -- :cpp:func:`xt::random::fisher_f(shape, m, n) `: generates an expression of the specified shape, - containing numbers sampled from the Fisher-f random number distribution. -- :cpp:func:`xt::random::student_t(shape, n) `: generates an expression of the specified shape, - containing numbers sampled from the Student-t random number distribution. - -Meshes ------- - -- :cpp:func:`xt::meshgrid(x1, x2,...) `: generates N-D coordinate expressions given - one-dimensional coordinate arrays ``x1``, ``x2``... - If specified vectors have lengths ``Ni = len(xi)``, meshgrid returns ``(N1, N2, N3,..., Nn)``-shaped arrays, with the elements - of xi repeated to fill the matrix along the first dimension for x1, the second for x2 and so on. diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst deleted file mode 100644 index 982773051..000000000 --- a/docs/source/changelog.rst +++ /dev/null @@ -1,2391 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Changelog -========= - -0.27.1 ------- - -- Add tagfiles to support fetching documentation with xeus-cpp-lite - `# 2862 https://github.com/xtensor-stack/xtensor/pull/2862` - -0.27.0 ------- - -- Replaced apply_cv with xtl::apply_cv and deleted duplicated code - `# 2836 https://github.com/xtensor-stack/xtensor/pull/2836` -- Implement apply with std 17 - `# 2835 https://github.com/xtensor-stack/xtensor/pull/2835` -- feat: Use cpp20 by default - `# 2839 https://github.com/xtensor-stack/xtensor/pull/2839` -- Set C++20 in clang-format - `# 2843 https://github.com/xtensor-stack/xtensor/pull/2843` -- Update docs to reflect new directory structure. - `# 2845 https://github.com/xtensor-stack/xtensor/pull/2845` -- Adding concept to a part of the code - `# 2842 https://github.com/xtensor-stack/xtensor/pull/2842` -- fix: update benchmarks - `# 2848 https://github.com/xtensor-stack/xtensor/pull/2848` -- Revive benchmarks - `# 2854 https://github.com/xtensor-stack/xtensor/pull/2854` -- Set cmake min version to represent used features. - `# 2852 https://github.com/xtensor-stack/xtensor/pull/2852` -- Enabling rich display for xeus-cpp-lite - `# 2853 https://github.com/xtensor-stack/xtensor/pull/2853` -- Add braces around initializers - `# 2855 https://github.com/xtensor-stack/xtensor/pull/2855` -- Adding concept to a part of the code (part 2) - `# 2846 https://github.com/xtensor-stack/xtensor/pull/2846` -- cmake: write xtensor.hpp to local dir to keep global build dir clean - `# 2857 https://github.com/xtensor-stack/xtensor/pull/2857` - -0.26.0 ------- - -- Adding the ability to enable memory overlap check in assignment to avoid unneeded temporary memory allocation - `# 2768 https://github.com/xtensor-stack/xtensor/pull/2768` -- Pure xtensor FFT implementation - `# 2782 https://github.com/xtensor-stack/xtensor/pull/2782` -- Update for C++ 20 compatibility - `# 2774 https://github.com/xtensor-stack/xtensor/pull/2774` -- Fixed CI added OSX 13 and GCC 12 - `# 2796 https://github.com/xtensor-stack/xtensor/pull/2796` -- Fix compile issue with clang 19.1.1 - `# 2813 https://github.com/xtensor-stack/xtensor/pull/2813` -- Avoid warnings in compiler version checks - `# 2781 https://github.com/xtensor-stack/xtensor/pull/2781` -- Bump OSX Version 12 -> 13 to avoid deprecated environment - `# 2818 https://github.com/xtensor-stack/xtensor/pull/2818` -- Update gh-pages.yml - `# 2824 https://github.com/xtensor-stack/xtensor/pull/2824` -- Upgraded to xsimd 13.2.0 - `# 2825 https://github.com/xtensor-stack/xtensor/pull/2825` -- Added missing configuration key for RTD - `# 2826 https://github.com/xtensor-stack/xtensor/pull/2826` -- Code reorganization - `# 2829 https://github.com/xtensor-stack/xtensor/pull/2829` -- Adding fix for incorrect usage of xt::has_assign_conversion in xassig - `# 2830 https://github.com/xtensor-stack/xtensor/pull/2830` -- Upgraded to xtl 0.8.0 and C++17 - `# 2831 https://github.com/xtensor-stack/xtensor/pull/2831` -- Migrated to more recent compilers - `# 2832 https://github.com/xtensor-stack/xtensor/pull/2832` -- Fix for Clang19 - `# 2833 https://github.com/xtensor-stack/xtensor/pull/2833` - -0.25.0 ------- - -- Fix conversion warning in xrepeat - `# 2732 https://github.com/xtensor-stack/xtensor/pull/2732` -- Upraded to xsimd 11 - `# 2735 https://github.com/xtensor-stack/xtensor/pull/2735` -- Update to use XTENSOR_DEFAULT_ALIGNMENT when using XSIMD - `# 2739 https://github.com/xtensor-stack/xtensor/pull/2739` -- Removed failing test xinfo on clang 16 - `# 2740 https://github.com/xtensor-stack/xtensor/pull/2740` -- [CI] Switching to mamba-org/setup-micromamba - `# 2742 https://github.com/xtensor-stack/xtensor/pull/2742` -- Bump cmake version and resolve build issues - `# 2744 https://github.com/xtensor-stack/xtensor/pull/2744` -- Make reshape_view accept -1 as a wildcard dimension - `# 2746 https://github.com/xtensor-stack/xtensor/pull/2746` -- Fixing bug in argmin/argmax called with axis on rank-1 container - `# 2753 https://github.com/xtensor-stack/xtensor/pull/2753` -- pre-commit autoupdate - `# 2754 https://github.com/xtensor-stack/xtensor/pull/2754` -- Use L suffix for long double constants - `# 2762 https://github.com/xtensor-stack/xtensor/pull/2762` -- Use 1/4 step for testing arange - `# 2763 https://github.com/xtensor-stack/xtensor/pull/2763` -- [Optimization] Updated concatenate_access and stack_access to remove allocations - `# 2759 https://github.com/xtensor-stack/xtensor/pull/2759` -- [CI] Added more compilers - `# 2767 https://github.com/xtensor-stack/xtensor/pull/2767` -- Minor xindex_view to_array cleanup - `# 2765 https://github.com/xtensor-stack/xtensor/pull/2765` - -0.24.7 ------- - -- Adjust version of required xsimd in README - `# 2670 https://github.com/xtensor-stack/xtensor/pull/2670` -- Add CI through github actions. - `# 2692 https://github.com/xtensor-stack/xtensor/pull/2692` -- Added unwrap - `# 2710 https://github.com/xtensor-stack/xtensor/pull/2710` -- Removed repeated work from ci-extra build - `# 2711 https://github.com/xtensor-stack/xtensor/pull/2711` -- Removed bad macro definitions - `# 2712 https://github.com/xtensor-stack/xtensor/pull/2712` -- Fixing some iterator issues - `# 2564 https://github.com/xtensor-stack/xtensor/pull/2564` -- Fixed static analysis build - `# 2720 https://github.com/xtensor-stack/xtensor/pull/2720` -- Support external linkage for "recurser_run" - `# 2714 https://github.com/xtensor-stack/xtensor/pull/2714` -- add possibility to use std::stable_sort with xt::argsort - `# 2681 https://github.com/xtensor-stack/xtensor/pull/2681` - -0.24.6 ------- - -- Improving documentation xstrides - `# 2664 https://github.com/xtensor-stack/xtensor/pull/2664` -- Parallel and more aggressive strided assigner - `# 2660 https://github.com/xtensor-stack/xtensor/pull/2660` -- Removing duplicates from documentation - `# 2669 https://github.com/xtensor-stack/xtensor/pull/2669` -- Adding aliases xt::xtensor_pointer and xt::xarray_pointer - `# 2665 https://github.com/xtensor-stack/xtensor/pull/2665` -- Fix and refactor partition - `# 2652 https://github.com/xtensor-stack/xtensor/pull/2652` -- Fix and update pre-commit - `# 2657 https://github.com/xtensor-stack/xtensor/pull/2657` - -0.24.5 ------- - -- Add space before pragma diagnostic - `# 2654 https://github.com/xtensor-stack/xtensor/pull/2654` -- Update xtl requirement in cmake - `# 2649 https://github.com/xtensor-stack/xtensor/pull/2649` -- Fix a bug where .fill doesn't work for a xcontainer that is non-contiguous - `# 2650 https://github.com/xtensor-stack/xtensor/pull/2650` - - -0.24.4 ------- - -- Align qualifiers using clang-format - `# 2647 https://github.com/xtensor-stack/xtensor/pull/2647` -- Add xt::quantile - `# 2614 https://github.com/xtensor-stack/xtensor/pull/2614` -- Add swapaxes and moveaxis - `# 2638 https://github.com/xtensor-stack/xtensor/pull/2638` -- Enforce { ... } - `# 2641 https://github.com/xtensor-stack/xtensor/pull/2641` -- Manual style fixes - `# 2642 https://github.com/xtensor-stack/xtensor/pull/2642` -- Do not step further than last element in xreducer_stepper aggregation - `# 2636 https://github.com/xtensor-stack/xtensor/pull/2636` -- Upgraded to xsimd 10.0.0 - `# 2635 https://github.com/xtensor-stack/xtensor/pull/2635` -- Explicitly declare test_xtensor_core_lib as STATIC - `# 2586 https://github.com/xtensor-stack/xtensor/pull/2586` -- fix npy_file move assignment - `# 2585 https://github.com/xtensor-stack/xtensor/pull/2585` -- Install as arch-independent - `# 2588 https://github.com/xtensor-stack/xtensor/pull/2588` -- Change extended tests test header - `# 2630 https://github.com/xtensor-stack/xtensor/pull/2630` -- argmax crashes when compiled using Visual Studio compiler with O1/O2 optimizations - `# 2568 https://github.com/xtensor-stack/xtensor/pull/2568` -- Fix xindexed_view::to_end - `# 2627 https://github.com/xtensor-stack/xtensor/pull/2627` -- Change xindex_view reference type to handle const data - `# 2622 https://github.com/xtensor-stack/xtensor/pull/2622` -- Fix TBB target in CMake exported interface - `# 2617 https://github.com/xtensor-stack/xtensor/pull/2617` -- Document missing xsort functions - `# 2608 https://github.com/xtensor-stack/xtensor/pull/2608` -- Specialize get_strides_type for xbuffer_adaptor - `# 2606 https://github.com/xtensor-stack/xtensor/pull/2606` -- find external packages (threads) after defining project - `# 2575 https://github.com/xtensor-stack/xtensor/pull/2575` - -0.24.3 ------- - -- Rename and fix storage iterator - `#2534 https://github.com/xtensor-stack/xtensor/pull/2534` -- rename storage_rbegin, storage_rend, ... to linear_rbegin, ... - `#2535 https://github.com/xtensor-stack/xtensor/pull/2535` -- Enabling reference value types for xfunction. - `#2532 https://github.com/xtensor-stack/xtensor/pull/2532` -- fixing linear iterator docs. - `#2538 https://github.com/xtensor-stack/xtensor/pull/2538` -- Minor improvements for Windows (MSVC, ClangCl) support - `#2531 https://github.com/xtensor-stack/xtensor/pull/2531` -- changing static layout in xtsrided_view temporary_type to container's layout - `#2553 https://github.com/xtensor-stack/xtensor/pull/2553` -- Upgraded to xsimd 9.0.1 - `#2573 https://github.com/xtensor-stack/xtensor/pull/2573` - -0.24.2 ------- - -- Fixed the documentation of adapt functions - `#2496 https://github.com/xtensor-stack/xtensor/pull/2496` -- Updated C++20 option for visual studio builds C++2a no longer a valid std option - `#2497 https://github.com/xtensor-stack/xtensor/pull/2497` -- Simplifying argmin and argmax where possible - `#2499 https://github.com/xtensor-stack/xtensor/pull/2499` -- Removed unused code - `#2502 https://github.com/xtensor-stack/xtensor/pull/2502` -- Fixed build error in MSVC 2019 by decaying decltype to base type - `#2506 https://github.com/xtensor-stack/xtensor/pull/2506` -- Added xt::convolve - `#2507 https://github.com/xtensor-stack/xtensor/pull/2507` -- Adding reset_data to xbuffer_adaptor and reset_buffer to adaptor to replace the pointer without any reallocation - `#2521 https://github.com/xtensor-stack/xtensor/pull/2521` -- Workaround for EDG C++ frontend bug - `#2528 https://github.com/xtensor-stack/xtensor/pull/2528` -- Adding cast to deal with xtensor-python's signedness of shape - `#2510 https://github.com/xtensor-stack/xtensor/pull/2510` -- Adding missing rank to xtensor_adaptor - `#2520 https://github.com/xtensor-stack/xtensor/pull/2520` -- Fixing compiler warning - `#2522 https://github.com/xtensor-stack/xtensor/pull/2522` - -0.24.1 ------- - -- Define tbb threshold - `#2455 https://github.com/xtensor-stack/xtensor/pull/2455` -- Export link interface to tbb - `#2456 https://github.com/xtensor-stack/xtensor/pull/2456` -- has_trivial_default_constructor has been removed from libstdc++ since version 7. - `#2459 https://github.com/xtensor-stack/xtensor/pull/2459` -- Added missing headers in CMake - `#2462 https://github.com/xtensor-stack/xtensor/pull/2462` -- Workaround for CMake implementations that do not use C and CXX languages - `#2467 https://github.com/xtensor-stack/xtensor/pull/2467` -- Fix erroneous less_equal usage in is_sorted calls - `#2471 https://github.com/xtensor-stack/xtensor/pull/2471` -- Adding xt::missing to operator() - `#2488 https://github.com/xtensor-stack/xtensor/pull/2488` -- Silence unused variable warning GCC - `#2494 https://github.com/xtensor-stack/xtensor/pull/2494` -- Adding xt::missing functionality to .periodic(...), .at(...), and .in_bounds(...) - `#2493 https://github.com/xtensor-stack/xtensor/pull/2493` -- Fixing internal types - `#2492 https://github.com/xtensor-stack/xtensor/pull/2492` -- Adding size assertion .flat(i) + adding a few tests on size assertions - `#2388 https://github.com/xtensor-stack/xtensor/pull/2388` -- Adding free function xt::strides - `#2489 https://github.com/xtensor-stack/xtensor/pull/2489` - -0.24.0 ------- - -- Comparison of shapes with differnt types is now supported - `#2393 https://github.com/xtensor-stack/xtensor/pull/2393` -- Ported tests to doctest - `#2405 https://github.com/xtensor-stack/xtensor/pull/2405` -- Updated docs of argmin and argmax - `#2425 https://github.com/xtensor-stack/xtensor/pull/2425` -- blockwise reducers intital implementation - `#2415 https://github.com/xtensor-stack/xtensor/pull/2415` -- Fixed comparison of double in some tests - `#2436 https://github.com/xtensor-stack/xtensor/pull/2436` -- Upgraded to xsimd 8 - `#2438 https://github.com/xtensor-stack/xtensor/pull/2438` - -0.23.10 -------- - -- Performance fix: set m_strides_computed = true after computing - `#2377 https://github.com/xtensor-stack/xtensor/pull/2377` -- argsort: catching zeros stride leading axis (bugfix) - `#2238 https://github.com/xtensor-stack/xtensor/pull/2238` -- Adding ``.flat(i)`` - `#2356 https://github.com/xtensor-stack/xtensor/pull/2356` -- Fixed ``check_index`` function - `#2378 https://github.com/xtensor-stack/xtensor/pull/2378` -- Fixing & -> && in histogram - `#2386 https://github.com/xtensor-stack/xtensor/pull/2386` -- Adding ``front()`` and ``back()`` convenience methods - `#2385 https://github.com/xtensor-stack/xtensor/pull/2385` -- Adding description of index operators - `#2387 https://github.com/xtensor-stack/xtensor/pull/2387` -- flip: adding overload without axis (mimics NumPy) - `#2373 https://github.com/xtensor-stack/xtensor/pull/2373` -- average: fixing overload issue for axis argument - `#2374 https://github.com/xtensor-stack/xtensor/pull/2374` - -0.23.9 ------- - -- Fix data_offset method in xview to compute the strides only once - `#2371 https://github.com/xtensor-stack/xtensor/pull/2371` - -0.23.8 ------- - -- Specialize operator= when RHS is chunked - `#2367 https://github.com/xtensor-stack/xtensor/pull/2367` - -0.23.7 ------- - -- Fixed chunked_iterator - `#2365 https://github.com/xtensor-stack/xtensor/pull/2365` - -0.23.6 ------- - -- Update installation instructions to mention mamba - `#2357 https://github.com/xtensor-stack/xtensor/pull/2357` -- Fixed grid_shape return type - `#2360 https://github.com/xtensor-stack/xtensor/pull/2360` -- Added assertion in resize method - `#2361 https://github.com/xtensor-stack/xtensor/pull/2361` -- Added const chunk iterators - `#2362 https://github.com/xtensor-stack/xtensor/pull/2362` -- Fixed chunk assignment - `#2363 https://github.com/xtensor-stack/xtensor/pull/2363` - -0.23.5 ------- - -- No need to explicitly install blas anymore with latest xtensor-blas - `#2343 https://github.com/xtensor-stack/xtensor/pull/2343` -- FIX for xtensor-stack/xtl/issues/245 - `#2344 https://github.com/xtensor-stack/xtensor/pull/2344` -- Implement grid view - `#2346 https://github.com/xtensor-stack/xtensor/pull/2346` -- Refactoring of xchunked_view - `#2353 https://github.com/xtensor-stack/xtensor/pull/2353` - -0.23.4 ------- - -- Fix edge chunk assignment - `#2342 https://github.com/xtensor-stack/xtensor/pull/2342` - -0.23.3 ------- - -- Use the correct version file for TBB since 2021.1 - `#2334 https://github.com/xtensor-stack/xtensor/pull/2334` -- Add missing API RTD for nan functions - `#2333 https://github.com/xtensor-stack/xtensor/pull/2333` -- Fixed layout issue in container classes - `#2335 https://github.com/xtensor-stack/xtensor/pull/2335` -- Fixed assignment of a tensor_view on a pseudo-container - `#2336 https://github.com/xtensor-stack/xtensor/pull/2336` -- Fixed return type of data method - `#2338 https://github.com/xtensor-stack/xtensor/pull/2338` -- Fixed assignment to flatten view - `#2339 https://github.com/xtensor-stack/xtensor/pull/2339` - -0.23.2 ------- - -- MSVC Build: Wrapped linker flags in quotes - `#2299 https://github.com/xtensor-stack/xtensor/pull/2299` -- Added can_assign and enable_assignable_expression - `#2323 https://github.com/xtensor-stack/xtensor/pull/2323` -- Fix automatically generated tests - `#2313 https://github.com/xtensor-stack/xtensor/pull/2313` -- Fix linspace endpoint bug - `#2306 https://github.com/xtensor-stack/xtensor/pull/2306` -- Added fallback to old behavior in FindTBB.cmake - `#2325 https://github.com/xtensor-stack/xtensor/pull/2325` -- Implement nanmin and nanmax - `#2314 https://github.com/xtensor-stack/xtensor/pull/2314` -- Clean up and add more tests for nanmin and nanmax - `#2326 https://github.com/xtensor-stack/xtensor/pull/2326` -- Fix linespace with only one point - `#2327 https://github.com/xtensor-stack/xtensor/pull/2327` -- Fixed ambiguous call of tile - `#2329 https://github.com/xtensor-stack/xtensor/pull/2329` - -0.23.1 ------- - -- Fix compilation warnings on unused local typedefs - `#2295 https://github.com/xtensor-stack/xtensor/pull/2295` -- Disable a failing shuffle test for clang - `#2294 https://github.com/xtensor-stack/xtensor/pull/2294` -- Fix simd assign_data - `#2292 https://github.com/xtensor-stack/xtensor/pull/2292` -- Fix -Wshadow and -Wunused-local-typedef warning - `#2293 https://github.com/xtensor-stack/xtensor/pull/2293` -- Documentation improvement Part #B - `#2287 https://github.com/xtensor-stack/xtensor/pull/2287` - -0.23.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- Remove chunked array extension mechanism - `#2283 `_ -- Upgraded to xtl 0.7.0 - `#2284 `_ - -Other changes -~~~~~~~~~~~~~ - -- Harmonize #include statements in doc - `#2280 `_ -- Added missing shape_type in xfunctor_stepper - `#2285 `_ - -0.22.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- Drop support of 3.* Clang versions - `#2251 `_ -- Fix reducers assignment - `#2254 `_ -- Removed reducer ``big_promote_type`` - `#2277 `_ - -Other changes -~~~~~~~~~~~~~ - -- Improve histogram performance with equal bin sizes - `#2088 `_ -- Added missing header in xfixed - `#2225 `_ -- Implement xt::random::choice with weights vector - `#2241 `_ -- Testing alignment - `#2246 `_ -- Add reducers tests - `#2252 `_ -- Fix binary operators on complex - `#2253 `_ -- Removed not implemented assign method from xchunked_array - `#2256 `_ -- Support initialized list for chunked_array shapes - `#2258 `_ -- Add as_strided free function - `#2261 `_ -- Fix histogram compatibility with containers beyond xtensor - `#2263 `_ -- Fixed broadcasting with keep_slice that holds a single element - `#2270 `_ -- Make xt::cast and xtl::optional compatible - `#2271 `_ -- Fix minor warnings detected by clang - `#2272 `_ -- Extra assert in mean computation wrt. ddof - `#2273 `_ -- Provide a -Werror mode and ensure xtensor passes with it - `#2274 `_ -- Moved layout_remove_any to xlayout.hpp - `#2275 `_ -- Provide a -Werror mode and ensure xtensor passes with it - `#2274 `_ -- Slight reorganization of the documentation - `#2276 `_ -- Updated reducer docs according to recent changes - `#2278 `_ -- Added template parameter for initial value type in accumulators - `#2279 `_ - -0.21.10 -------- - -- Document chunked arrays - `#2102 `_ -- Removed ``zarray`` files - `#2221 `_ -- Improved ``xeval`` - `#2223 `_ -- Fixed various warnings - `#2224 `_ - -0.21.9 ------- - -- Adding macro ``XTENSOR_SELECT_ALIGN`` - `#2152 `_ -- xcontainer.hpp: Renamed a shadowing type name inside a function - `#2208 `_ -- Add chunk_memory_layout to chunked_array factory - `#2211 `_ -- CMake: Modernized GTest-integration - `#2212 `_ -- ``xnpy.hpp``: fix multiple definition of 'host_endian_char' variable when included in different linked objects - `#2214 `_ -- Made global variable const to force internal linkage - `#2216 `_ -- Use xtl::endianness instead of bundling it - `#2218 `_ -- Fix call to resize of chunk container - `#2219 `_ - -0.21.8 ------- - -- Fix undefined behavior while testing shifts - `#2175 `_ -- Fix ``zarray`` initialization from ``zarray`` - `#2180 `_ -- Portable and generic implementation of endianess detection - `#2182 `_ -- Fix xnpy save padding computation - `#2183 `_ -- Only use ``-march=native`` if it's available - `#2184 `_ -- Fix ``xchunked_array`` assignment - `#2177 `_ -- Add specific ``xchunked_array`` constructor for ``xchunk_store_manager`` - `#2188 `_ -- Make xnpy tests aware of both little and big endian targets - `#2189 `_ -- Fixed constructors of ``xchunked_array`` - `#2190 `_ -- First implementation of ``zchunked_wrapper`` - `#2193 `_ -- Don't mark dirty a resized or reshaped ``xfile_array`` - `#2194 `_ -- Replaced catch-all constructor of ``zarray`` with more restrictive ones - `#2195 `_ -- Fixed SFINAE based on ``xchunked_store_manager`` - `#2197 `_ -- Fix generated cmake config to include missing required lib - `#2200 `_ -- Add ``set_chunk_shape`` to the first chunk of the pool - `#2198 `_ -- Chunked array refactoring - `#2201 `_ -- Refactored ``xchunked_array`` semantic - `#2202 `_ -- Added missing header to CMakeLists.txt - `#2203 `_ -- Fixed ``load_simd`` for ``xcomplex`` - `#2204 `_ -- Upgraded to xtl 0.6.20 - `#2206 `_ -- changed std traits to new ``xtl::xtraits`` - `#2205 `_ -- ``xstorage.hpp``: Renamed a shadowing variable inside a function - `#2207 `_ - -0.21.7 ------- - -- Removed zheaders from single header - `#2157 `_ -- Implemented insertion of range and intializer list in svector - `#2165 `_ -- Adding has_shape - `#2163 `_ -- Adding get_rank and has_fixed_rank - `#2162 `_ -- Zrefactoring - `#2140 `_ -- Added missing header - `#2169 `_ -- Extending docs random - `#2173 `_ - -0.21.6 ------- - -- Added implementation of ``isin`` and ``in1d`` - `#2021 `_ -- Wrote single include header - `#2031 `_ -- Added details for ``xt::random`` to docs - `#2043 `_ -- Added ``digitize``, ``searchsorted``, and ``bin_items`` - `#2037 `_ -- Fixed error with zero tensor size in ``xt::mean`` - `#2047 `_ -- Fixed initialization order in ``xfunction`` - `#2050 `_ -- ``adapt_smart_ptr`` overloads now accept STL-like container as shape - `#2052 `_ -- Added ``xchunked_array`` - `#2076 `_ -- ``xchunked_array`` inherits from ``xiterable`` - `#2082 `_ -- ``xchunked_array`` inherits from ``xcontainer_semantic`` - `#2083 `_ -- Fixed assignment operator of ``xchunked_array`` - `#2084 `_ -- Added constructors from ``xexpression`` and ``chunk_shape`` to ``xchunked_array`` - `#2087 `_ -- Fixed chunk layout - `#2091 `_ -- Copy constructor gets expression's chunk_shape if it is chunked - `#2092 `_ -- Replaced template parameter chunk_type with chunk_storage - `#2095 `_ -- Implemented on-disk chunked array - `#2096 `_ -- Implemented chunk pool in xchunk_store_manager - `#2099 `_ -- ``xfile_array`` is now an expression - `#2107 `_ -- ``xchunked_array`` code cleanup - `#2109 `_ -- ``xchunked_store_manager`` code cleanup - `#2110 `_ -- Refactored ``xfile_array`` - `#2117 `_ -- Added simd accessors to ``xfil_array_container`` - `#2118 `_ -- Abstracted file format through a formal class - `#2115 `_ -- Added ``xchunked_array`` extension template - `#2122 `_ -- Refactored ``xdisk_io_handler`` - `#2123 `_ -- Fixed exception for file write operation - `#2125 `_ -- Implemented ``zarray`` - `#2127 `_ -- Implemented the skeleton of the dynamic expression system - `#2129 `_ -- Implemented zfunctions, equivalent of xfunction for dynamic expression system - `#2130 `_ -- Implemented ``allocate_result`` in ``zfunction`` - `#2132 `_ -- Implemented assign mechanism for ``zarray`` - `#2133 `_ -- Added xindex_path to transform indexes into path - `#2131 `_ -- Fixing various compiler warnings - `#2145 `_ -- Removed conversion and initialization warnings - `#2141 `_ - -0.21.5 ------- - -- Fix segfault when using ``xt::drop`` on an empty list of indices - `#1990 `_ -- Implemented missing methods in ``xrepeat`` class - `#1993 `_ -- Added extension base to ``xrepeat`` and clean up ``xbroadcast`` - `#1994 `_ -- Fix return type of ``nanmean`` and add unittest - `#1996 `_ -- Add result type template argument for ``stddev``, ``variance``, ``nanstd`` and ``nanvar`` - `#1999 `_ -- Fix variance overload - `#2002 `_ -- Added missing ``xaxis_slice_iterator`` header to CMakeLists.txt - `#2009 `_ -- Fixed xview on const keep and const drop slices - `#2010 `_ -- Added ``static_assert`` to ``adapt`` methods - `#2015 `_ -- Removed allocator deprecated calls - `#2018 `_ -- Added missing overload of ``push_back`` to ``svector`` - `#2024 `_ -- Initialized all members of ``xfunciton_cache_impl`` - `#2026 `_ - -0.21.4 ------- - -- Fix warning -Wsign-conversion in ``xview`` - `#1902 `_ -- Fixed issue due to thread_local storage on some architectures - `#1905 `_ -- benchmark/CMakeLists.txt: fixed a tiny spelling mistake - `#1904 `_ -- nd-iterator implementation - `#1891 `_ -- Add GoatCounter analytics for the documentation - `#1908 `_ -- Added ``noexcept`` in ``svector`` - `#1919 `_ -- Add implementation of repeat (similar to NumPy) - `#1896 `_ -- Fix initialization of out shape in ``xt::tile`` - `#1923 `_ -- ``xaxis_slice_iterator`` – Iterates over 1D slices oriented along the specified axis - `#1916 `_ -- Fixed cxx11 lib guard - `#1925 `_ -- Fixed CXX11 ABI when _GLIBCXX_USE_DUAL_ABI is set to 0 - `#1927 `_ -- Enabling array-bounds warning - `#1933 `_ -- Fixed warnings - `#1934 `_ -- Compile with g++ instead of gcc, clarify include directories - `#1938 `_ -- broadcast function now accepts fixed shapes - `#1939 `_ -- Don't print decimal point after ``inf`` or ``nan`` - `#1940 `_ -- Improved performance of ``xt::tile`` - `#1943 `_ -- Refactoring CI - `#1942 `_ -- Documentation build: Switched to channel QuantStack - `#1948 `_ -- Removed warnings due to gtest upgrade - `#1949 `_ -- Fixed flatten view of view - `#1950 `_ -- Improved narrative documentation of reducers - `#1958 `_ -- Add test for printing xarray of type ``size_t`` - `#1947 `_ -- Added documentation for iterators - `#1961 `_ -- Fixed ``check_element_index`` behavior for 0-D expressions - `#1965 `_ -- Fixed ``element`` method of xreducer - `#1966 `_ -- Fixed ``cast`` for third-party types - `#1967 `_ -- fix ``xoperation`` - `#1790 `_ -- Added installation instruction with MinGW - `#1969 `_ -- ``xrepeat`` now stores ``const_xclosure_t`` instead of ``E`` - `#1968 `_ -- Fixed ``argpartition`` leading axis test - `#1971 `_ -- Added tests with C++20 enabled - `#1974 `_ -- Added documentation for ``repeat`` - `#1975 `_ -- Fixed sort and partition - `#1976 `_ -- xt::view now supports negative indices - `#1979 `_ - -0.21.3 ------- - -- Allow use of cmake add_subdirectory(xtensor) by checking for xtl target - `#1865 `_ -- Simplifying CMake config - `#1856 `_ -- Fixed ``reshape`` with signed integers - `#1867 `_ -- Disabled MSVC iterator checks - `#1874 `_ -- Added covariance function - `#1847 `_ -- Fix for older cmake - `#1880 `_ -- Added row and col facade for 2-D contianers - `#1876 `_ -- Implementation of ``xt::tile`` - `#1888 `_ -- Fixed ``reshape`` return - `#1886 `_ -- Enabled ``add_subdirectory`` for *xsimd* - `#1889 `_ -- Support ``ddof`` argument for ``xt::variance`` - `#1893 `_ -- Set -march=native only if the user did not set another -march already - `#1899 `_ -- Assemble new container in ``xpad`` - `#1808 `_ - -0.21.2 ------- - -- Upgraded to gtest 1.10.0 - `#1859 `_ -- Upgraded to xsimd 7.4.4 - `#1864 `_ -- Removed allocator deprecated calls - `#1862 `_ - -0.21.1 ------- - -- Added circular includes check - `#1853 `_ -- Removed cricular dependencies - `#1854 `_ - -0.21.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- Dynamic SIMD assign - `#1762 `_ - -Other changes -~~~~~~~~~~~~~ - -- Updated links to other projects - `#1773 `_ -- Updated license - `#1774 `_ -- Updated related projects - `#1775 `_ -- Fixed ``has_simd_interface`` for non existing ``simd_return_type`` - `#1779 `_ -- Added average overload for default equal weights - `#1789 `_ -- Implemented concatenation of ``fixed_shape`` tensors - `#1793 `_ -- Replaced ``new`` with ``unique_ptr`` in headers - `#1800 `_ -- Fixed reallocation when an ``xbuffer`` is copied over - `#1799 `_ -- Added hte ability to use the library with ``-fnoexception`` - `#1801 `_ -- Minor efficiency improvement - `#1807 `_ -- Unified ``xt::concatenate`` and ``xt::concatenate_fixed`` - `#1805 `_ -- Have ``reshape`` method return a reference to self - `#1813 `_ -- Enabling tests of ``xtensor_fixed`` on Windows with clang. - `#1815 `_ -- Disabled SIMD assignment when bool conversion occurs - `#1818 `_ -- Speed up views, added SIMD interface to strided views - `#1627 `_ -- Fixed assignment of scalar to complex - `#1828 `_ -- Fixed concurrency issue in ``flat_expression_adaptor`` - `#1831 `_ -- Implemented an equivalent to ``numpy.roll`` - `#1823 `_ -- Upgraded to ``xtl 0.6.9`` - `#1839 `_ -- Fixed type of OpenMP's index variable on Windows - `#1838 `_ -- Implemented ``hstack`` and ``vstack`` - `#1841 `_ -- Implemented ``hsplit`` and ``vsplit`` - `#1842 `_ -- Fixed behavior of ``diff`` when ``n`` is greater thant the number of elements - `#1843 `_ -- Added treshold to OpenMP parallelization - `#1849 `_ -- Added missing assign operator in ``xmasked_view`` - `#1850 `_ -- Updated CMake target - `#1851 `_ - -0.20.10 -------- - -- Simplified functors definition - `#1756 `_ -- Fixed ``container_simd_return_type`` - `#1759 `_ -- Fixed reducer init for ``xtensor_fixed`` value type - `#1761 `_ - -0.20.9 ------- - -- Added alias to check if type is ``xsemantic_base`` - `#1673 `_ -- Added missing include ``xoperation.hpp`` - `#1674 `_ -- Moved XSIMD and TBB dependencies to tests only - `#1676 `_ -- Added missing coma - `#1680 `_ -- Added NumPy-like parameter in ``load_csv`` - `#1682 `_ -- Added ``shape()`` method to ``xshape.hpp`` - `#1592 `_ -- Added shape print tip to docs - `#1693 `_ -- Fix lvalue npy_file heap corruption in MSVC - `#1697 `_ -- Fix UB when parsing 1-dimension npy - `#1696 `_ -- Fixed compiler error (missing ``shape`` method in ``xbroadcast`` and ``xscalar``) - `#1699 `_ -- Added: deg2rad, rad2deg, degrees, radians - `#1700 `_ -- Despecialized xt::to_json and xt::from_json - `#1691 `_ -- Added coverity - `#1577 `_ -- Additional configuration for future coverity branch - `#1712 `_ -- More tests for coverity - `#1714 `_ -- Update README.md for Conan installation instructions - `#1717 `_ -- Reset stream's flags after output operation - `#1718 `_ -- Added missing include in ``xview.hpp`` - `#1719 `_ -- Removed usage of allocator's members that are deprecated in C++17 - `#1720 `_ -- Added tests for mixed assignment - `#1721 `_ -- Fixed ``step_simd`` when underlying iterator holds an ``xscalar_stepper`` - `#1724 `_ -- Fixed accumulator for empty arrays - `#1725 `_ -- Use ``temporary_type`` in implementation of ``xt::diff`` - `#1727 `_ -- CMakeLists.txt: bumped up xsimd required version to 7.2.6 - `#1728 `_ -- Fixed reducers on empty arrays - `#1729 `_ -- Implemented additional random distributions - `#1708 `_ -- Fixed reducers: passing the same axis many times now throws - `#1730 `_ -- Made ``xfixed_container`` optionally sharable - `#1733 `_ -- ``step_simd`` template parameter is now the value type instead of the simd type - `#1736 `_ -- Implemented OpenMP Parallelization. - `#1739 `_ -- Readme improvements - `#1741 `_ -- Vectorized ``xt::where`` - `#1738 `_ -- Fix typos and wording in documentation - `#1745 `_ -- Upgraded to xtl 0.6.6. and xsimd 7.4.0 - `#1747 `_ -- Improve return value type for ``nanmean`` - `#1749 `_ -- Allows (de)serialization of xexpressions in NumPy formatted strings and streams - `#1751 `_ -- Enabled vectorization of boolean operations - `#1748 `_ -- Added the list of contributors - `#1755 `_ - -0.20.8 ------- - -- Added traversal order to ``argwhere`` and ``filter`` - `#1672 `_ -- ``flatten`` now returns the new type ``xtensor_view`` - `#1671 `_ -- Error case handling in ``concatenate`` - `#1669 `_ -- Added assign operator from ``temporary_type`` in ``xiterator_adaptor`` - `#1668 `_ -- Improved ``index_view`` examples - `#1667 `_ -- Updated build option section of the documentation - `#1666 `_ -- Made ``xsequence_view`` convertible to arbitrary sequence type providing iterators - `#1657 `_ -- Added overload of ``is_linear`` for expressions without ``strides`` method - `#1655 `_ -- Fixed reverse ``arange`` - `#1653 `_ -- Add warnings for random number generation - `#1652 `_ -- Added common pitfalls section in the documentation - `#1649 `_ -- Added missing ``shape`` overload in ``xfunction`` - `#1650 `_ -- Made ``xconst_accessible::shape(std::size_t)`` visible in ``xview`` - `#1645 `_ -- Diff: added bounds-check on maximal recursion - `#1640 `_ -- Add ``xframe`` to related projects - `#1635 `_ -- Update ``indice.rst`` - `#1626 `_ -- Remove unecessary arguments - `#1624 `_ -- Replace ``auto`` with explicit return type in ``make_xshared`` - `#1621 `_ -- Add `z5` to related projects - `#1620 `_ -- Fixed long double complex offset views - `#1614 `_ -- Fixed ``xpad`` bugs - `#1607 `_ -- Workaround for annoying bug in VS2017 - `#1602 `_ - -0.20.7 ------- - -- Fix reshape view assignment and allow setting traversal order - `#1598 `_ - -0.20.6 ------- - -- Added XTENSOR_DEFAULT_ALIGNMENT macro - `#1597 `_ -- Added missing comparison operators for const_array - `#1596 `_ -- Fixed reducer for expression with shape containing 0 - `#1595 `_ -- Very minor spelling checks in comments - `#1591 `_ -- tests can be built in debug mode - `#1589 `_ -- strided views constructors forward shape argument - `#1587 `_ -- Remove unused type alias - `#1585 `_ -- Fixed reducers with empty list of axes - `#1582 `_ -- Fix typo in builder docs - `#1581 `_ -- Fixed return type of data in xstrided_view - `#1580 `_ -- Fixed reducers on expression with shape containing 1 as first elements - `#1579 `_ -- Fixed xview::element for range with more elements than view's dimension - `#1578 `_ -- Fixed broadcasting of shape containing 0-sized dimensions - `#1575 `_ -- Fixed norm return type for complex - `#1574 `_ -- Fixed iterator incremented or decremented by 0 - `#1572 `_ -- Added complex exponential test - `#1571 `_ -- Strided views refactoring - `#1569 `_ -- Add clang-cl support - `#1559 `_ - -0.20.5 ------- - -- Fixed ``conj`` - `#1556 `_ -- Fixed ``real``, ``imag``, and ``functor_view`` - `#1554 `_ -- Allows to include *xsimd* without defining ``XTENSOR_USE_XSIMD`` - `#1548 `_ -- Fixed ``argsort`` in column major - `#1547 `_ -- Fixed ``assign_to`` for ``arange`` on ``double`` - `#1541 `_ -- Fix example code in container.rst - `#1544 `_ -- Removed return value from ``step_leading`` - `#1536 `_ -- Bugfix: amax - `#1533 `_ -- Removed extra ; - `#1527 `_ - -0.20.4 ------- - -- Buffer adaptor default constructor - `#1524 `_ - -0.20.3 ------- - -- Fix xbuffer adaptor - `#1523 `_ - -0.20.2 ------- - -- Fixed broadcast linear assign - `#1493 `_ -- Fixed ``do_stirdes_match`` - `#1497 `_ -- Removed unused capture - `#1499 `_ -- Upgraded to *xtl* 0.6.2 - `#1502 `_ -- Added missing methods in ``xshared_expression`` - `#1503 `_ -- Fixed iterator types of ``xcontainer`` - `#1504 `_ -- Typo correction in external-structure.rst - `#1505 `_ -- Added extension base to adaptors - `#1507 `_ -- Fixed shared expression iterator methods - `#1509 `_ -- Strided view fixes - `#1512 `_ -- Improved range documentation - `#1515 `_ -- Fixed ``ravel`` and ``flatten`` implementation - `#1511 `_ -- Fixed ``xfixed_adaptor`` temporary assign - `#1516 `_ -- Changed struct -> class in ``xiterator_adaptor`` - `#1513 `_ -- Fxed ``argmax`` for expressions with strides 0 - `#1519 `_ -- Add ``has_linear_assign`` to ``sdynamic_view`` - `#1520 `_ - -0.20.1 ------- - -- Add a test for mimetype rendering and fix forward declaration - `#1490 `_ -- Fix special case of view iteration - `#1491 `_ - -0.20.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- Removed ``xmasked_value`` and ``promote_type_t`` - `#1389 `_ -- Removed deprecated type ``slice_vector`` - `#1459 `_ -- Upgraded to *xtl* 0.6.1 - `#1468 `_ -- Added ``keep_dims`` option to reducers - `#1474 `_ -- ``do_strides_match`` now accept an addition base stride value - `#1479 `_ - -Other changes -~~~~~~~~~~~~~ - -- Add ``partition``, ``argpartition`` and ``median`` - `#991 `_ -- Fix tets on avx512 - `#1410 `_ -- Implemented ``xcommon_tensor_t`` with tests - `#1412 `_ -- Code reorganization - `#1416 `_ -- ``reshape`` now accepts ``initializer_list`` parameter - `#1417 `_ -- Improved documentation - `#1419 `_ -- Fixed ``noexcept`` specifier - `#1418 `_ -- ``view`` now accepts lvalue slices - `#1420 `_ -- Removed warnings - `#1422 `_ -- Added ``reshape`` member to ``xgenerator`` to make ``arange`` more flexible - `#1421 `_ -- Add ``std::decay_t`` to ``shape_type`` in strided view - `#1425 `_ -- Generic reshape for ``xgenerator`` - `#1426 `_ -- Fix out of bounds accessing in ``xview::compute_strides`` - `#1437 `_ -- Added quick reference section to documentation - `#1438 `_ -- Improved getting started CMakeLists.txt - `#1440 `_ -- Added periodic indices - `#1430 `_ -- Added build section to narrative documentation - `#1442 `_ -- Fixed ``linspace`` corner case - `#1443 `_ -- Fixed type-o in documentation - `#1446 `_ -- Added ``xt::xpad`` - `#1441 `_ -- Added warning in ``resize`` documentation - `#1447 `_ -- Added ``in_bounds`` method - `#1444 `_ -- ``xstrided_view_base`` is now a CRTP base class - `#1453 `_ -- Turned ``xfunctor_applier_base`` into a CRTP base class - `#1455 `_ -- Removed out of bound access in ``data_offset`` - `#1456 `_ -- Added ``xaccessible`` base class - `#1451 `_ -- Refactored ``operator[]`` - `#1460 `_ -- Splitted ``xaccessible`` - `#1461 `_ -- Refactored ``size`` - `#1462 `_ -- Implemented ``nanvar`` and ``nanstd`` with tests - `#1424 `_ -- Removed warnings - `#1463 `_ -- Added ``periodic`` and ``in_bounds`` method to ``xoptional_assembly_base`` - `#1464 `_ -- Updated documentation according to last changes - `#1465 `_ -- Fixed ``flatten_sort_result_type`` - `#1470 `_ -- Fixed ``unique`` with expressions not defining ``temporary_type`` - `#1472 `_ -- Fixed ``xstrided_view_base`` constructor - `#1473 `_ -- Avoid signed integer overflow in integer printer - `#1475 `_ -- Fixed ``xview::inner_backstrides_type`` - `#1480 `_ -- Fixed compiler warnings - `#1481 `_ -- ``slice_implementation_getter`` now forwards its lice argument - `#1486 `_ -- ``linspace`` can now be reshaped - `#1488 `_ - -0.19.4 ------- - -- Add missing include - `#1391 `_ -- Fixes in xfunctor_view - `#1393 `_ -- Add tests for xfunctor_view - `#1395 `_ -- Add `empty` method to fixed_shape - `#1396 `_ -- Add accessors to slice members - `#1401 `_ -- Allow adaptors on shared pointers - `#1218 `_ -- Fix `eye` with negative index - `#1406 `_ -- Add documentation for shared pointer adaptor - `#1407 `_ -- Add `nanmean` function - `#1408 `_ - -0.19.3 ------- - -- Fix arange - `#1361 `_. -- Adaptors for C stack-allocated arrays - `#1363 `_. -- Add support for optionals in ``conditional_ternary`` - `#1365 `_. -- Add tests for ternary operator on xoptionals - `#1368 `_. -- Enable ternary operation for a mix of ``xoptional`` and ``value`` - `#1370 `_. -- ``reduce`` now accepts a single reduction function - `#1371 `_. -- Implemented share method - `#1372 `_. -- Documentation of shared improved - `#1373 `_. -- ``make_lambda_xfunction`` more generic - `#1374 `_. -- minimum/maximum for ``xoptional`` - `#1378 `_. -- Added missing methods in ``uvector`` and ``svector`` - `#1379 `_. -- Clip ``xoptional_assembly`` - `#1380 `_. -- Improve gtest cmake - `#1382 `_. -- Implement ternary operator for scalars - `#1385 `_. -- Added missing ``at`` method in ``uvector`` and ``svector`` - `#1386 `_. -- Fixup binder environment - `#1387 `_. -- Fixed ``resize`` and ``swap`` of ``svector`` - `#1388 `_. - -0.19.2 ------- - -- Enable CI for C++17 - `#1324 `_. -- Fix assignment of masked views - `#1328 `_. -- Set CMAKE_CXX_STANDARD instead of CMAKE_CXX_FLAGS - `#1330 `_. -- Allow specifying traversal order to argmin and argmax - `#1331 `_. -- Update section on differences with NumPy - `#1336 `_. -- Fix accumulators for shapes containing 1 - `#1337 `_. -- Decouple XTENSOR_DEFAULT_LAYOUT and XTENSOR_DEFAULT_TRAVERSAL - `#1339 `_. -- Prevent embiguity with `xsimd::reduce` - `#1343 `_. -- Require *xtl* 0.5.3 - `#1346 `_. -- Use concepts instead of SFINAE - `#1347 `_. -- Document good practice for xtensor-based API design - `#1348 `_. -- Fix rich display of tensor expressions - `#1353 `_. -- Fix xview on fixed tensor - `#1354 `_. -- Fix issue with `keep_slice` in case of `dynamic_view` on `view` - `#1355 `_. -- Prevent installation of gtest artifacts - `#1357 `_. - -0.19.1 ------- - -- Add string specialization to ``lexical_cast`` - `#1281 `_. -- Added HDF5 reference for ``xtensor-io`` - `#1284 `_. -- Fixed view index remap issue - `#1288 `_. -- Fixed gcc 8.2 deleted functions - `#1289 `_. -- Fixed reducer for 0d input - `#1292 `_. -- Fixed ``check_element_index`` - `#1295 `_. -- Added comparison functions - `#1297 `_. -- Add some tests to ensure chrono works with xexpressions - `#1272 `_. -- Refactor ``functor_view`` - `#1276 `_. -- Documentation improved - `#1302 `_. -- Implementation of shift operators - `#1304 `_. -- Make functor adaptor stepper work for proxy specializations - `#1305 `_. -- Replaced ``auto&`` with ``auto&&`` in ``assign_to`` - `#1306 `_. -- Fix namespace in ``xview_utils.hpp`` - `#1308 `_. -- Introducing ``flatten_indices`` and ``unravel_indices`` - `#1300 `_. -- Default layout parameter for ``ravel`` - `#1311 `_. -- Fixed ``xvie_stepper`` - `#1317 `_. -- Fixed assignment of view on view - `#1314 `_. -- Documented indices - `#1318 `_. -- Fixed shift operators return type - `#1319 `_. - -0.19.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- Upgraded to ``xtl 0.5`` - `#1275 `_. - -Other changes -~~~~~~~~~~~~~ - -- Removed type-o in docs, minor code style consistency update - `#1255 `_. -- Removed most of the warnings - `#1261 `_. -- Optional bitwise fixed - `#1263 `_. -- Prevent macro expansion in ``std::max`` - `#1265 `_. -- Update numpy.rst - `#1267 `_. -- Update getting_started.rst - `#1268 `_. -- keep and drop ``step_size`` fixed - `#1270 `_. -- Fixed typo in ``xadapt`` - `#1277 `_. -- Fixed typo - `#1278 `_. - -0.18.3 ------- - -- Exporting optional dependencies - `#1253 `_. -- 0-D HTML rendering - `#1252 `_. -- Include nlohmann_json in xio for mime bundle repr - `#1251 `_. -- Fixup xview scalar assignment - `#1250 `_. -- Implemented `from_indices` - `#1240 `_. -- xtensor_forward.hpp cleanup - `#1243 `_. -- default layout-type for `unravel_from_strides` and `unravel_index` - `#1239 `_. -- xfunction iterator fix - `#1241 `_. -- xstepper fixes - `#1237 `_. -- print_options io manipulators - `#1231 `_. -- Add syntactic sugar for reducer on single axis - `#1228 `_. -- Added view vs. adapt benchmark - `#1229 `_. -- added precisions to the installation instructions - `#1226 `_. -- removed data interface from dynamic view - `#1225 `_. -- add xio docs - `#1223 `_. -- Fixup xview assignment - `#1216 `_. -- documentation updated to be consistent with last changes - `#1214 `_. -- prevents macro expansion of std::max - `#1213 `_. -- Fix minor typos - `#1212 `_. -- Added missing assign operator in xstrided_view - `#1210 `_. -- argmax on axis with single element fixed - `#1209 `_. - -0.18.2 ------- - -- expression tag system fixed - `#1207 `_. -- optional extension for generator - `#1206 `_. -- optional extension for ``xview`` - `#1205 `_. -- optional extension for ``xstrided_view`` - `#1204 `_. -- optional extension for reducer - `#1203 `_. -- optional extension for ``xindex_view`` - `#1202 `_. -- optional extension for ``xfunctor_view`` - `#1201 `_. -- optional extension for broadcast - `#1198 `_. -- extension API and code cleanup - `#1197 `_. -- ``xscalar`` optional refactoring - `#1196 `_. -- Extension mechanism - `#1192 `_. -- Many small fixes - `#1191 `_. -- Slight refactoring in ``step_size`` logic - `#1188 `_. -- Fixup call of const overload in assembly storage - `#1187 `_. - -0.18.1 ------- - -- Fixup xio forward declaration - `#1185 `_. - -0.18.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- Assign and trivial_broadcast refactoring - `#1150 `_. -- Moved array manipulation functions (``transpose``, ``ravel``, ``flatten``, ``trim_zeros``, ``squeeze``, ``expand_dims``, ``split``, ``atleast_Nd``, ``atleast_1d``, ``atleast_2d``, ``atleast_3d``, ``flip``) from ``xstrided_view.hpp`` to ``xmanipulation.hpp`` - `#1153 `_. -- iterator API improved - `#1155 `_. -- Fixed ``where`` and ``nonzero`` function behavior to mimic the behavior from NumPy - `#1157 `_. -- xsimd and functor refactoring - `#1173 `_. - -New features -~~~~~~~~~~~~ - -- Implement ``rot90`` - `#1153 `_. -- Implement ``argwhere`` and ``flatnonzero`` - `#1157 `_. -- Implemented ``xexpression_holder`` - `#1164 `_. - -Other changes -~~~~~~~~~~~~~ - -- Warnings removed - `#1159 `_. -- Added missing include - `#1162 `_. -- Removed unused type alias in ``xmath/average`` - `#1163 `_. -- Slices improved - `#1168 `_. -- Fixed ``xdrop_slice`` - `#1181 `_. - -0.17.4 ------- - -- perfect forwarding in ``xoptional_function`` constructor - `#1101 `_. -- fix issue with ``base_simd`` - `#1103 `_. -- ``XTENSOR_ASSERT`` fixed on Windows - `#1104 `_. -- Implement ``xmasked_value`` - `#1032 `_. -- Added ``setdiff1d`` using stl interface - `#1109 `_. -- Added test case for ``setdiff1d`` - `#1110 `_. -- Added missing reference to ``diff`` in ``From NumPy to xtensor`` section - `#1116 `_. -- Add ``amax`` and ``amin`` to the documentation - `#1121 `_. -- ``histogram`` and ``histogram_bin_edges`` implementation - `#1108 `_. -- Added NumPy comparison for interp - `#1111 `_. -- Allow multiple return type reducer functions - `#1113 `_. -- Fixes ``average`` bug + adds NumPy based tests - `#1118 `_. -- Static ``xfunction`` cache for fixed sizes - `#1105 `_. -- Add negative reshaping axis - `#1120 `_. -- Updated ``xmasked_view`` using ``xmasked_value`` - `#1074 `_. -- Clean documentation for views - `#1131 `_. -- Build with *xsimd* on Windows fixed - `#1127 `_. -- Implement ``mime_bundle_repr`` for ``xmasked_view`` - `#1132 `_. -- Modify shuffle to use identical algorithms for any number of dimensions - `#1135 `_. -- Warnings removal on windows - `#1139 `_. -- Add permutation function to random - `#1141 `_. -- ``xfunction_iterator`` permutation - `#933 `_. -- Add ``bincount`` to ``xhistogram`` - `#1140 `_. -- Add contiguous iterable base class and remove layout param from storage iterator - `#1057 `_. -- Add ``storage_iterator`` to view and strided view - `#1045 `_. -- Removes ``data_element`` from ``xoptional`` - `#1137 `_. -- ``xtensor`` default constructor and scalar assign fixed - `#1148 `_. -- Add ``resize / reshape`` to ``xfixed_container`` - `#1147 `_. -- Iterable refactoring - `#1149 `_. -- ``inner_strides_type`` imported in ``xstrided_view`` - `#1151 `_. - -0.17.3 ------- - -- ``xslice`` fix - `#1099 `_. -- added missing ``static_layout`` in ``xmasked_view`` - `#1100 `_. - -0.17.2 ------- - -- Add experimental TBB support for parallelized multicore assign - `#948 `_. -- Add inline statement to all functions in xnpy - `#1097 `_. -- Fix strided assign for certain assignments - `#1095 `_. -- CMake, remove gtest warnings - `#1085 `_. -- Add conversion operators to slices - `#1093 `_. -- Add optimization to unchecked accessors when contiguous layout is known - `#1060 `_. -- Speedup assign by computing ``any`` layout on vectors - `#1063 `_. -- Skip resizing for fixed shapes - `#1072 `_. -- Add xsimd apply to xcomplex functors (conj, norm, arg) - `#1086 `_. -- Propagate contiguous layout through views - `#1039 `_. -- Fix C++17 ambiguity for GCC 7 - `#1081 `_. -- Correct shape type in argmin, fix svector growth - `#1079 `_. -- Add ``interp`` function to xmath - `#1071 `_. -- Fix valgrind warnings + memory leak in xadapt - `#1078 `_. -- Remove more clang warnings & errors on OS X - `#1077 `_. -- Add move constructor from xtensor <-> xarray - `#1051 `_. -- Add global support for negative axes in reducers/accumulators - allow multiple axes in average - `#1010 `_. -- Fix reference usage in xio - `#1076 `_. -- Remove occurences of std::size_t and double - `#1073 `_. -- Add missing parantheses around min/max for MSVC - `#1061 `_. - -0.17.1 ------- - -- Add std namespace to size_t everywhere, remove std::copysign for MSVC - `#1053 `_. -- Fix (wrong) bracket warnings for older clang versions (e.g. clang 5 on OS X) - `#1050 `_. -- Fix strided view on view by using std::addressof - `#1049 `_. -- Add more adapt functions and shorthands - `#1043 `_. -- Improve CRTP base class detection - `#1041 `_. -- Fix rebind container ambiguous template for C++17 / GCC 8 regression - `#1038 `_. -- Fix functor return value - `#1035 `_. - -0.17.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- Changed strides to ``std::ptrdiff_t`` - `#925 `_. -- Renamed ``count_nonzeros`` in ``count_nonzero`` - `#974 `_. -- homogenize ``xfixed`` constructors - `#970 `_. -- Improve ``random::choice`` - `#1011 `_. - -New features -~~~~~~~~~~~~ - -- add ``signed char`` to npy deserialization format - `#1017 `_. -- simd assignment now requires convertible types instead of same type - `#1000 `_. -- shared expression and automatic xclosure detection - `#992 `_. -- average function - `#987 `_. -- added simd support for complex - `#985 `_. -- argsort function - `#977 `_. -- propagate fixed shape - `#922 `_. -- added xdrop_slice - `#972 `_. -- added doc for ``xmasked_view`` - `#971 `_. -- added ``xmasked_view`` - `#969 `_. -- added ``dynamic_view`` - `#966 `_. -- added ability to use negative indices in keep slice - `#964 `_. -- added an easy way to create lambda expressions, square and cube - `#961 `_. -- noalias on rvalue - `#965 `_. - -Other changes -~~~~~~~~~~~~~ - -- ``xshared_expression`` fixed - `#1025 `_. -- fix ``make_xshared`` - `#1024 `_. -- add tests to evaluate shared expressions - `#1019 `_. -- fix ``where`` on ``xview`` - `#1012 `_. -- basic usage replaced with getting started - `#1004 `_. -- avoided installation failure in absence of ``nlohmann_json`` - `#1001 `_. -- code and documentation clean up - `#998 `_. -- removed g++ "pedantic" compiler warnings - `#997 `_. -- added missing header in basic_usage.rst - `#996 `_. -- warning pass - `#990 `_. -- added missing include in ``xview`` - `#989 `_. -- added missing ```` include - `#983 `_. -- xislice refactoring - `#962 `_. -- added missing operators to noalias - `#932 `_. -- cmake fix for Intel compiler on Windows - `#951 `_. -- fixed xsimd abs deduction - `#946 `_. -- added islice example to view doc - `#940 `_. - -0.16.4 ------- - -- removed usage of ``std::transfomr`` in assign - `#868 `_. -- add strided assignment - `#901 `_. -- simd activated for conditional ternary functor - `#903 `_. -- ``xstrided_view`` split - `#905 `_. -- assigning an expression to a view throws if it has more dimensions - `#910 `_. -- faster random - `#913 `_. -- ``xoptional_assembly_base`` storage type - `#915 `_. -- new tests and warning pass - `#916 `_. -- norm immediate reducer - `#924 `_. -- add ``reshape_view`` - `#927 `_. -- fix immediate reducers with 0 strides - `#935 `_. - -0.16.3 ------- - -- simd on mathematical functions fixed - `#886 `_. -- ``fill`` method added to containers - `#887 `_. -- access with more arguments than dimensions - `#889 `_. -- unchecked method implemented - `#890 `_. -- ``fill`` method implemented in view - `#893 `_. -- documentation fixed and warnings removed - `#894 `_. -- negative slices and new range syntax - `#895 `_. -- ``xview_stepper`` with implicit ``xt::all`` bug fix - `#899 `_. - -0.16.2 ------- - -- Add include of ``xview.hpp`` in example - `#884 `_. -- Remove ``FS`` identifier - `#885 `_. - -0.16.1 ------- - -- Workaround for Visual Studio Bug - `#858 `_. -- Fixup example notebook - `#861 `_. -- Prevent expansion of min and max macros on Windows - `#863 `_. -- Renamed ``m_data`` to ``m_storage`` - `#864 `_. -- Fix regression with respect to random access stepping with views - `#865 `_. -- Remove use of CS, DS and ES qualifiers for Solaris builds - `#866 `_. -- Removal of precision type - `#870 `_. -- Make json tests optional, bump xtl/xsimd versions - `#871 `_. -- Add more benchmarks - `#876 `_. -- Forbid simd fixed - `#877 `_. -- Add more asserts - `#879 `_. -- Add missing ``batch_bool`` typedef - `#881 `_. -- ``simd_return_type`` hack removed - `#882 `_. -- Removed test guard and fixed dimension check in ``xscalar`` - `#883 `_. - -0.16.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- ``data`` renamed in ``storage``, ``raw_data`` renamed in ``data`` - `#792 `_. -- Added layout template parameter to ``xstrided_view`` - `#796 `_. -- Remove equality operator from stepper - `#824 `_. -- ``dynamic_view`` renamed in ``strided_view`` - `#832 `_. -- ``xtensorf`` renamed in ``xtensor_fixed`` - `#846 `_. - -New features -~~~~~~~~~~~~ - -- Added strided view selector - `#765 `_. -- Added ``count_nonzeros`` - `#781 `_. -- Added implicit conversion to scalar in ``xview`` - `#788 `_. -- Added tracking allocators to ``xutils.hpp`` - `#789 `_. -- ``xindexslice`` and ``shuffle`` function - `#804 `_. -- Allow ``xadapt`` with dynamic layout - `#816 `_. -- Added ``xtensorf`` initialization from C array - `#819 `_. -- Added policy to allocation tracking for throw option - `#820 `_. -- Free function ``empty`` for construction from shape - `#827 `_. -- Support for JSON serialization and deserialization of xtensor expressions - `#830 `_. -- Add ``trapz`` function - `#837 `_. -- Add ``diff`` and ``trapz(y, x)`` functions - `#841 `_. - -Other changes -~~~~~~~~~~~~~ - -- Added fast path for specific assigns - `#767 `_. -- Renamed internal macros to prevent collisions - `#772 `_. -- ``dynamic_view`` unwrapping - `#775 `_. -- ``xreducer_stepper`` copy semantic fixed - `#785 `_. -- ``xfunction`` copy constructor fixed - `#787 `_. -- warnings removed - `#791 `_. -- ``xscalar_stepper`` fixed - `#802 `_. -- Fixup ``xadapt`` on const pointers - `#809 `_. -- Fix in owning buffer adaptors - `#810 `_. -- Macros fixup - `#812 `_. -- More fixes in ``xadapt`` - `#813 `_. -- Mute unused variable warning - `#815 `_. -- Remove comparison of steppers in assign loop - `#823 `_. -- Fix reverse iterators - `#825 `_. -- gcc-8 fix for template method calls - `#833 `_. -- refactor benchmarks for upcoming release - `#842 `_. -- ``flip`` now returns a view - `#843 `_. -- initial warning pass - `#850 `_. -- Fix warning on diff function - `#851 `_. -- xsimd assignment fixed - `#852 `_. - -0.15.9 ------- - -- missing layout method in xfixed - `#777 `_. -- fixed uninitialized backstrides - `#774 `_. -- update xtensor-blas in binder - `#773 `_. - -0.15.8 ------- - -- comparison operators for slices - `#770 `_. -- use default-assignable layout for strided views. - `#769 `_. - -0.15.7 ------- - -- nan related functions - `#718 `_. -- return types fixed in dynamic view helper - `#722 `_. -- xview on constant expressions - `#723 `_. -- added decays to make const ``value_type`` compile - `#727 `_. -- iterator for constant ``strided_view`` fixed - `#729 `_. -- ``strided_view`` on ``xfunction`` fixed - `#732 `_. -- Fixes in ``xstrided_view`` - `#736 `_. -- View semantic (broadcast on assign) fixed - `#742 `_. -- Compilation prevented when using ellipsis with ``xview`` - `#743 `_. -- Index of ``xiterator`` set to shape when reaching the end - `#744 `_. -- ``xscalar`` fixed - `#748 `_. -- Updated README and related projects - `#749 `_. -- Perfect forwarding in ``xfunction`` and views - `#750 `_. -- Missing include in ``xassign.hpp`` - `#752 `_. -- More related projects in the README - `#754 `_. -- Fixed stride computation for ``xtensorf`` - `#755 `_. -- Added tests for backstrides - `#758 `_. -- Clean up ``has_raw_data`` ins strided view - `#759 `_. -- Switch to ``ptrdiff_t`` for slices - `#760 `_. -- Fixed ``xview`` strides computation - `#762 `_. -- Additional methods in slices, required for ``xframe`` - `#764 `_. - -0.15.6 ------- - -- zeros, ones, full and empty_like functions - `#686 `_. -- squeeze view - `#687 `_. -- bitwise shift left and shift right - `#688 `_. -- ellipsis, unique and trim functions - `#689 `_. -- xview iterator benchmark - `#696 `_. -- optimize stepper increment - `#697 `_. -- minmax reducers - `#698 `_. -- where fix with SIMD - `#704 `_. -- additional doc for scalars and views - `#705 `_. -- mixed arithmetic with SIMD - `#713 `_. -- broadcast fixed - `#717 `_. - -0.15.5 ------- - -- assign functions optimized - `#650 `_. -- transposed view fixed - `#652 `_. -- exceptions refactoring - `#654 `_. -- performances improved - `#655 `_. -- view data accessor fixed - `#660 `_. -- new dynamic view using variant - `#656 `_. -- alignment added to fixed xtensor - `#659 `_. -- code cleanup - `#664 `_. -- xtensorf and new dynamic view documentation - `#667 `_. -- qualify namespace for compute_size - `#665 `_. -- make xio use ``dynamic_view`` instead of ``view`` - `#662 `_. -- transposed view on any expression - `#671 `_. -- docs typos and grammar plus formatting - `#676 `_. -- index view test assertion fixed - `#680 `_. -- flatten view - `#678 `_. -- handle the case of pointers to const element in ``xadapt`` - `#679 `_. -- use quotes in #include statements for xtl - `#681 `_. -- additional constructors for ``svector`` - `#682 `_. -- removed ``test_xsemantics.hpp`` from test CMakeLists - `#684 `_. - -0.15.4 ------- - -- fix gcc-7 error w.r.t. the use of ``assert`` - `#648 `_. - -0.15.3 ------- - -- add missing headers to cmake installation and tests - `#647 `_. - - -0.15.2 ------- - -- ``xshape`` implementation - `#572 `_. -- xfixed container - `#586 `_. -- protected ``xcontainer::derived_cast`` - `#627 `_. -- const reference fix - `#632 `_. -- ``xgenerator`` access operators fixed - `#643 `_. -- contiguous layout optiimzation - `#645 `_. - - -0.15.1 ------- - -- ``xarray_adaptor`` fixed - `#618 `_. -- ``xtensor_adaptor`` fixed - `#620 `_. -- fix in ``xreducer`` steppers - `#622 `_. -- documentation improved - `#621 `_. - `#623 `_. - `#625 `_. -- warnings removed - `#624 `_. - -0.15.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- change ``reshape`` to ``resize``, and add throwing ``reshape`` - `#598 `_. -- moved to modern cmake - `#611 `_. - -New features -~~~~~~~~~~~~ - -- unravel function - `#589 `_. -- random access iterators - `#596 `_. - - -Other changes -~~~~~~~~~~~~~ - -- upgraded to google/benchmark version 1.3.0 - `#583 `_. -- ``XTENSOR_ASSERT`` renamed into ``XTENSOR_TRY``, new ``XTENSOR_ASSERT`` - `#603 `_. -- ``adapt`` fixed - `#604 `_. -- VC14 warnings removed - `#608 `_. -- ``xfunctor_iterator`` is now a random access iterator - `#609 `_. -- removed ``old-style-cast`` warnings - `#610 `_. - -0.14.1 ------- - -New features -~~~~~~~~~~~~ - -- sort, argmin and argmax - `#549 `_. -- ``xscalar_expression_tag`` - `#582 `_. - -Other changes -~~~~~~~~~~~~~ - -- accumulator improvements - `#570 `_. -- benchmark cmake fixed - `#571 `_. -- allocator_type added to container interface - `#573 `_. -- allow conda-forge as fallback channel - `#575 `_. -- arithmetic mixing optional assemblies and scalars fixed - `#578 `_. -- arithmetic mixing optional assemblies and optionals fixed - `#579 `_. -- ``operator==`` restricted to xtensor and xoptional expressions - `#580 `_. - -0.14.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- ``xadapt`` renamed into ``adapt`` - `#563 `_. -- Naming consistency - `#565 `_. - -New features -~~~~~~~~~~~~ - -- add ``random::choice`` - `#547 `_. -- evaluation strategy and accumulators. - `#550 `_. -- modulus operator - `#556 `_. -- ``adapt``: default overload for 1D arrays - `#560 `_. -- Move semantic on ``adapt`` - `#564 `_. - -Other changes -~~~~~~~~~~~~~ - -- optional fixes to avoid ambiguous calls - `#541 `_. -- narrative documentation about ``xt::adapt`` - `#544 `_. -- ``xfunction`` refactoring - `#545 `_. -- SIMD acceleration for AVX fixed - `#557 `_. -- allocator fixes - `#558 `_. - `#559 `_. -- return type of ``view::strides()`` fixed - `#568 `_. - - -0.13.2 ------- - -- Support for complex version of ``isclose`` - `#512 `_. -- Fixup static layout in ``xstrided_view`` - `#536 `_. -- ``xexpression::operator[]`` now take support any type of sequence - `#537 `_. -- Fixing ``xinfo`` issues for Visual Studio. - `#529 `_. -- Fix const-correctness in ``xstrided_view``. - `#526 `_. - - -0.13.1 ------- - -- More general floating point type - `#518 `_. -- Do not require functor to be passed via rvalue reference - `#519 `_. -- Documentation improved - `#520 `_. -- Fix in xreducer - `#521 `_. - -0.13.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- The API for ``xbuffer_adaptor`` has changed. The template parameter is the type of the buffer, not just the value type - `#482 `_. -- Change ``edge_items`` print option to ``edgeitems`` for better NumPy consistency - `#489 `_. -- *xtensor* now depends on *xtl* version `~0.3.3` - `#508 `_. - -New features -~~~~~~~~~~~~ - -- Support for parsing the ``npy`` file format - `#465 `_. -- Creation of optional expressions from value and boolean expressions (optional assembly) - `#496 `_. -- Support for the explicit cast of expressions with different value types - `#491 `_. - -Other changes -~~~~~~~~~~~~~ - -- Addition of broadcasting bitwise operators - `#459 `_. -- More efficient optional expression system - `#467 `_. -- Migration of benchmarks to the Google benchmark framework - `#473 `_. -- Container semantic and adaptor semantic merged - `#475 `_. -- Various fixes and improvements of the strided views - `#480 `_. - `#481 `_. -- Assignment now performs basic type conversion - `#486 `_. -- Workaround for a compiler bug in Visual Studio 2017 - `#490 `_. -- MSVC 2017 workaround - `#492 `_. -- The ``size()`` method for containers now returns the total number of elements instead of the buffer size, which may differ when the smallest stride is greater than ``1`` - `#502 `_. -- The behavior of ``linspace`` with integral types has been made consistent with NumPy - `#510 `_. - -0.12.1 ------- - -- Fix issue with slicing when using heterogeneous integral types - `#451 `_. - -0.12.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- *xtensor* now depends on *xtl* version `0.2.x` - `#421 `_. - -New features -~~~~~~~~~~~~ - -- *xtensor* has an optional dependency on *xsimd* for enabling simd acceleration - `#426 `_. - -- All expressions have an additional safe access function (``at``) - `#420 `_. - -- norm functions - `#440 `_. - -- ``closure_pointer`` used in iterators returning temporaries so their ``operator->`` can be - correctly defined - `#446 `_. - -- expressions tags added so *xtensor* expression system can be extended - `#447 `_. - -Other changes -~~~~~~~~~~~~~ - -- Preconditions and exceptions - `#409 `_. - -- ``isclose`` is now symmetric - `#411 `_. - -- concepts added - `#414 `_. - -- narrowing cast for mixed arithmetic - `#432 `_. - -- ``is_xexpression`` concept fixed - `#439 `_. - -- ``void_t`` implementation fixed for compilers affected by C++14 defect CWG 1558 - `#448 `_. - -0.11.3 ------- - -- Fixed bug in length-1 statically dimensioned tensor construction - `#431 `_. - -0.11.2 ------- - -- Fixup compilation issue with latest clang compiler. (missing `constexpr` keyword) - `#407 `_. - -0.11.1 ------- - -- Fixes some warnings in julia and python bindings - -0.11.0 ------- - -Breaking changes -~~~~~~~~~~~~~~~~ - -- ``xbegin`` / ``xend``, ``xcbegin`` / ``xcend``, ``xrbegin`` / ``xrend`` and ``xcrbegin`` / ``xcrend`` methods replaced - with classical ``begin`` / ``end``, ``cbegin`` / ``cend``, ``rbegin`` / ``rend`` and ``crbegin`` / ``crend`` methods. - Old ``begin`` / ``end`` methods and their variants have been removed. - `#370 `_. - -- ``xview`` now uses a const stepper when its underlying expression is const. - `#385 `_. - -Other changes -~~~~~~~~~~~~~ - -- ``xview`` copy semantic and move semantic fixed. - `#377 `_. - -- ``xoptional`` can be implicitly constructed from a scalar. - `#382 `_. - -- build with Emscripten fixed. - `#388 `_. - -- STL version detection improved. - `#396 `_. - -- Implicit conversion between signed and unsigned integers fixed. - `#397 `_. diff --git a/docs/source/closure-semantics.rst b/docs/source/closure-semantics.rst deleted file mode 100644 index ad4d11504..000000000 --- a/docs/source/closure-semantics.rst +++ /dev/null @@ -1,257 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -.. _closure-semantics-label: - -Closure semantics -================= - -The *xtensor* library is a tensor expression library implementing NumPy-style broadcasting and universal functions but in a lazy fashion. - -If ``x`` and ``y`` are two tensor expressions with compatible shapes, the result of ``x + y`` is not a tensor but an expression that does -not hold any value. Values of ``x + y`` are computed upon access or when the result is assigned to a container such as :cpp:type:`xt::xtensor` or -:cpp:type:`xt::xarray`. The same holds for most functions in xtensor, views, broadcasting views, etc. - -In order to be able to perform the differed computation of ``x + y``, the returned expression must hold references, const references or -copies of the members ``x`` and ``y``, depending on how arguments were passed to ``operator+``. The actual types held by the expressions -are the **closure types**. - -The concept of closure type is key in the implementation of *xtensor* and appears in all the expressions defined in xtensor, and the utility functions and metafunctions complement the tools of the standard library for the move semantics. - -Basic rules for determining closure types ------------------------------------------ - -The two main requirements are the following: - -- when an argument passed to the function returning an expression (here, ``operator+``) is an *rvalue*, the closure type is always a value and the ``rvalue`` is *moved*. -- when an argument passed to the function returning an expression is an *lvalue reference*, the closure type is a reference of the same type. - -It is important for the closure type not to be a reference when the passed argument is an rvalue, which can result in dangling references. - -Following the conventions of the C++ standard library for naming type traits, we provide two type traits classes providing an implementation of these rules -in the ``xutils.hpp`` header, ``closure_type``, and ``const_closure_type``. The latter adds the ``const`` qualifier to the reference even when the provided argument is not const. - -.. code:: cpp - - template - struct closure_type - { - using underlying_type = std::conditional_t< - std::is_const>::value, - const std::decay_t, - std::decay_t>; - using type = typename std::conditional< - std::is_lvalue_reference::value, - underlying_type&, - underlying_type>::type; - }; - - template - using closure_type_t = typename closure_type::type; - -The implementation for ``const_closure_type`` is slightly shorter. - -.. code:: cpp - - template - struct const_closure_type - { - using underlying_type = std::decay_t; - using type = typename std::conditional< - std::is_lvalue_reference::value, - std::add_const_t&, - underlying_type>::type; - }; - - template - using const_closure_type_t = typename const_closure_type::type; - -Using this mechanism, we were able to - -- avoid dangling references in nested expressions, -- hold references whenever possible, -- take advantage of the move semantics when holding references is not possible. - -Closure types and scalar wrappers ---------------------------------- - -A requirement for *xtensor* is the ability to mix scalars and tensors in tensor expressions. In order to do so, -scalar values are wrapped into the ``xscalar`` wrapper, which is a cheap 0-D tensor expression holding a single -scalar value. - -For the xscalar to be a proper proxy on the scalar value, if actually holds a closure type on the scalar value. - -The logic for this is encoded into xtensor's ``xclosure`` type trait. - -.. code:: cpp - - template - struct xclosure - { - using type = closure_t; - }; - - template - struct xclosure>> - { - using type = xscalar>; - }; - - template - using xclosure_t = typename xclosure::type; - -In doing so, we ensure const-correctness, we avoid dangling reference, and ensure that lvalues remain lvalues. -The ``const_xclosure`` follows the same scheme: - -.. code:: cpp - - template - struct const_xclosure - { - using type = const_closure_type_t; - }; - - template - struct const_xclosure>> - { - using type = xscalar>; - }; - - template - using const_xclosure_t = typename const_xclosure::type; - -Writing functions that return expressions ------------------------------------------ - -*xtensor closure semantics are not meant to prevent users from doing mistakes, since it would also prevent them from doing something clever*. - -This section covers cases where understanding C++ move semantics and xtensor closure semantics helps writing better code with xtensor. - -Returning evaluated or unevaluated expressions -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -A key feature of xtensor is that a function returning e.g. ``x + y / z`` where ``x``, ``y`` and ``z`` are xtensor expressions does not actually perform any -computation. It is only evaluated upon access or assignment. The returned expression holds values or references for ``x``, ``y`` and ``z`` depending on the -lvalue-ness of the variables passed to the expression, using the *closure semantics* described earlier. This may result in dangling references when using -local variables of a function in an unevaluated expression unless one properly forwards / move the variables. - -.. note:: - - The following rule of thumbs prevents dangling references in the xtensor closure semantics: - - - If the laziness is not important for your use case, returning ``xt::eval(x + y / z)`` will return an evaluated container and avoid these complications. - - Otherwise, the key is to *move* lvalues that become invalid when leaving the current scope. - - If you would need to *move* more than once, take a look at the `Reusing expressions / sharing expressions`_. - -**Example: moving local variables and forwarding universal references** - -Let us first consider the following implementation of the ``mean`` function in xtensor: - -.. raw:: html - - - -.. code:: cpp - - template - inline auto mean(E&& e) noexcept - { - using value_type = typename std::decay_t::value_type; - auto size = e.size(); - auto s = sum(std::forward(e)); - return std::move(s) / value_type(size); - } - -The first thing to take into account is that the result of the final division is an expression, which performs the actual computation -upon access or assignment. - -- In order to perform the division, the expression must hold the values or references on the numerator and denominator. -- Since ``s`` is a local variable, it will be destroyed upon leaving the scope of the function, and more importantly, it is an *lvalue*. -- A consequence of ``s`` being an lvalue and a local variable, is that the ``s / value_type(size)`` would end up holding a dangling ``const`` reference on ``s``. -- Hence we must call return ``std::move(s) / value_type(size)``. - -The other place in this example where the C++ move semantics is used is the line ``s = sum(std::forward(e))``. The goal is to have the unevaluated ``s`` expression -hold a const reference or a value for ``e`` depending on the lvalue-ness of the parameter passed to the function. - - -Reusing expressions / sharing expressions -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Sometimes it is necessary to use a xexpression in two separate places in another xexpression. For example, when computing -something like ``sin(A) + cos(A)`` we can see A being referenced twice. This works fine if we can guarantee that ``A`` has a -long enough lifetime. However, when writing generic interfaces that accept rvalues we cannot always guarantee that ``A`` will -live long enough. -Another scenario is the creation of a temporary, which needs to be used at more than one place in the resulting expression. -We can only `std::move(...)` the temporary once into the expression to hand lifetime management to the expression. - -In order to solve this problem, xtensor offers two solutions: the first involves ad-hoc lambda construction and the second utilizes -shared pointers wrapped in a ``xshared_expression``. - -We can rewrite the ``sin(A) + cos(A)`` function as a lambda that we use to create a vectorized xfunction, and xtensor has a simple -utility to achieve this: - -.. code:: cpp - - template - inline auto sin_plus_cos(E&& e) noexcept - { - auto func = [](auto x) -> decltype(sin(x) + cos(x)) { - return sin(x) + cos(x); - }; - return detail::make_lambda_function(std::move(func), std::forward(e)); - } - -Note: writing a lambda is just sugar for writing a functor. -Also, using ``auto x`` as the function argument enables automatic *xsimd* acceleration. - -As the data flow through the lambda is entirely transparent to the compiler, using this construct -is generally faster than using ``xshared_expressions``. The usage of ``xshared_expression`` also -requires the creation of a ``shared_ptr`` which dynamically allocates some memory and is therefore slow(ish). -But under certain circumstances it might be required, e.g. to implement a fully lazy average: - -.. code:: cpp - - template - inline auto average(E&& e, W&& weights, std::ptrdiff_t axis) noexcept - { - auto shared_weights = xt::make_xshared(std::move(weights)); - auto expr = xt::sum(e * shared_weights , {axis}) / xt::sum(shared_weights); - // the following line prints how often shared_weights is used - std::cout << shared_weights.use_count() << std::endl; // ==> 4 - return expr; - } - -We can see that, before returning from the function, four copies of ``shared_weights`` -exist: two in the two ``xt::sum`` functions, and one is the temporary. The last one lies -in ``weights`` itself, it is a technical requirement for the ``share`` syntax. After -returning from the function, only two copies of the ``xshared_expression`` will exist. -As discussed before, ``xt::make_xshared`` has the same overhead as creating a ``std::shared_ptr`` -which is used internally by the shared expression. - -Another syntax can be used if you don't want to have a temporary variable for the shared -expression: - -.. code:: cpp - - template - inline auto average(E&& e, W&& weights, std::ptrdiff_t axis) noexcept - { - auto expr = xt::sum(e * xt::share(weights) , {axis}) / xt::sum(xt::share(weights)); - // the following line prints how often shared_weights is used - std::cout << shared_weights.use_count() << std::endl; // ==> 3 - return expr; - } - -In that case only three copies of the shared weights exist. Notice that contrary to -``make_xshare``, ``share`` also accepts lvalues; this is to avoid the required ``std::move``, -however ``share`` will turn its argument into an rvalue and will move it into the shared -expression. Thus ``share`` invalidates its argument, and the only thing that can be done -with an expression upon which ``share`` has been called is another call to ``share``. Therefore -``share`` should be called on rvalue references or temporary expressions only. diff --git a/docs/source/cmake.svg b/docs/source/cmake.svg deleted file mode 100644 index 254fe0129..000000000 --- a/docs/source/cmake.svg +++ /dev/null @@ -1,493 +0,0 @@ - - - - - - - - image/svg+xml - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/source/compilers.rst b/docs/source/compilers.rst deleted file mode 100644 index 69673031e..000000000 --- a/docs/source/compilers.rst +++ /dev/null @@ -1,139 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Compiler workarounds -==================== - -This page tracks the workarounds for the various compiler issues that we -encountered in the development. This is mostly of interest for developers -interested in contributing to xtensor. - -Visual Studio 2015 and ``std::enable_if`` ------------------------------------------ - -With Visual Studio, ``std::enable_if`` evaluates its second argument, even if -the condition is false. This is the reason for the presence of the indirection -in the implementation of the ``xfunction_type_t`` meta-function. - -Visual Studio 2017 and alias templates with non-class template parameters and multiple aliasing levels -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Alias template with non-class parameters only, and multiple levels of aliasing -are not properly considered as types by Visual Studio 2017. The base -``xcontainer`` template class underlying xtensor container types has such alias -templates defined. We avoid the multiple levels of aliasing in the case of Visual -Studio. - -Visual Studio and ``min`` and ``max`` macros -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Visual Studio defines ``min`` and ``max`` macros causing calls to e.g. -``std::min`` and ``std::max`` to be interpreted as syntax errors. The -``NOMINMAX`` definition may be used to disable these macros. - -In xtensor, to prevent macro replacements of ``min`` and ``max`` functions, we -wrap them with parentheses, so that client code does not need the ``NOMINMAX`` -definition. - -Visual Studio 2017 (15.7.1) seeing declarations as extra overloads -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -In ``xvectorize.hpp``, Visual Studio 15.7.1 sees the forward declaration of ``vectorize(E&&)`` as a separate overload. - -Visual Studio 2017 double non-class parameter pack expansion -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -In ``xfixed.hpp`` we add a level of indirection to expand one parameter pack before the other. -Not doing this results in VS2017 complaining about a parameter pack that needs to be expanded in this -context while it actually is. - -Visual Studio 2022 (19.31+) workaround inline compiler optimization bug -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -In ``xstrides.hpp``, added an early return inside ``compute_strides`` when ``shape.size() == 0`` to -prevent a run time crash from occuring. Without this guard statement, instructions from inside the -for loop were somehow being reached, despite being logically unreachable. -Original issue `here. `_ -Upstream issue `here. `_ - -GCC-4.9 and Clang < 3.8 and constexpr ``std::min`` and ``std::max`` -------------------------------------------------------------------- - -``std::min`` and ``std::max`` are not constexpr in these compilers. In -``xio.hpp``, we locally define a ``XTENSOR_MIN`` macro used instead of -``std::min``. The macro is undefined right after it is used. - -Clang < 3.8 not matching ``initializer_list`` with static arrays ----------------------------------------------------------------- - -Old versions of Clang don't handle overload resolution with braced initializer -lists correctly: braced initializer lists are not properly matched to static -arrays. This prevent compile-time detection of the length of a braced -initializer list. - -A consequence is that we need to use stack-allocated shape types in these cases. -Workarounds for this compiler bug arise in various files of the code base. -Everywhere, the handling of `Clang < 3.8` is wrapped with checks for the -``X_OLD_CLANG`` macro. - -**The support of `Clang < 4.0` is dropped in xtensor 0.22.** - -Clang-cl and ``std::get`` -------------------------- - -`Clang-cl` does not allow to call ``std::get`` with ``*this`` as parameter from a class inheriting from std::tuple. -In that case, we explicitly upcast to ``std::tuple``. - -GCC < 5.1 and ``std::is_trivially_default_constructible`` ---------------------------------------------------------- - -The versions of the STL shipped with versions of GCC older than 5.1 are missing -a number of type traits, such as ``std::is_trivially_default_constructible``. -However, for some of them, equivalent type traits with different names are -provided, such as ``std::has_trivial_default_constructor``. - -In this case, we polyfill the proper standard names using the deprecated -``std::has_trivial_default_constructor``. This must also be done when the -compiler is clang when it makes use of the GCC implementation of the STL, -which is the default behavior on linux. Properly detecting the version of the -GCC STL used by clang cannot be done with the ``__GNUC__`` macro, which is -overridden by clang. Instead, we check for the definition of the macro -``_GLIBCXX_USE_CXX11_ABI`` which is only defined with GCC versions greater than -``5``. - -GCC-6 and the signature of ``std::isnan`` and ``std::isinf`` ------------------------------------------------------------- - -We are not directly using ``std::isnan`` or ``std::isinf`` for the -implementation of ``xt::isnan`` and ``xt::isinf``, as a workaround to the -following bug in GCC-6 for the following reason. - -- C++11 requires that the ```` header declares ``bool std::isnan(double)`` and ``bool std::isinf(double)``. -- C99 requires that the ```` header declares ``int ::isnan(double)`` and ``int ::isinf(double)``. - -These two definitions would clash when importing both headers and using namespace std. - -As of version 6, GCC detects whether the obsolete functions are present in the -C header ```` and uses them if they are, avoiding the clash. However, -this means that the function might return int instead of bool as C++11 -requires, which is a bug. - -GCC-8 and deleted functions ---------------------------- - -GCC-8 (8.2 specifically) doesn't seem to SFINAE deleted functions correctly. A -strided view on a dynamic_view errors with a message: use of deleted function. -It should pick the *other* implementation by SFINAE on the function -signature, because our ``has_strides`` meta-function should return -false. Instantiating the ``has_strides`` in the inner_types fixes the issue. -Original issue here: https://github.com/xtensor-stack/xtensor/issues/1273 - -Apple LLVM version >= 8.0.0 ---------------------------- - -``tuple_cat`` is bugged and propagates the constness of its tuple arguments to the types -inside the tuple. When checking if the resulting tuple contains a given type, the const -qualified type also needs to be checked. diff --git a/docs/source/conda.svg b/docs/source/conda.svg deleted file mode 100644 index 643a65320..000000000 --- a/docs/source/conda.svg +++ /dev/null @@ -1 +0,0 @@ - diff --git a/docs/source/conf.py b/docs/source/conf.py deleted file mode 100644 index 4f5fffb67..000000000 --- a/docs/source/conf.py +++ /dev/null @@ -1,51 +0,0 @@ -#!/usr/bin/env python3 -# -*- coding: utf-8 -*- - -import os -import subprocess - -on_rtd = os.environ.get('READTHEDOCS', None) == 'True' - -if on_rtd: - subprocess.call('cd ..; doxygen', shell=True) - -import sphinx_rtd_theme - -html_theme = "sphinx_rtd_theme" - -html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] - -def setup(app): - app.add_css_file("main_stylesheet.css") - -extensions = ['breathe', 'sphinx_rtd_theme'] -breathe_projects = { 'xtensor': '../xml' } -breathe_default_project = "xtensor" -templates_path = ['_templates'] -html_static_path = ['_static'] -source_suffix = '.rst' -master_doc = 'index' -project = 'xtensor' -copyright = '2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht' -author = 'Johan Mabille, Sylvain Corlay and Wolf Vollprecht' - -html_logo = 'quantstack-white.svg' - -exclude_patterns = [] -highlight_language = 'c++' -pygments_style = 'sphinx' -todo_include_todos = False -htmlhelp_basename = 'xtensordoc' - -html_js_files = [ - 'goatcounter.js' -] - -# Automatically link to NumPy doc -extensions += ['sphinx.ext.intersphinx'] -intersphinx_mapping = { - "numpy": ("https://numpy.org/doc/stable/", None), - "scipy": ("https://docs.scipy.org/doc/scipy/reference", None), - "xtensor-blas": ("https://xtensor-blas.readthedocs.io/en/stable", None), - "xtl": ("https://xtl.readthedocs.io/en/stable", None), -} diff --git a/docs/source/container.rst b/docs/source/container.rst deleted file mode 100644 index 74367b7a8..000000000 --- a/docs/source/container.rst +++ /dev/null @@ -1,220 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Arrays and tensors -================== - -Internal memory layout ----------------------- - -A multi-dimensional array of *xtensor* consists of a contiguous one-dimensional buffer combined with an indexing scheme that maps -unsigned integers to the location of an element in the buffer. The range in which the indices can vary is specified by the -`shape` of the array. - -The scheme used to map indices into a location in the buffer is a strided indexing scheme. In such a scheme, the index -``(i0, ..., in)`` corresponds to the offset ``sum(ik * sk)`` from the beginning of the one-dimensional buffer, where -``(s0, ..., sn)`` are the ``strides`` of the array. Some particular cases of strided schemes implement well-known memory layouts: - -- the row-major layout (or C layout) is a strided index scheme where the strides grow from right to left -- the column-major layout (or Fortran layout) is a strided index scheme where the strides grow from left to right - -*xtensor* provides a :cpp:enum:`xt::layout_type` enum that helps to specify the layout used by multidimensional arrays. -This enum can be used in two ways: - -- at compile time, as a template argument. The value :cpp:enumerator:`xt::layout_type::dynamic` allows specifying any - strided index scheme at runtime (including row-major and column-major schemes), while :cpp:enumerator:`xt::layout_type::row_major` - and :cpp:enumerator:`xt::layout_type::column_major` fixes the strided index scheme and disable - :cpp:func:`resize() ` and constructor overloads taking a set of strides or a layout - value as parameter. - The default value of the template parameter is :c:macro:`XTENSOR_DEFAULT_LAYOUT`. -- at runtime if the previous template parameter was set to :cpp:enumerator:`xt::layout_type::dynamic`. - In that case, :cpp:func:`resize() ` and constructor overloads allow specifying a set of - strides or a layout value to avoid strides computation. - If neither strides nor layout is specified when instantiating or resizing a multi-dimensional array, strides - corresponding to :c:macro:`XTENSOR_DEFAULT_LAYOUT` are used. - -The following example shows how to initialize a multi-dimensional array of dynamic layout with specified strides: - -.. code:: - - #include - #include - - std::vector shape = { 3, 2, 4 }; - std::vector strides = { 8, 4, 1 }; - xt::xarray a(shape, strides); - -However, this requires to carefully compute the strides to avoid buffer overflow when accessing elements of the array. -We can use the following shortcut to specify the strides instead of computing them: - -.. code:: - - #include - #include - - std::vector shape = { 3, 2, 4 }; - xt::xarray a(shape, xt::layout_type::row_major); - -If the layout of the array can be fixed at compile time, we can make it even simpler: - -.. code:: - - #include - #include - - std::vector shape = { 3, 2, 4 }; - xt::xarray a(shape); - // this shortcut is equivalent: - // xt::xarray a(shape); - -However, in the latter case, the layout of the array is forced to :cpp:enumerator:`xt::layout_type::row_major` at -compile time, and therefore cannot be changed at runtime. - -Runtime vs Compile-time dimensionality --------------------------------------- - -Three container classes implementing multidimensional arrays are provided: :cpp:type:`xt::xarray` and -:cpp:type:`xt::xtensor` and :cpp:type:`xt::xtensor_fixed`. - -- :cpp:type:`xt::xarray` can be reshaped dynamically to any number of dimensions. It is the container that is the most similar to NumPy arrays. -- :cpp:type:`xt::xtensor` has a dimension set at compilation time, which enables many optimizations. - For example, shapes and strides of :cpp:type:`xt::xtensor` instances are allocated on the stack instead of the heap. -- :cpp:type:`xt::xtensor_fixed` has a shape fixed at compile time. - This allows even more optimizations, such as allocating the storage for the container - on the stack, as well as computing strides and backstrides at compile time, making the allocation of this container extremely cheap. - -Let's use :cpp:type:`xt::xtensor` instead of :cpp:type:`xt::xarray` in the previous example: - -.. code:: - - #include - #include - - std::array shape = { 3, 2, 4 }; - xt::xtensor a(shape); - // this is equivalent to - // xt::xtensor a(shape); - -Or when using :cpp:type:`xt::xtensor_fixed`: - -.. code:: - - #include - - xt::xtensor_fixed> a(); - // or xt::xtensor_fixed, xt::layout_type::row_major>() - -:cpp:type:`xt::xarray`, :cpp:type:`xt::xtensor` and :cpp:type:`xt::xtensor_fixed` containers are all -:cpp:type:`xt::xexpression` s and can be involved and mixed in mathematical expressions, assigned to each -other etc... -They provide an augmented interface compared to other :cpp:type:`xt::xexpression` types: - -- Each method exposed in :cpp:type:`xt::xexpression` interface has its non-const counterpart exposed by - :cpp:type:`xt::xarray`, :cpp:type:`xt::xtensor` and :cpp:type:`xt::xtensor_fixed`. -- :cpp:func:`reshape() ` reshapes the container in place, and the global size of the container has to stay the same. -- :cpp:func:`resize() ` resizes the container in place, that is, if the global size of the container doesn't change, no memory allocation occurs. -- :cpp:func:`strides() ` returns the strides of the container, used to compute the position of an element in the underlying buffer. - -Reshape -------- - -The :cpp:func:`reshape() ` method accepts any kind of 1D-container, you don't have to -pass an instance of ``shape_type``. -It only requires the new shape to be compatible with the old one, that is, the number of elements in the container must -remain the same: - -.. code:: - - #include - - xt::xarray a = { 1, 2, 3, 4, 5, 6, 7, 8}; - // The following two lines ... - std::array sh1 = {2, 4}; - a.reshape(sh1); - // ... are equivalent to the following two lines ... - xt::xarray::shape_type sh2({2, 4}); - a.reshape(sh2); - // ... which are equivalent to the following - a.reshape({2, 4}); - -One of the values in the ``shape`` argument can be -1. -In this case, the value is inferred from the number of elements in the container and the remaining values in the ``shape``: - -.. code:: - - #include - xt::xarray a = { 1, 2, 3, 4, 5, 6, 7, 8}; - a.reshape({2, -1}); - // a.shape() return {2, 4} - -Performance ------------ - -The dynamic dimensionality of :cpp:type:`xt::xarray` comes at a cost. -Since the dimension is unknown at build time, the sequences holding shape and strides of :cpp:type:`xt::xarray` -instances are heap-allocated, which makes it significantly more expensive than :cpp:type:`xt::xtensor`. -Shape and strides of :cpp:type:`xt::xtensor` are stack-allocated which makes them more efficient. - -More generally, the library implements a ``promote_shape`` mechanism at build time to determine the optimal sequence -type to hold the shape of an expression. -The shape type of a broadcasting expression whose members have a dimensionality determined at compile time will have a -stack-allocated shape. -If a single member of a broadcasting expression has a dynamic dimension (for example an :cpp:type:`xt::xarray`), -it bubbles up to the entire broadcasting expression which will have a heap-allocated shape. -The same hold for views, broadcast expressions, etc... - -Aliasing and temporaries ------------------------- - -In some cases, an expression should not be directly assigned to a container. -Instead, it has to be assigned to a temporary variable before being copied into the destination container. -A typical case where this happens is when the destination container is involved in the expression and has to be resized. -This phenomenon is known as *aliasing*. - -To prevent this, *xtensor* assigns the expression to a temporary variable before copying it. -In the case of :cpp:type:`xt::xarray`, this results in an extra dynamic memory allocation and copy. - -However, if the left-hand side is not involved in the expression being assigned, no temporary variable should be required. -*xtensor* cannot detect such cases automatically and applies the "temporary variable rule" by default. -A mechanism is provided to forcibly prevent usage of a temporary variable: - -.. code:: - - #include - #include - - // a, b, and c are xt::xarrays previously initialized - xt::noalias(b) = a + c; - // Even if b has to be resized, a+c will be assigned directly to it - // No temporary variable will be involved - -Example of aliasing -~~~~~~~~~~~~~~~~~~~ - -The aliasing phenomenon is illustrated in the following example: - -.. code:: - - #include - #include - - std::vector a_shape = {3, 2, 4}; - xt::xarray a(a_shape); - - std::vector b_shape = {2, 4}; - xt::xarray b(b_shape); - - b = a + b; - // b appears on both left-hand and right-hand sides of the statement - -In the above example, the shape of ``a + b`` is ``{ 3, 2, 4 }``. -Therefore, ``b`` must first be resized, which impacts how the right-hand side is computed. - -If the values of ``b`` were copied into the new buffer directly without an intermediary variable, then we would have -``new_b(0, i, j) == old_b(i, j) for (i,j) in [0,1] x [0, 3]``. -After the resize of ``bb``, ``a(0, i, j) + b(0, i, j)`` is assigned to ``b(0, i, j)``, then, -due to broadcasting rules, ``a(1, i, j) + b(0, i, j)`` is assigned to ``b(1, i, j)``. -The issue is ``b(0, i, j)`` has been changed by the previous assignment. diff --git a/docs/source/debian.svg b/docs/source/debian.svg deleted file mode 100644 index 923265199..000000000 --- a/docs/source/debian.svg +++ /dev/null @@ -1,86 +0,0 @@ - - - - - - - - - - - - - -]> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/source/dev-build-options.rst b/docs/source/dev-build-options.rst deleted file mode 100644 index c4b12a8fe..000000000 --- a/docs/source/dev-build-options.rst +++ /dev/null @@ -1,103 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Build and configuration -======================= - -Build ------ - -*xtensor* build supports the following options: - -- ``BUILD_TESTS``: enables the ``xtest`` and ``xbenchmark`` targets (see below). -- ``DOWNLOAD_GTEST``: downloads ``gtest`` and builds it locally instead of using a binary installation. -- ``GTEST_SRC_DIR``: indicates where to find the ``gtest`` sources instead of downloading them. -- ``XTENSOR_ENABLE_ASSERT``: activates the assertions in *xtensor*. -- ``XTENSOR_CHECK_DIMENSION``: turns on ``XTENSOR_ENABLE_ASSERT`` and activates dimension checks in *xtensor*. - Note that the dimensions check should not be activated if you expect ``operator()`` to perform broadcasting. -- ``XTENSOR_USE_XSIMD``: enables simd acceleration in *xtensor*. This requires that you have xsimd_ installed - on your system. -- ``XTENSOR_USE_TBB``: enables parallel assignment loop. This requires that you have you have tbb_ installed - on your system. - - - Optionally use ``XTENSOR_TBB_THRESHOLD`` to set a minimum size to trigger parallel assignment (default is 0) - -- ``XTENSOR_USE_OPENMP``: enables parallel assignment loop using OpenMP. This requires that OpenMP is available on your system. - -All these options are disabled by default. Enabling ``DOWNLOAD_GTEST`` or -setting ``GTEST_SRC_DIR`` enables ``BUILD_TESTS``. - -If the ``BUILD_TESTS`` option is enabled, the following targets are available: - -- xtest: builds an run the test suite. -- xbenchmark: builds and runs the benchmarks. - -For instance, building the test suite of *xtensor* with assertions enabled: - -.. code:: - - mkdir build - cd build - cmake -DBUILD_TESTS=ON -DXTENSOR_ENABLE_ASSERT=ON ../ - make xtest - -Building the test suite of *xtensor* where the sources of ``gtest`` are -located in e.g. ``/usr/share/gtest``: - -.. code:: - - mkdir build - cd build - cmake -DGTEST_SRC_DIR=/usr/share/gtest ../ - make xtest - -.. _configuration-label: - -Configuration -------------- - -*xtensor* can be configured via macros, which must be defined *before* -including any of its header. Here is a list of available macros: - -- ``XTENSOR_ENABLE_ASSERT``: enables assertions in xtensor, such as bound check. -- ``XTENSOR_ENABLE_CHECK_DIMENSION``: enables the dimensions check in *xtensor*. Note that this option should not be turned - on if you expect ``operator()`` to perform broadcasting. -- ``XTENSOR_USE_XSIMD``: enables SIMD acceleration in *xtensor*. This requires that you have xsimd_ installed - on your system. -- ``XTENSOR_USE_TBB``: enables parallel assignment loop. This requires that you have you have tbb_ installed - on your system. -- ``XTENSOR_USE_OPENMP``: enables parallel assignment loop using OpenMP. This requires that OpenMP is available on your system. -- ``XTENSOR_DEFAULT_DATA_CONTAINER(T, A)``: defines the type used as the default data container for tensors and arrays. ``T`` - is the ``value_type`` of the container and ``A`` its ``allocator_type``. -- ``XTENSOR_DEFAULT_SHAPE_CONTAINER(T, EA, SA)``: defines the type used as the default shape container for tensors and arrays. - ``T`` is the ``value_type`` of the data container, ``EA`` its ``allocator_type``, and ``SA`` is the ``allocator_type`` - of the shape container. -- ``XTENSOR_DEFAULT_LAYOUT``: defines the default layout (row_major, column_major, dynamic) for tensors and arrays. We *strongly* - discourage using this macro, which is provided for testing purpose. Prefer defining alias types on tensor and array - containers instead. -- ``XTENSOR_DEFAULT_TRAVERSAL``: defines the default traversal order (row_major, column_major) for algorithms and iterators on tensors - and arrays. We *strongly* discourage using this macro, which is provided for testing purpose. - -Build the documentation ------------------------ - -First install the tools required to build the documentation: - -.. code:: - - conda install breathe doxygen sphinx_rtd_theme -c conda-forge - -You can then build the documentation: - -.. code:: - - cd docs - make html - -Type ``make help`` to see the list of available documentation targets. - -.. _xsimd: https://github.com/xtensor-stack/xsimd -.. _tbb: https://github.com/uxlfoundation/oneTBB diff --git a/docs/source/developer/assign_xexpression.svg b/docs/source/developer/assign_xexpression.svg deleted file mode 100644 index 0617796c0..000000000 --- a/docs/source/developer/assign_xexpression.svg +++ /dev/null @@ -1,2 +0,0 @@ - -
assign_xexpression(lhs, rhs)
assign_xexpression(lhs, rhs)
resize(lhs, rhs)
resize(lhs, rhs)
1
1
assign_data(lhs, rhs, trivial)
assign_data(lhs, rhs, trivial)
2
2
trivial?
trivial?
xsimd?
xsimd?
vectorized index-based loop
vectorized index-based loop
stepper-based loop
stepper-based loop
iterator-based loop
iterator-based loop
yes
yes
yes
yes
no
no
no
no diff --git a/docs/source/developer/assignment.rst b/docs/source/developer/assignment.rst deleted file mode 100644 index 2d51d7e3e..000000000 --- a/docs/source/developer/assignment.rst +++ /dev/null @@ -1,215 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -.. _xtensor-assign-label: - -Assignment -========== - -In this section, we consider the class :cpp:type:`xt::xarray` and its semantic bases (``xcontainer_semantic`` and -``xsemantic_base``) to illustrate how the assignment works. *xtensor* provides different mechanics of -assignment depending on the type of expression. - -Extended copy semantic -~~~~~~~~~~~~~~~~~~~~~~ - -:cpp:type:`xt::xarray` provides an extended copy constructor and an extended assignment operator: - -.. code:: - - template - xarray(const xexpression&); - - template - self_type& operator=(const xexpression& e); - -The assignment operator forwards to ``xsemantic_base::operator=`` whose implementation is given below: - -.. code:: - - template - derived_type& operator=(const xexpression& e) - { - temporary_type tmp(e); - return this->derived_cast().assign_temporary(std::move(tmp)); - } - -Here ``temporary_type`` is :cpp:type:`xt::xarray`, the assignment operator computes the result of the expression in -a temporary variable and then assigns it to the :cpp:type:`xt::xarray` instance. This temporary variable avoids aliasing -when the array is involved in the rhs expression where broadcasting happens: - -.. code:: - - xarray a = {1, 2, 3, 4}; - xarray b = {{1, 2, 3, 4}, - {5, 6, 7, 8}}; - a = a + b; - -The extended copy constructor calls ``xsemantic_base::assign`` which calls ``xcontainer::assign_xexpression``. -This two-steps invocation allows to provide an uniform API (assign, plus_assign, minus_assign, etc) in the -top base class while specializing the implementations in inheriting classes (``xcontainer_semantic`` and -``xview_semantic``). ``xcontainer::assign_xexpression`` eventually calls the free function ``xt::assign_xexpression`` -which will be discussed in details later. - -The behavior of the extended copy semantic can be summarized with the following diagram: - -.. image:: extended_copy_semantic.svg - -Computed assignment -~~~~~~~~~~~~~~~~~~~ - -Computed assignment can be achieved either with traditional operators (``operator+=``, ``operator-=``) or -with the corresponding assign functions (``plus_assign``, ``minus_assign``, etc). The computed assignment -operators forwards to the extended assignment operator as illustrated below: - -.. code:: - - template - template - inline auto xsemantic_base::operator+=(const xexpression& e) -> derived_type& - { - return operator=(this->derived_cast() + e.derived_cast()); - } - -The computed assign functions, like ``assign`` itself, avoid the instantiation of a temporary variable. -They call the overload of ``computed_assign`` which, in the case of ``xcontainer_semantic``, simply forwards -to the free function ``xt::computed_assign``: - -.. code:: - - template - template - inline auto xsemantic_base::plus_assign(const xexpression& e) -> derived_type& - { - return this->derived_cast().computed_assign(this->derived_cast() + e.derived_cast()); - } - - template - template - inline auto xcontainer_semantic::computed_assign(const xexpression& e) -> derived_type& - { - xt::computed_assign(*this, e); - return this->derived_cast(); - } - -Again this two-steps invocation allows to provide a uniform API in ``xsemantic_base`` and specializations -in the inheriting semantic classes. Besides this allows some code factorization since the assignment -logic is implemented only once in ``xt::computed_assign``. - -Scalar computed assignment -~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Computed assignment operators involving a scalar are similar to computed assign methods: - -.. code:: - - template - template - inline auto xsemantic_base::operator+=(const E& e) -> disable_xexpression - { - return this->derived_cast().scalar_computed_assign(e, std::plus<>()); - } - - template - template - inline auto xcontainer_semantic::scalar_computed_assign(const E& e, F&& f) -> derived_type& - { - xt::scalar_computed_assign(*this, e, std::forward(f)); - return this->derived_cast(); - } - -The free function ``xt::scalar_computed_assign`` contains optimizations specific to scalars. - -Expression assigners -~~~~~~~~~~~~~~~~~~~~ - -The three main functions for assigning expressions (``assign_xexpression``, ``computed_assign`` and -``scalar_computed_assign``) have a similar implementation: they forward the call to the -``xexpression_assigner``, a template class that can be specialized according to the expression -tag: - -.. code:: - - template - inline void assign_xexpression(xexpression& e1, const xexpression& e2) - { - using tag = xexpression_tag_t; - xexpression_assigner::assign_xexpression(e1, e2); - } - - template - class xexpression_assigner : public xexpression_assigner_base - { - public: - - using base_type = xexpression_assigner_base; - - template - static void assign_xexpression(xexpression& e1, const xexpression& e2); - - template - static void computed_assign(xexpression& e1, const xexpression& e2); - - template - static void scalar_computed_assign(xexpression& e1, const E2& e2, F&& f); - - // ... - }; - -*xtensor* provides specializations for ``xtensor_expression_tag`` and ``xoptional_expression_tag``. -When implementing a new function type whose API is unrelated to the one of ``xfunction_base``, -the ``xexpression_assigner`` should be specialized so that the assignment relies on this specific API. - -assign_xexpression -~~~~~~~~~~~~~~~~~~ - -The ``assign_xexpression`` methods first resizes the lhs expression, it chooses an assignment -method depending on many properties of both lhs and rhs expressions. One of these properties, computed -during the resize phase, is the nature of the assignment: trivial or not. The assignment is said to be -trivial when the memory layout of the lhs and rhs are such that assignment can be done by iterating over -a 1-D sequence on both sides. In that case, two options are possible: - -- if *xtensor* is compiled with the optional *xsimd* dependency, and if the layout and the - ``value_type`` of each expression allows it, the assignment is a vectorized index-based loop - operating on the expression buffers. -- if the *xsimd* assignment is not possible (for any reason), an iterator-based loop operating - on the expresion buffers is used instead. - -These methods are implemented in specializations of the ``trivial_assigner`` class. - -When the assignment is not trivial, :ref:`stepper-label` are used to perform the assignment. Instead of -using ``xiterator`` of each expression, an instance of ``data_assigner`` holds both steppers and makes -them step together. - -.. image:: assign_xexpression.svg - -computed_assign -~~~~~~~~~~~~~~~ - -The ``computed_assign`` method is slightly different from the ``assign_xexpression`` method. After -resizing the lhs member, it checks if some broadcasting is involved. If so, the rhs expression is -evaluated into a temporary and the temporary is assigned to the lhs expression, otherwise rhs is -directly evaluated in lhs. This is because a computed assignment always implies aliasing (meaning -that the lhs is also involved in the rhs): ``a += b;`` is equivalent to ``a = a + b;``. - -.. image:: computed_assign.svg - -scalar_computed_assign -~~~~~~~~~~~~~~~~~~~~~~ - -The ``scalar_computed_assign`` method simply iterates over the expression and applies the scalar -operation on each value: - -.. code:: - - template - template - inline void xexpression_assigner::scalar_computed_assign(xexpression& e1, const E2& e2, F&& f) - { - E1& d = e1.derived_cast(); - std::transform(d.cbegin(), d.cend(), d.begin(), - [e2, &f](const auto& v) { return f(v, e2); }); - } diff --git a/docs/source/developer/computed_assign.svg b/docs/source/developer/computed_assign.svg deleted file mode 100644 index 518784652..000000000 --- a/docs/source/developer/computed_assign.svg +++ /dev/null @@ -1,2 +0,0 @@ - -
computed_assign(lhs, rhs)
computed_assign(lhs, rhs)
resize(lhs, rhs)
resize(lhs, rhs)
1
1
assign_data(lhs, rhs, trivial)
assign_data(lhs, rhs, trivial)
2
2
broadcasting?
broadcasting?
no
no
assign_data(tmp, rhs, trivial)
assign_data(tmp, rhs, trivial)
lhs.assign_temporary(tmp)
lhs.assign_temporary(tmp)
yes
yes
1
1
2
2 diff --git a/docs/source/developer/concepts.rst b/docs/source/developer/concepts.rst deleted file mode 100644 index 06de0ffd2..000000000 --- a/docs/source/developer/concepts.rst +++ /dev/null @@ -1,304 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -.. _concepts-label: - -Concepts -======== - -*xtensor*'s core is built upon key concepts captured in interfaces that are put together in derived -classes through CRTP (`Curiously Recurring Template Pattern -`_) and multiple inheritance. -Interfaces and classes that model expressions implement *value semantic*. CRTP and value semantic -achieve static polymorphism and avoid performance overhead of virtual methods and dynamic -dispatching. - -xexpression -~~~~~~~~~~~ - -:cpp:type:`xt::xexpression` is the base class for all expression classes. It is a CRTP base whose template -parameter must be the most derived class in the hierarchy. For instance, if ``A`` inherits -from ``B`` which in turn inherits from :cpp:type:`xt::xexpression`, then ``B`` should be a template -class whose template parameter is ``A`` and should forward this parameter to :cpp:type:`xt::xexpression`: - -.. code:: - - #include - - template - class B : public xexpression - { - // ... - }; - - class A : public B - { - // ... - }; - -:cpp:type:`xt::xexpression` only provides three overloads of a same function, that cast an :cpp:type:`xt::xexpression` -object to the most inheriting type, depending on the nature of the object (*lvalue*, -*const lvalue* or *rvalue*): - -.. code:: - - derived_type& derived_cast() & noexcept; - const derived_type& derived_cast() const & noexcept; - derived_type derived_cast() && noexcept; - -.. _xiterable-concept-label: - -xiterable -~~~~~~~~~ - -The iterable concept is modeled by two classes, ``xconst_iterable`` and ``xiterable``, defined -in ``xtensor/core/xiterable.hpp``. ``xconst_iterable`` provides types and methods for iterating on -constant expressions, similar to the ones provided by the STL containers. Unlike the STL, the -methods of ``xconst_iterable`` and ``xiterable`` are templated by a layout parameter that allows -you to iterate over a N-dimensional expression in row-major order or column-major order. - -.. note:: - - Row-major layout means that elements that only differ by their last index are contiguous in - memory. Column-major layout means that elements that only differ by their first index are - contiguous in memory. - - .. image:: iteration.svg - -.. code:: - - template - const_iterator begin() const noexcept; - template - const_iterator end() const noexcept; - template - const_iterator cbegin() const noexcept; - template - const_iterator cend() const noexcept; - - template - const_reverse_iterator rbegin() const noexcept; - template - const_reverse_iterator rend() const noexcept; - template - const_reverse_iterator crbegin() const noexcept; - template - const_reverse_iterator crend() const noexcept; - -This template parameter is defaulted to ``XTENSOR_DEFAULT_TRAVERSAL`` (see :ref:`configuration-label`), so -that *xtensor* expressions can be used in generic code such as: - -.. code:: - - std::copy(a.cbegin(), a.cend(), b.begin()); - -where ``a`` and ``b`` can be arbitrary types (from *xtensor*, the STL or any external library) -supporting standard iteration. - -``xiterable`` inherits from ``xconst_iterable`` and provides non-const counterpart of methods -defined in ``xconst_iterable``. Like :cpp:type:`xt::xexpression`, both are CRTP classes whose template -parameter must be the most derived type. - -Besides traditional methods for iterating, ``xconst_iterable`` and ``xiterable`` provide overloads -taking a shape parameter. This allows to iterate over an expression as if it was broadcast to the -given shape: - -.. code:: - - #include - #include - #include - #include - - int main(int argc, char* argv[]) - { - xt::xarray a = { 1, 2, 3 }; - std::vector shape = { 2, 3 }; - std::copy(a.cbegin(shape), a.cend(shape), std::output_iterator(std::cout, " ")); - // output: 1 2 3 1 2 3 - } - -Iterators returned by methods defined in ``xconst_iterable`` and ``xiterable`` are random access -iterators. - -.. _xsemantic-concept-label: - -xsemantic -~~~~~~~~~ - -The ``xsemantic_base`` interface provides methods for assigning an expression: - -.. code:: - - template - disable_xexpression operator+=(const E&); - - template - derived_type& operator+=(const xexpression&); - -and similar methods for ``operator-=``, ``operator*=``, ``operator/=``, ``operator%=``, -``operator&=``, ``operator|=`` and ``operator^=``. - -The first overload is meant for computed assignment involving a scalar; it allows to write code like - -.. code:: - - #include - #include - - int main(int argc, char* argv) - { - xarray a = { 1, 2, 3 }; - a += 4; - std::cout << a << std::endl; - // outputs { 5, 6, 7 } - } - -We rely on SFINAE to remove this overload from the overload resolution set when the parameter that we want -to assign is not a scalar, avoiding ambiguity. - -Operator-based methods taking a general :cpp:type:`xt::xexpression` parameter don't perform a direct assignment. Instead, -the result is assigned to a temporary variable first, in order to prevent issues with aliasing. Thus, if ``a`` -and ``b`` are expressions, the following - -.. code:: - - a += b - -is equivalent to - -.. code:: - - temporary_type tmp = a + b; - a.assign(tmp); - -Temporaries can be avoided with the assign-based methods: - -.. code:: - - template - derived_type& plus_assign(const xexpression&); - template - derived_type&> minus_assign(const xexpression&); - template - derived_type& multiplies_assign(const xexpression&); - template - derived_type& divides_assign(const xexpression&); - template - derived_type& modulus_assign(const xexpression&); - -``xsemantic_base`` is a CRTP class whose parameter must be the most derived type in the hierarchy. It inherits -from :cpp:type:`xt::xexpression` and forwards its template parameter to this latter one. - -``xsemantic_base`` also provides a assignment operator that takes an :cpp:type:`xt::xexpression` in its protected section: - -.. code:: - - template - derived_type& operator=(const xexpression&); - -Like computed assignment operators, it evaluates the expression inside a temporary before calling the ``assign`` -method. Classes inheriting from ``xsemantic_base`` must redeclare this method either in their protected section -(if they are not final classes) or in their public section. In both cases, they should forward the call to their -base class. - -Two refinements of this concept are provided, ``xcontainer_semantic`` and ``xview_semantic``. Refer to the -:ref:`xtensor-assign-label` section for more details about semantic classes and how they're involved in expression -assignment. - -xsemantic classes hierarchy: - -.. image:: xsemantic_classes.svg - -.. _xcontainer-concept-label: - -xcontainer -~~~~~~~~~~ - -The ``xcontainer`` class provides methods for container-based expressions. It does not hold any data, this is delegated -to inheriting classes. It assumes the data are stored using a strided-index scheme. ``xcontainer`` defines the following -methods: - -**Shape, strides and size** - -.. code:: - - size_type size() const noexcept; - size_type dimension() const noexcept; - - const inner_shape_type& shape() const noexcept; - const inner_strides_type& strides() const noexcept; - const inner_backstrides_type& backstrides() const noexcept; - -**Data access methods** - -.. code:: - - template - const_reference operator()(Args... args) const; - - template - const_reference at(Args... args) const; - - template - disable_integral_t operator[](const S& index) const; - - template - const_reference operator[](std::initializer_list index) const; - - template - const_reference element(It first, It last) const; - - const storage_type& storage() const; - -(and their non-const counterpart) - -**Broadcasting methods** - -.. code:: - - template - bool broadcast_shape(const S& shape) const; - -Lower-level methods are also provided, meant for optimized assignment and BLAS bindings. -They are covered in the :ref:`xtensor-assign-label` section. - -If you read the entire code of ``xcontainer``, you'll notice that two types are defined for shape, -strides and backstrides: ``shape_type`` and ``inner_shape_type``, ``strides_type`` and -``inner_strides_type``, and ``backstrides_type`` and ``inner_backstrides_type``. The distinction -between ``inner_shape_type`` and ``shape_type`` was motivated by the xtensor-python wrapper around -NumPy data structures, where the inner shape type is a proxy on the shape section of the NumPy -arrayobject. It cannot have a value semantics on its own as it is bound to the entire NumPy array. - -``xstrided_container`` inherits from ``xcontainer``; it represents a container that holds its shape -and strides. It provides methods for reshaping the container: - -.. code:: - - template - void resize(D&& shape, bool force = false); - - template - void resize(S&& shape, layout_type l); - - template - void resize(S&& shape, const strides_type& strides); - - template - void reshape(S&& shape, layout_type l); - -Both ``xstrided_container`` and ``xcontainer`` are CRTP classes whose template parameter must be -the most derived type in the hierarchy. Besides, ``xcontainer`` inherits from ``xiterable``, -thus providing iteration methods. - -.. image:: xcontainer_classes.svg - -xfunction -~~~~~~~~~ - -The ``xfunction`` class is used to model mathematical operations and functions. It provides similar -methods to the ones defined in ``xcontainer``, and embeds the functor describing the operation and -its operands. It inherits from ``xconst_iterable``, thus providing iteration methods. diff --git a/docs/source/developer/expression_tree.rst b/docs/source/developer/expression_tree.rst deleted file mode 100644 index b33907e05..000000000 --- a/docs/source/developer/expression_tree.rst +++ /dev/null @@ -1,193 +0,0 @@ -.. Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht - - Distributed under the terms of the BSD 3-Clause License. - - The full license is in the file LICENSE, distributed with this software. - -Expression tree -=============== - -Most of the expressions in *xtensor* are lazy-evaluated, they do not hold any value, the values are computed upon -access or when the expression is assigned to a container. This means that *xtensor* needs somehow to keep track of -the expression tree. - -xfunction -~~~~~~~~~ - -A node in the expression tree may be represented by different classes in *xtensor*; here we focus on basic arithmetic -operations and mathematical functions, which are represented by an instance of ``xfunction``. This is a template -class whose parameters are: - -- a functor describing the operation of the mathematical function -- the closures of the child expressions, i.e. the most optimal way to store each child expression - -Consider the following code: - -.. code:: - - xarray a = xt::ones({2, 2}); - xarray b = xt::ones({2, 2}); - - auto f = (a + b); - -Here the type of ``f`` is ``xfunction&, const xarray&>``, and f stores constant -references on the arrays involved in the operation. This can be illustrated by the figure below: - -.. image:: xfunction_tree.svg - -The implementation of ``xfunction`` methods is quite easy: they forward the call to the nodes and apply the operation -when this makes sense. For instance, assuming that the operands are stored as ``m_first`` and ``m_second``, and the functor -describing the operation as ``m_functor``, the implementation of ``operator()`` and ``broadcast_shape`` looks like: - -.. code:: - - template - template - inline auto xfunction::operator()(Args... args) const -> const_reference - { - return m_functor(m_first(args...), m_second(args...)); - } - - template - template - inline bool xfunction::broadcast_shape(S& shape) const - { - return m_first.broadcast_shape(shape) && m_second.broadcast_shape(shape); - } - -In fact, ``xfunction`` can handle an arbitrary number of arguments. The practical implementation is slightly more -complicated than the code snippet above, however the principle remains the same. - -Holding expressions -~~~~~~~~~~~~~~~~~~~ - -Each node of an expression tree holds const references to its child nodes, or the child nodes themselves, depending on -their nature. When building a complex expression, if a part of this expression is an rvalue, it is moved inside its -parent, else a constant reference is used: - -.. code:: - - xarray some_function(); - - xarray a = xt::ones({2, 2}); - auto f = a + some_function(); - -Here ``f`` holds a constant reference on ``a``, while the array returned by ``some_function`` is moved into ``f``. -The actual types held by the expression are the **closure types**, more details can be found in :ref:`closure-semantics-label`. - -Building the expression tree -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -As previously stated, each mathematical function in xtensor returns an instance of ``xfunction``. This section explains -in details how the template parameters of ``xfunction`` are computed according to the type of the function, the number -and the types of its arguments. Let's consider the definition of ``operator+``: - -.. code:: - - template - inline auto operator+(E1&& e1, E2&& e2) -> detail::xfunction_type - { - return detail::make_xfunction(std::forward(e1), std::forward(e2)); - } - -This top-level function selects the appropriate functor and forwards its arguments to the ``make_xfunction`` generator. -This latter is responsible for setting the remaining template parameters of ``xfunction``: - -.. code:: - - template