diff --git a/.appveyor.yml b/.appveyor.yml
deleted file mode 100644
index 5e2ac542a..000000000
--- a/.appveyor.yml
+++ /dev/null
@@ -1,51 +0,0 @@
-build: false
-
-platform:
-  - x64
-  - x86
-
-image:
-  - Previous Visual Studio 2017
-  - Visual Studio 2015
-
-environment:
-  matrix:
-    - MINICONDA: C:\xtensor-conda
-
-init:
-  - "ECHO %MINICONDA%"
-  - if "%APPVEYOR_BUILD_WORKER_IMAGE%" == "Visual Studio 2015" set VCVARPATH="C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat"
-  - if "%APPVEYOR_BUILD_WORKER_IMAGE%" == "Visual Studio 2015" set VCARGUMENT=%PLATFORM%
-  - if "%APPVEYOR_BUILD_WORKER_IMAGE%" == "Previous Visual Studio 2017" if "%PLATFORM%" == "x64" set VCVARPATH="C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-  - if "%APPVEYOR_BUILD_WORKER_IMAGE%" == "Previous Visual Studio 2017" if "%PLATFORM%" == "x86" set VCVARPATH="C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars32.bat"
-  - echo "%VCVARPATH% %VCARGUMENT%"
-  - "%VCVARPATH% %VCARGUMENT%"
-  - ps: if($env:Platform -eq "x64"){Start-FileDownload 'http://repo.continuum.io/miniconda/Miniconda3-latest-Windows-x86_64.exe' C:\Miniconda.exe; echo "Done"}
-  - ps: if($env:Platform -eq "x86"){Start-FileDownload 'http://repo.continuum.io/miniconda/Miniconda3-latest-Windows-x86.exe' C:\Miniconda.exe; echo "Done"}
-  - cmd: C:\Miniconda.exe /S /D=C:\xtensor-conda
-  - "set PATH=%MINICONDA%;%MINICONDA%\\Scripts;%MINICONDA%\\Library\\bin;%PATH%"
-
-install:
-  - conda config --set always_yes yes --set changeps1 no
-  - conda update -q conda
-  - conda info -a
-  - conda install gtest=1.8.0 cmake -c conda-forge
-  - conda install xtl==0.4.16 -c QuantStack
-  - conda install xsimd -c QuantStack
-  - conda install nlohmann_json -c QuantStack
-    #- cmake -G "NMake Makefiles" -D CMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON -DXTENSOR_USE_XSIMD=ON -DDISABLE_VS2017=ON .
-    #- cmake -G "NMake Makefiles" -D CMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON -DDISABLE_VS2017=ON .
-    #- if "%APPVEYOR_BUILD_WORKER_IMAGE%" == "Visual Studio 2015" if "%PLATFORM%" == "x64" cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON -DXTENSOR_USE_XSIMD=ON .
-    #- if "%APPVEYOR_BUILD_WORKER_IMAGE%" == "Visual Studio 2015" if "%PLATFORM%" == "x86" cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON .
-    #- if "%APPVEYOR_BUILD_WORKER_IMAGE%" == "Previous Visual Studio 2017" cmake -G "NMake Makefiles" -D CMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON -DDISABLE_VS2017=ON .
-  - ps: if($env:APPVEYOR_BUILD_WORKER_IMAGE -eq "Visual Studio 2015" -And $env:Platform -eq "x64") {
-        cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON -DXTENSOR_USE_XSIMD=ON .
-        }
-        else {
-        cmake -G "NMake Makefiles" -D CMAKE_INSTALL_PREFIX=%MINICONDA%\\LIBRARY -DBUILD_TESTS=ON -DDISABLE_VS2017=ON .
-        }
-  - nmake test_xtensor_lib
-  - cd test
-
-build_script:
-  - .\test_xtensor_lib
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 000000000..3cdca3d53
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,90 @@
+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: <xtensor/.+>
+  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
new file mode 100644
index 000000000..3de597778
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,13 @@
+# 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
+
+<!---
+Give any relevant description here.
+If your PR fixes an issue, please include "Fixes #ISSUE" (substituting the relevant issue ID).
+-->
diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
new file mode 100644
index 000000000..9ec6f8f33
--- /dev/null
+++ b/.github/workflows/benchmarks.yml
@@ -0,0 +1,73 @@
+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/codspeed.yml b/.github/workflows/codspeed.yml
new file mode 100644
index 000000000..05d385180
--- /dev/null
+++ b/.github/workflows/codspeed.yml
@@ -0,0 +1,52 @@
+name: CodSpeed
+
+on:
+  push:
+    branches: [master]
+  pull_request: # Allow CodSpeed to trigger backtest performance analysis
+
+  workflow_dispatch:
+
+
+permissions:
+  contents: read
+  id-token: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.job }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: bash -e -l {0}
+
+jobs:
+  benchmarks:
+    name: Run benchmarks
+    runs-on: namespace-profile-benchmark;container.privileged=true;container.host-pid-namespace=true
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v6
+
+    - 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: Build benchmarks
+      run: |
+        cmake -G Ninja -Bbuild \
+          -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX \
+          -DBUILD_BENCHMARK=ON \
+          -DXTENSOR_USE_XSIMD=ON \
+          -DCODSPEED_MODE=simulation
+        cmake --build build --target benchmark_xtensor --parallel 8
+
+    - name: Run benchmarks
+      uses: CodSpeedHQ/action@v4
+      with:
+        mode: simulation
+        run: ./build/benchmark/benchmark_xtensor
diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
new file mode 100644
index 000000000..f86b5256a
--- /dev/null
+++ b/.github/workflows/gh-pages.yml
@@ -0,0 +1,48 @@
+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
new file mode 100644
index 000000000..25f105dd5
--- /dev/null
+++ b/.github/workflows/issue-close.yml
@@ -0,0 +1,33 @@
+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: 365
+        days-before-issue-close: 14
+        stale-issue-label: Stale
+        stale-issue-message: |
+          This issue is stale because it has been open for 365 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
new file mode 100644
index 000000000..1a66aa273
--- /dev/null
+++ b/.github/workflows/linux.yml
@@ -0,0 +1,102 @@
+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: ${{ matrix.os }}
+    name: ${{ matrix.os }} ${{ matrix.sys.compiler }} ${{ matrix.sys.version }} - ${{ matrix.sys.name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, ubuntu-24.04-arm]
+        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: clang, version: '21', name: column-major, flags: -DDEFAULT_COLUMN_MAJOR=ON}
+        - {compiler: clang, version: '22', name: assert, flags: -DXTENSOR_ENABLE_ASSERT=ON}
+        - {compiler: clang, version: '22', name: column-major, flags: -DDEFAULT_COLUMN_MAJOR=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}
+        # TODO: Activate following gcc versions when switching github runner to ubuntu 26.04
+        # - {compiler: gcc, version: '15', name: xsimd-tbb, flags: -DXTENSOR_USE_XSIMD=ON -DXTENSOR_USE_TBB=ON}
+        # - {compiler: gcc, version: '15', name: tbb, flags: -DXTENSOR_USE_TBB=ON -DTBB_INCLUDE_DIR=$CONDA_PREFIX/include -DTBB_LIBRARY=$CONDA_PREFIX/lib}
+        # - {compiler: gcc, version: '16', name: xsimd-tbb, flags: -DXTENSOR_USE_XSIMD=ON -DXTENSOR_USE_TBB=ON}
+        # - {compiler: gcc, version: '16', name: tbb, flags: -DXTENSOR_USE_TBB=ON -DTBB_INCLUDE_DIR=$CONDA_PREFIX/include -DTBB_LIBRARY=$CONDA_PREFIX/lib}
+        exclude:
+        - os: ubuntu-24.04-arm
+          sys:
+            compiler: gcc
+            version: '12'
+        - os: ubuntu-24.04-arm
+          sys:
+            compiler: gcc
+            version: '11'
+
+    steps:
+    - name: Install GCC
+      if: matrix.sys.compiler == 'gcc'
+      uses: egor-tensin/setup-gcc@v2
+      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@v6
+
+    - 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
new file mode 100644
index 000000000..5dbce477e
--- /dev/null
+++ b/.github/workflows/osx.yml
@@ -0,0 +1,50 @@
+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/sanitizers.yml b/.github/workflows/sanitizers.yml
new file mode 100644
index 000000000..c008e832c
--- /dev/null
+++ b/.github/workflows/sanitizers.yml
@@ -0,0 +1,110 @@
+name: Sanitizers
+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.os }}
+    name: sanitizer / ${{ matrix.sys.compiler }} ${{ matrix.sys.version }} / ${{ matrix.config.name }} / ${{ matrix.sys.name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04]
+        sys:
+        - {compiler: clang, version: '21', name: asan, sanitizer: address}
+        - {compiler: clang, version: '21', name: lsan, sanitizer: leak}
+        - {compiler: clang, version: '21', name: ubsan, sanitizer: undefined}
+        config:
+        - {name: Debug}
+
+    steps:
+
+    - 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@v6
+
+    - 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: |
+        export CC=clang
+        export CXX=clang++
+        cmake -G Ninja \
+          -Bbuild \
+          -DCMAKE_BUILD_TYPE=${{matrix.config.name}} \
+          -DCMAKE_INSTALL_PREFIX=$CONDA_PREFIX \
+          -DBUILD_TESTS=ON \
+          -DUSE_SANITIZER=${{ matrix.sys.sanitizer }}
+
+    - name: Build tests
+      working-directory: build
+      run: cmake --build . --config ${{matrix.config.name}} --target test_xtensor_lib --parallel 8
+
+    - name: Run tests
+      working-directory: build
+      run: |
+        SAN=${{ matrix.sys.sanitizer }}
+        case "$SAN" in
+          address)
+            export ASAN_OPTIONS=log_path=asan_log_:alloc_dealloc_mismatch=0:halt_on_error=0:handle_abort=0
+            export ASAN_SAVE_DUMPS=AsanDump.dmp
+            ;;
+          leak)
+            export LSAN_OPTIONS=log_path=lsan_log_:halt_on_error=0
+            ;;
+          undefined)
+            export UBSAN_OPTIONS=log_path=ubsan_log_:halt_on_error=0:print_stacktrace=1
+            ;;
+        esac
+        ctest -R ^xtest$ --output-on-failure
+
+    - name: Upload sanitizer log
+      if: always()
+      uses: actions/upload-artifact@v6
+      with:
+        name: sanitizer-log-${{ matrix.sys.sanitizer }}-${{ matrix.sys.compiler }}-${{ matrix.sys.version }}-${{ matrix.config.name }}-${{ runner.os }}
+        path: '**/*san_log_*'
+        if-no-files-found: ignore
+
+    - name: Upload sanitizer dump
+      if: always()
+      uses: actions/upload-artifact@v6
+      with:
+        name: sanitizer-dump-${{ matrix.sys.sanitizer }}-${{ matrix.sys.compiler }}-${{ matrix.sys.version }}-${{ matrix.config.name }}-${{ runner.os }}
+        path: '**/AsanDump.dmp'
+        if-no-files-found: ignore
+
+    - name: Return errors if sanitizer log content is not empty
+      if: always()
+      run: |
+        if [ -n "$(find build/test -name '*san_log_*' -type f -size +0 2>/dev/null)" ]; then
+          echo "Sanitizer detected errors. See the log for details."
+          exit 1
+        fi
diff --git a/.github/workflows/static-analysis.yml b/.github/workflows/static-analysis.yml
new file mode 100644
index 000000000..64fe21244
--- /dev/null
+++ b/.github/workflows/static-analysis.yml
@@ -0,0 +1,22 @@
+name: Static Analysis
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: pre-commit/action@v3.0.1
+
+  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
new file mode 100644
index 000000000..c04adc626
--- /dev/null
+++ b/.github/workflows/windows.yml
@@ -0,0 +1,64 @@
+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
index a57e2c3b3..4a5bcec30 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,7 @@
+# Doxygen output
+docs/html/
+docs/xml/
+
 # Prerequisites
 *.d
 
@@ -29,6 +33,10 @@
 
 # Vim tmp files
 *.swp
+*~
+
+# Generated directory
+include/tmp/
 
 # Build directory
 build/
@@ -49,5 +57,12 @@ 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/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 000000000..bfc98b9cf
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,48 @@
+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/.travis.yml b/.travis.yml
deleted file mode 100644
index a11787c40..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,156 +0,0 @@
-language: cpp
-dist: trusty
-env:
-matrix:
-  fast_finish: true
-  include:
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-4.9
-      env: COMPILER=gcc GCC=4.9
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-5
-      env: COMPILER=gcc GCC=5 DISABLE_XSIMD=1
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
-      env: COMPILER=gcc GCC=6 ENABLE_TBB=1
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
-      env: COMPILER=gcc GCC=6 BOUND_CHECKS=1 BUILD_BENCHMARK=1
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
-      env: COMPILER=gcc GCC=6 COLUMN_MAJOR_LAYOUT=1
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-4.9
-            - clang-3.6
-      env: COMPILER=clang CLANG=3.6 DISABLE_XSIMD=1 
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-3.9
-          packages:
-            - g++-4.9
-            - clang-3.9
-      env: COMPILER=clang CLANG=3.9
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-          packages:
-            - g++-4.9
-            - clang-4.0
-      env: COMPILER=clang CLANG=4.0 DISABLE_XSIMD=1
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-          packages:
-            - g++-4.9
-            - clang-5.0
-      env: COMPILER=clang CLANG=5.0 ENABLE_TBB=1 DISABLE_XSIMD=1
-    - os: linux
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-          packages:
-            - clang-6.0
-      env: COMPILER=clang CLANG=6.0
-    - os: osx
-      osx_image: xcode8
-      compiler: clang
-env:
-  global:
-    - MINCONDA_VERSION="latest"
-    - MINCONDA_LINUX="Linux-x86_64"
-    - MINCONDA_OSX="MacOSX-x86_64"
-before_install:
-    - |
-      # Configure build variables
-      if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-        if [[ "$COMPILER" == "gcc" ]]; then
-          export CXX=g++-$GCC CC=gcc-$GCC;
-        fi
-        if [[ "$COMPILER" == "clang" ]]; then
-          export CXX=clang++-$CLANG CC=clang-$CLANG;
-        fi
-      elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-        export CXX=clang++ CC=clang;
-      fi
-install:
-    # Define the version of miniconda to download
-    - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-        MINCONDA_OS=$MINCONDA_LINUX;
-      elif [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-        MINCONDA_OS=$MINCONDA_OSX;
-      fi
-    - wget "http://repo.continuum.io/miniconda/Miniconda3-$MINCONDA_VERSION-$MINCONDA_OS.sh" -O miniconda.sh;
-    - bash miniconda.sh -b -p $HOME/miniconda
-    - export PATH="$HOME/miniconda/bin:$PATH"
-    - hash -r
-    - conda config --set always_yes yes --set changeps1 no
-    - conda update -q conda
-    - conda install gtest=1.8.0 cmake -c conda-forge
-    - conda install xtl==0.4.16 -c QuantStack
-    - conda install xsimd -c QuantStack
-    - conda install nlohmann_json -c QuantStack
-    - if [[ "$ENABLE_TBB" == 1 ]]; then
-        conda install tbb-devel -c conda-forge;
-      fi
-    # Testing
-    - mkdir build
-    - cd build
-    - if [[ "$BOUND_CHECKS" == 1 ]]; then
-        cmake -DXTENSOR_ENABLE_ASSERT=ON -DDOWNLOAD_GTEST=ON -DBUILD_BENCHMARK=ON ..;
-      elif [[ "$COLUMN_MAJOR_LAYOUT" == 1 ]]; then
-        cmake -DBUILD_TESTS=ON -DDEFAULT_COLUMN_MAJOR=ON ..;
-      elif [[ "$DISABLE_XSIMD" == 1 ]]; then
-        cmake -DBUILD_TESTS=ON ..;
-      elif [[ "$ENABLE_TBB" == 1 ]]; then
-        cmake -DDOWNLOAD_GTEST=ON -DXTENSOR_USE_XSIMD=ON -DXTENSOR_USE_TBB=ON -DTBB_INCLUDE_DIR=/home/travis/miniconda/include -DTBB_LIBRARY=/home/travis/miniconda/lib ..;
-      else
-        cmake -DXTENSOR_USE_XSIMD=ON -DBUILD_TESTS=ON ..;
-      fi
-    - make -j2 test_xtensor_lib
-    - if [[ "$BUILD_BENCHMARK" == 1 ]]; then
-        make -j2 benchmark_xtensor ;
-      fi
-    - cd test
-script:
-    - ./test_xtensor_lib
diff --git a/CMakeLists.txt b/CMakeLists.txt
index feee99e88..331fb48c2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,20 +1,32 @@
 ############################################################################
-# Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht    #
+# 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.1)
-project(xtensor)
+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/xtensor_config.hpp" xtensor_version_defines
+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) +([^ ]+)$")
@@ -28,99 +40,187 @@ message(STATUS "Building xtensor v${${PROJECT_NAME}_VERSION}")
 # Dependencies
 # ============
 
-set(xtl_REQUIRED_VERSION 0.4.16)
-find_package(xtl ${xtl_REQUIRED_VERSION} REQUIRED)
-
-message(STATUS "Found xtl: ${xtl_INCLUDE_DIRS}/xtl")
+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 14.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/xaccumulator.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xadapt.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xarray.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xassign.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xaxis_iterator.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xbroadcast.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xbuffer_adaptor.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xbuilder.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xcomplex.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xconcepts.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xcontainer.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xcsv.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xdynamic_view.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xeval.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xexception.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xexpression.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xexpression_holder.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xfixed.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xfunction.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xfunctor_view.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xgenerator.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xhistogram.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xindex_view.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xinfo.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xio.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xiterable.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xiterator.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xjson.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xlayout.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xmanipulation.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xmasked_value.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xmasked_view.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xmath.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xnoalias.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xnorm.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xnpy.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xoffset_view.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xoperation.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xoptional.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xoptional_assembly.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xoptional_assembly_base.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xoptional_assembly_storage.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xrandom.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xreducer.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xscalar.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xsemantic.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xshape.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xslice.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xsort.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xstorage.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xstrided_view.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xstrided_view_base.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xstrides.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xtensor.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xtensor_config.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xtensor_forward.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xtensor_simd.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xutils.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xvectorize.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xview.hpp
-    ${XTENSOR_INCLUDE_DIR}/xtensor/xview_utils.hpp
+    ${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 $<BUILD_INTERFACE:${XTENSOR_INCLUDE_DIR}>
-                                             $<INSTALL_INTERFACE:include>)
+
+target_include_directories(xtensor INTERFACE
+    $<BUILD_INTERFACE:${XTENSOR_INCLUDE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+    $<INSTALL_INTERFACE:include>)
+
+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_USE_XSIMD "simd acceleration for xtensor" OFF)
-OPTION(XTENSOR_USE_TBB "enable parallelization using intel TBB" 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_GTEST "build gtest from downloaded sources" OFF)
 OPTION(DOWNLOAD_GBENCHMARK "download google benchmark and build from source" ON)
 OPTION(DEFAULT_COLUMN_MAJOR "set default layout to column major" OFF)
-OPTION(DISABLE_VS2017 "disables the compilation of some test with Visual Studio 2017" 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(DOWNLOAD_GTEST OR GTEST_SRC_DIR)
-    set(BUILD_TESTS ON)
-endif()
 
 if(XTENSOR_ENABLE_ASSERT OR XTENSOR_CHECK_DIMENSION)
     add_definitions(-DXTENSOR_ENABLE_ASSERT)
@@ -130,31 +230,20 @@ if(XTENSOR_CHECK_DIMENSION)
     add_definitions(-DXTENSOR_ENABLE_CHECK_DIMENSION)
 endif()
 
-if(XTENSOR_USE_XSIMD)
-    add_definitions(-DXTENSOR_USE_XSIMD)
-    find_package(xsimd 7.0 REQUIRED)
-    message(STATUS "Found xsimd: ${xsimd_INCLUDE_DIRS}/xsimd")
-    target_link_libraries(xtensor INTERFACE xsimd)
-endif()
-
-if(XTENSOR_USE_TBB)
-    set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
-    add_definitions(-DXTENSOR_USE_TBB)
-    find_package(TBB REQUIRED)
-    message(STATUS "Found intel TBB: ${TBB_INCLUDE_DIRS}")
-    include_directories(${TBB_INCLUDE_DIRS})
-    target_link_libraries(xtensor INTERFACE ${TBB_LIBRARIES})
+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(DISABLE_VS2017)
-    add_definitions(-DDISABLE_VS2017)
+if(MSVC AND DISABLE_MSVC_ITERATOR_CHECK)
+    add_compile_definitions($<$<CONFIG:Debug>:_ITERATOR_DEBUG_LEVEL=0>)
 endif()
 
 if(BUILD_TESTS)
+    enable_testing()
     add_subdirectory(test)
 endif()
 
@@ -162,6 +251,11 @@ 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
 # ============
 
@@ -175,10 +269,10 @@ install(TARGETS xtensor
 export(EXPORT ${PROJECT_NAME}-targets
        FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake")
 
-install(FILES ${XTENSOR_HEADERS}
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/xtensor)
+install(DIRECTORY ${XTENSOR_INCLUDE_DIR}/xtensor
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
-set(XTENSOR_CMAKECONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" CACHE
+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
@@ -205,4 +299,47 @@ 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_LIBDIR}/pkgconfig/")
+        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
index 0e953348c..03d48a3bc 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,5 @@
-Copyright (c) 2016, Johan Mabille and Sylvain Corlay
+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
diff --git a/README.md b/README.md
index 33c01baf4..19c5f9fe1 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,13 @@
 # ![xtensor](docs/source/xtensor.svg)
 
-[![Travis](https://travis-ci.org/QuantStack/xtensor.svg?branch=master)](https://travis-ci.org/QuantStack/xtensor)
-[![Appveyor](https://ci.appveyor.com/api/projects/status/quf1hllkedr0rxbk?svg=true)](https://ci.appveyor.com/project/QuantStack/xtensor)
+[![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)
-[![Binder](https://img.shields.io/badge/launch-binder-brightgreen.svg)](https://mybinder.org/v2/gh/QuantStack/xtensor/stable?filepath=notebooks/xtensor.ipynb)
-[![Join the Gitter Chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/QuantStack/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![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)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/xtensor-stack/xtensor?utm_source=badge)
 
 Multi-dimensional arrays with broadcasting and lazy computing.
 
@@ -26,62 +29,89 @@ 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/QuantStack/xtensor-python),
-[xtensor-julia](https://github.com/QuantStack/Xtensor.jl) and
-[xtensor-r](https://github.com/QuantStack/xtensor-r) projects respectively.
+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.
 
-`xtensor` requires a modern C++ compiler supporting C++14. The following C++
-compilers are supported:
+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.
 
- - On Windows platforms, Visual C++ 2015 Update 2, or more recent
- - On Unix platforms, gcc 4.9 or a recent version of Clang
 
 ## Installation
 
-`xtensor` is a header-only library. We provide a package for the conda package
-manager.
+### Package managers
+
+We provide a package for the mamba (or conda) package manager:
 
 ```bash
-conda install -c conda-forge xtensor
+mamba install -c conda-forge xtensor
 ```
 
-Or you can directly install it from the sources:
+### 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
 
-To try out xtensor interactively in your web browser, just click on the binder
-link:
+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.
 
-[![Binder](docs/source/binder-logo.svg)](https://mybinder.org/v2/gh/QuantStack/xtensor/stable?filepath=notebooks/xtensor.ipynb)
+![xeus-cling](docs/source/xeus-cling-screenshot.png)
 
 ## Documentation
 
-To get started with using `xtensor`, check out the full 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/QuantStack/xtl) library and
-has an optional dependency on the [xsimd](https://github.com/QuantStack/xsimd)
+`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.4.16 |       ^7.0.0      |
-|  0.18.2   | ^0.4.16 |       ^7.0.0      |
-|  0.18.1   | ^0.4.16 |       ^7.0.0      |
-|  0.18.0   | ^0.4.16 |       ^7.0.0      |
-|  0.17.4   | ^0.4.16 |       ^6.1.4      |
-|  0.17.3   | ^0.4.15 |       ^6.1.4      |
-|  0.17.2   | ^0.4.15 |       ^6.1.4      |
-|  0.17.1   | ^0.4.14 |       ^6.1.4      |
-|  0.17.0   | ^0.4.13 |       ^6.1.4      |
+|  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`
@@ -277,9 +307,9 @@ Besides, two access operators are provided:
 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/QuantStack/xsimd)
+### [![xsimd](docs/source/xsimd-small.svg)](https://github.com/xtensor-stack/xsimd)
 
-The [xsimd](https://github.com/QuantStack/xsimd) project underlies the
+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.
 
@@ -307,9 +337,9 @@ performance of the application.
 
 ## Language bindings
 
-### [![xtensor-python](docs/source/xtensor-python-small.svg)](https://github.com/QuantStack/xtensor-python)
+### [![xtensor-python](docs/source/xtensor-python-small.svg)](https://github.com/xtensor-stack/xtensor-python)
 
-The [xtensor-python](https://github.com/QuantStack/xtensor-python) project
+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.
@@ -317,9 +347,9 @@ 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/QuantStack/xtensor-julia)
+### [![xtensor-julia](docs/source/xtensor-julia-small.svg)](https://github.com/xtensor-stack/xtensor-julia)
 
-The [xtensor-julia](https://github.com/QuantStack/xtensor-julia) project
+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.
@@ -327,9 +357,9 @@ 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/QuantStack/xtensor-r)
+### [![xtensor-r](docs/source/xtensor-r-small.svg)](https://github.com/xtensor-stack/xtensor-r)
 
-The [xtensor-r](https://github.com/QuantStack/xtensor-r) project provides the
+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.
 
@@ -338,17 +368,17 @@ universal functions are provided.
 
 ## Library bindings
 
-### [![xtensor-blas](docs/source/xtensor-blas-small.svg)](https://github.com/QuantStack/xtensor-blas)
+### [![xtensor-blas](docs/source/xtensor-blas-small.svg)](https://github.com/xtensor-stack/xtensor-blas)
 
-The [xtensor-blas](https://github.com/QuantStack/xtensor-blas) project provides
+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/QuantStack/xtensor-io)
+### [![xtensor-io](docs/source/xtensor-io-small.svg)](https://github.com/xtensor-stack/xtensor-io)
 
-The [xtensor-io](https://github.com/QuantStack/xtensor-io) project enables the
+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, as well as  NumPy npy and npz files.
+files, sound files, HDF5 files, as well as NumPy npy and npz files.
 
 ## Building and running the tests
 
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 9b19c750d..0d0ce5766 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -6,30 +6,46 @@
 # The full license is in the file LICENSE, distributed with this software. #
 ############################################################################
 
-cmake_minimum_required(VERSION 3.1)
+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_DIR})
+    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)
+if(CODSPEED_MODE AND NOT CODSPEED_MODE STREQUAL "off")
+    message(STATUS "CodSpeed mode enabled (${CODSPEED_MODE}) - using RelWithDebInfo build type")
+    set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
+else()
+    message(STATUS "Forcing tests build type to Release")
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+endif()
 
 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")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -O3 -g -Wunused-parameter -Wextra -Wreorder")
-    CHECK_CXX_COMPILER_FLAG("-std=c++14" HAS_CPP14_FLAG)
-
-    if (HAS_CPP14_FLAG)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
-    else()
-        message(FATAL_ERROR "Unsupported compiler -- xtensor requires C++14 support!")
+    # Skip -march=native for CodSpeed simulation mode (valgrind does not
+    # support all native instruction sets)
+    if(NOT (CODSPEED_MODE STREQUAL "simulation"))
+        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()
+    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
@@ -68,32 +84,19 @@ endif()
 
 
 if(DOWNLOAD_GBENCHMARK OR GBENCHMARK_SRC_DIR)
-    if(DOWNLOAD_GBENCHMARK)
-        # Download and unpack googlebenchmark at configure time
-        configure_file(downloadGBenchmark.cmake.in googlebenchmark-download/CMakeLists.txt)
-    else()
-        # Copy local source of googlebenchmark at configure time
-        configure_file(copyGBenchmark.cmake.in googlebenchmark-download/CMakeLists.txt)
-    endif()
-    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
-                    RESULT_VARIABLE result
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-download )
-    if(result)
-        message(FATAL_ERROR "CMake step for googlebenchmark failed: ${result}")
-    endif()
-    execute_process(COMMAND ${CMAKE_COMMAND} --build .
-                    RESULT_VARIABLE result
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-download )
-    if(result)
-        message(FATAL_ERROR "Build step for googlebenchmark failed: ${result}")
-    endif()
-
-    # Add googlebenchmark directly to our build. This defines
-    # the gtest and gtest_main targets.
-    add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-src
-                     ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build)
-
-    set(GBENCHMARK_INCLUDE_DIRS "${googlebenchmark_SOURCE_DIR}/include")
+    FetchContent_Declare(googletest
+            GIT_REPOSITORY https://github.com/google/googletest.git
+            GIT_TAG main)
+
+    FetchContent_Declare(googlebenchmark
+            GIT_REPOSITORY https://github.com/CodSpeedHQ/codspeed-cpp.git
+            GIT_TAG main
+            SOURCE_SUBDIR google_benchmark)
+
+    FetchContent_MakeAvailable(
+            googletest
+            googlebenchmark)
+    set(GBENCHMARK_INCLUDE_DIRS "${googlebenchmark_SOURCE_DIR}/google_benchmark/include")
     set(GBENCHMARK_LIBRARIES benchmark)
 else()
     find_package(benchmark REQUIRED)
@@ -123,12 +126,23 @@ set(XTENSOR_BENCHMARK
     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} xtensor ${GBENCHMARK_LIBRARIES})
+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
diff --git a/benchmark/benchmark_adapter.cpp b/benchmark/benchmark_adapter.cpp
index f80b2892c..3a76dcb7e 100644
--- a/benchmark/benchmark_adapter.cpp
+++ b/benchmark/benchmark_adapter.cpp
@@ -1,28 +1,28 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-// #include "xtensor/xshape.hpp"
-#include "xtensor/xstorage.hpp"
-#include "xtensor/xutils.hpp"
-#include "xtensor/xadapt.hpp"
-#include "xtensor/xnoalias.hpp"
+// #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 <class V>
     void shape_array_adapter(benchmark::State& state)
     {
-        const V a({1,2,3,4});
-        const V b({1,2,3,4});
+        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<value_type, 1> result(std::array<std::size_t, 1>({4}));
@@ -63,7 +63,7 @@ namespace xt
             auto ab = xt::adapt(b);
             auto ar = xt::adapt(res);
             auto fun = aa + ab;
-            std::copy(fun.storage_cbegin(), fun.storage_cend(), ar.storage_begin());
+            std::copy(fun.linear_cbegin(), fun.linear_cend(), ar.linear_begin());
             benchmark::DoNotOptimize(ar.data());
         }
     }
@@ -81,8 +81,15 @@ namespace xt
             auto ab = xt::adapt(b);
             auto ar = xt::adapt(res);
             auto fun = aa + ab;
-            std::transform(fun.storage_cbegin(), fun.storage_cend(), ar.storage_begin(),
-                           [](typename decltype(fun)::value_type x) { return static_cast<typename decltype(ar)::value_type>(x); });
+            std::transform(
+                fun.linear_cbegin(),
+                fun.linear_cend(),
+                ar.linear_begin(),
+                [](typename decltype(fun)::value_type x)
+                {
+                    return static_cast<typename decltype(ar)::value_type>(x);
+                }
+            );
             benchmark::DoNotOptimize(ar.data());
         }
     }
diff --git a/benchmark/benchmark_assign.cpp b/benchmark/benchmark_assign.cpp
index 3e4ac1ad0..b9efb341e 100644
--- a/benchmark/benchmark_assign.cpp
+++ b/benchmark/benchmark_assign.cpp
@@ -1,19 +1,19 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xnoalias.hpp"
 
 namespace xt
 {
@@ -39,24 +39,22 @@ namespace xt
         }
 
         template <class V>
-        inline void init_xtensor_benchmark(V& lhs, V& rhs, V& res,
-                                           std::size_t size0, size_t size1)
+        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 });
+            lhs.resize({size0, size1});
+            rhs.resize({size0, size1});
+            res.resize({size0, size1});
             init_benchmark_data(lhs, rhs, size0, size1);
         }
 
         template <class V>
-        inline void init_dl_xtensor_benchmark(V& lhs, V& rhs, V& res,
-                                              std::size_t size0, size_t size1)
+        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);
+            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);
         }
 
@@ -161,7 +159,7 @@ namespace xt
             for (auto _ : state)
             {
                 auto fun = 3.0 * x - 2.0 * y;
-                std::copy(fun.storage_cbegin(), fun.storage_cend(), res.storage_begin());
+                std::copy(fun.linear_cbegin(), fun.linear_cend(), res.linear_begin());
                 benchmark::DoNotOptimize(res.data());
             }
         }
@@ -210,20 +208,19 @@ namespace xt
             }
         }
 
-
-        BENCHMARK_TEMPLATE(assign_c_assign, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_x_assign, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_xiter_copy, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_xstorageiter_copy, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_c_assign_ii, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_x_assign_ii, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_x_assign_iii, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_c_assign_iii, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_x_assign, xt::xarray<double>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_x_assign, xt::xarray<double, layout_type::dynamic>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_x_assign, xt::xtensor<double, 2, layout_type::dynamic>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_c_scalar_computed, xt::xtensor<double, 2>)->Range(32, 32<<3);
-        BENCHMARK_TEMPLATE(assign_x_scalar_computed, xt::xtensor<double, 2>)->Range(32, 32<<3);
+        BENCHMARK_TEMPLATE(assign_c_assign, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_x_assign, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_xiter_copy, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_xstorageiter_copy, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_c_assign_ii, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_x_assign_ii, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_x_assign_iii, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_c_assign_iii, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_x_assign, xt::xarray<double>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_x_assign, xt::xarray<double, layout_type::dynamic>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_x_assign, xt::xtensor<double, 2, layout_type::dynamic>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_c_scalar_computed, xt::xtensor<double, 2>)->Range(32, 32 << 3);
+        BENCHMARK_TEMPLATE(assign_x_scalar_computed, xt::xtensor<double, 2>)->Range(32, 32 << 3);
     }
 }
 
diff --git a/benchmark/benchmark_builder.cpp b/benchmark/benchmark_builder.cpp
index 021f09dfb..e25de39cb 100644
--- a/benchmark/benchmark_builder.cpp
+++ b/benchmark/benchmark_builder.cpp
@@ -1,16 +1,16 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xnoalias.hpp"
 
 namespace xt
 {
@@ -42,18 +42,18 @@ namespace xt
     {
         for (auto _ : state)
         {
-            xt::uvector<double> a {};
+            xt::uvector<double> a{};
             a.resize(10000);
             std::iota(a.begin(), a.end(), 0);
             benchmark::DoNotOptimize(a.data());
         }
     }
-    
+
     template <class T>
     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)
@@ -91,7 +91,7 @@ namespace xt
             auto xend = expr.cend();
             auto reit = res.begin();
             auto it = expr.cbegin();
-            for(ptrdiff_t n = 10000; n > 0; --n)
+            for (ptrdiff_t n = 10000; n > 0; --n)
             {
                 *reit = *it;
                 ++it;
@@ -127,13 +127,12 @@ namespace xt
     inline auto builder_ones(benchmark::State& state)
     {
         for (auto _ : state)
-        { 
+        {
             xt::xarray<double> res = xt::ones<double>({200, 200});
             benchmark::DoNotOptimize(res.data());
         }
     }
 
-
     inline auto builder_ones_assign_iterator(benchmark::State& state)
     {
         auto xo = xt::ones<double>({200, 200});
@@ -155,8 +154,12 @@ namespace xt
             xt::xtensor<double, 2> res(xt::static_shape<size_t, 2>({200, 200}));
             auto xo = xt::ones<double>({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());
         }
     }
diff --git a/benchmark/benchmark_container.cpp b/benchmark/benchmark_container.cpp
index eafdfe5cf..af51d1d19 100644
--- a/benchmark/benchmark_container.cpp
+++ b/benchmark/benchmark_container.cpp
@@ -1,19 +1,19 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <cstddef>
 #include <chrono>
+#include <cstddef>
 #include <string>
 
 #include <benchmark/benchmark.h>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
 
 namespace xt
 {
@@ -25,9 +25,9 @@ namespace xt
         template <class E>
         inline void init_benchmark(E& x, E& y, E& res, typename E::size_type size)
         {
-            x.resize({ size });
-            y.resize({ size });
-            res.resize({ size });
+            x.resize({size});
+            y.resize({size});
+            res.resize({size});
 
             using value_type = typename E::value_type;
             using size_type = typename E::size_type;
diff --git a/benchmark/benchmark_creation.cpp b/benchmark/benchmark_creation.cpp
index 12c423216..4410d2325 100644
--- a/benchmark/benchmark_creation.cpp
+++ b/benchmark/benchmark_creation.cpp
@@ -1,17 +1,17 @@
 /****************************************************************************
  * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xfixed.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/generators/xbuilder.hpp"
 
 namespace xt
 {
@@ -64,4 +64,4 @@ namespace xt
     BENCHMARK_TEMPLATE(benchmark_from_shape, xtensor<double, 2>);
     BENCHMARK_TEMPLATE(benchmark_creation, xarray<double>);
     BENCHMARK_TEMPLATE(benchmark_creation, xtensor<double, 2>);
-}
\ No newline at end of file
+}
diff --git a/benchmark/benchmark_increment_stepper.cpp b/benchmark/benchmark_increment_stepper.cpp
index 699aac211..1557692e2 100644
--- a/benchmark/benchmark_increment_stepper.cpp
+++ b/benchmark/benchmark_increment_stepper.cpp
@@ -1,15 +1,15 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xrandom.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/generators/xrandom.hpp"
 
 #define SHAPE 30, 30
 #define RANGE 3, 100
@@ -42,6 +42,7 @@ namespace xt
                 benchmark::DoNotOptimize(c);
             }
         }
+
         BENCHMARK(stepper_stepper)->Range(RANGE);
 
         void stepper_stepper_ref(benchmark::State& state)
@@ -65,6 +66,7 @@ namespace xt
                 benchmark::DoNotOptimize(c);
             }
         }
+
         BENCHMARK(stepper_stepper_ref)->Range(RANGE);
     }
 }
diff --git a/benchmark/benchmark_lambda_expressions.cpp b/benchmark/benchmark_lambda_expressions.cpp
index abe454b8d..6c6c40a49 100644
--- a/benchmark/benchmark_lambda_expressions.cpp
+++ b/benchmark/benchmark_lambda_expressions.cpp
@@ -1,18 +1,18 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xmath.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
+#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
 {
@@ -66,9 +66,9 @@ namespace xt
         }
     }
 
-    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);
-}
\ No newline at end of file
+    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
index cd888af84..c365551ea 100644
--- a/benchmark/benchmark_math.cpp
+++ b/benchmark/benchmark_math.cpp
@@ -1,10 +1,10 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <chrono>
 #include <cstddef>
@@ -13,9 +13,9 @@
 
 #include <benchmark/benchmark.h>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xtensor.hpp"
+#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
@@ -47,9 +47,9 @@ namespace xt
         template <class V>
         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 });
+            lhs.resize({size0, size1});
+            rhs.resize({size0, size1});
+            res.resize({size0, size1});
             init_benchmark_data(lhs, rhs, size0, size1);
         }
 
@@ -92,7 +92,7 @@ namespace xt
             for (auto _ : state)
             {
                 auto fct = f(lhs, rhs);
-                std::copy(fct.storage_begin(), fct.storage_end(), res.storage_begin());
+                std::copy(fct.linear_begin(), fct.linear_end(), res.linear_begin());
                 benchmark::DoNotOptimize(res.data());
             }
         }
@@ -152,31 +152,56 @@ namespace xt
          * Benchmark functors *
          **********************/
 
-#define DEFINE_OP_FUNCTOR_2OP(OP, NAME)\
-    struct NAME##_fn {\
-        template <class T>\
-        inline auto operator()(const T& lhs, const T& rhs) const { return lhs OP rhs; }\
-        inline static std::string name() { return #NAME; }\
+#define DEFINE_OP_FUNCTOR_2OP(OP, NAME)                          \
+    struct NAME##_fn                                             \
+    {                                                            \
+        template <class T>                                       \
+        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 <class T>\
-        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_1OP(FN)                   \
+    struct FN##_fn                               \
+    {                                            \
+        template <class T>                       \
+        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 <class T>\
-        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 DEFINE_FUNCTOR_2OP(FN)                                   \
+    struct FN##_fn                                               \
+    {                                                            \
+        template <class T>                                       \
+        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_OP_FUNCTOR_2OP(/, div);
 
         DEFINE_FUNCTOR_1OP(exp);
         DEFINE_FUNCTOR_1OP(exp2);
@@ -334,7 +359,8 @@ namespace xt
 
         a.resize({sz, sz});
         b.resize({sz, sz});
-        xtensor<bool, 2> res; res.resize({sz, sz});
+        xtensor<bool, 2> res;
+        res.resize({sz, sz});
 
         for (auto _ : state)
         {
@@ -351,7 +377,8 @@ namespace xt
 
         a.resize({sz, sz});
         b.resize({sz, sz});
-        xtensor<bool, 2> res; res.resize({sz, sz});
+        xtensor<bool, 2> res;
+        res.resize({sz, sz});
 
         for (auto _ : state)
         {
diff --git a/benchmark/benchmark_random.cpp b/benchmark/benchmark_random.cpp
index 93c0e17b3..e5279988d 100644
--- a/benchmark/benchmark_random.cpp
+++ b/benchmark/benchmark_random.cpp
@@ -1,25 +1,25 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xrandom.hpp"
+#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)
diff --git a/benchmark/benchmark_reducer.cpp b/benchmark/benchmark_reducer.cpp
index 9017bc327..c4304782f 100644
--- a/benchmark/benchmark_reducer.cpp
+++ b/benchmark/benchmark_reducer.cpp
@@ -1,15 +1,15 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xreducer.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/reducers/xreducer.hpp"
 
 namespace xt
 {
@@ -30,33 +30,33 @@ namespace xt
         {
             for (auto _ : state)
             {
-                res = sum(x, axes, evaluation_strategy::immediate());
+                res = sum(x, axes, evaluation_strategy::immediate);
                 benchmark::DoNotOptimize(res.data());
             }
         }
 
-        xarray<double> u = ones<double>({ 10, 100000 });
-        xarray<double> v = ones<double>({ 100000, 10 });
-        xarray<double> res2 = ones<double>({ 1 });
+        xarray<double> u = ones<double>({10, 100000});
+        xarray<double> v = ones<double>({100000, 10});
+        xarray<double> res2 = ones<double>({1});
 
-        std::vector<std::size_t> axis0 = { 0 };
-        std::vector<std::size_t> axis1 = { 1 };
-        std::vector<std::size_t> axis_both = { 0, 1 };
+        std::vector<std::size_t> axis0 = {0};
+        std::vector<std::size_t> axis1 = {1};
+        std::vector<std::size_t> axis_both = {0, 1};
 
-        static auto res0 = xarray<double>::from_shape({ 100000 });
-        static auto res1 = xarray<double>::from_shape({ 10 });
+        static auto res0 = xarray<double>::from_shape({100000});
+        static auto res1 = xarray<double>::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_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);
+        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 <class E, class X>
         inline auto reducer_manual_strided_reducer(benchmark::State& state, const E& x, E& res, const X& axes)
@@ -92,9 +92,9 @@ namespace xt
             }
         }
 
-        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);
+        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
new file mode 100644
index 000000000..9ae160712
--- /dev/null
+++ b/benchmark/benchmark_stl.cpp
@@ -0,0 +1,157 @@
+/***************************************************************************
+ * 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 <benchmark/benchmark.h>
+
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+
+namespace xt
+{
+    namespace
+    {
+        constexpr std::array<size_t, 2> cContainerAssignShape{2000, 2000};
+
+        template <class Shape>
+        auto generateRandomInt16From0To100(Shape&& x)
+        {
+            return xt::random::randint(x, 0, 100);
+        }
+    }
+
+    static void Xtensor_Uint16_2000x2000_DivideBy2_StdTransform(benchmark::State& aState)
+    {
+        xt::xtensor<uint16_t, 2> vInput = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::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<uint16_t, 2> vInput = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::from_shape(cContainerAssignShape);
+
+        for (auto _ : aState)
+        {
+            vOutput = vInput / 2;
+        }
+    }
+
+    static void Xtensor_Uint16_2000x2000_DivideBy2Double_StdTransform(benchmark::State& aState)
+    {
+        xt::xtensor<uint16_t, 2> vInput = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::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<uint16_t, 2> vInput = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::from_shape(cContainerAssignShape);
+
+        for (auto _ : aState)
+        {
+            vOutput = vInput / 2.0;
+        }
+    }
+
+    static void Xtensor_Uint16_2000x2000_MultiplyBy2_StdTransform(benchmark::State& aState)
+    {
+        xt::xtensor<uint16_t, 2> vInput = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::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<uint16_t, 2> vInput = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::from_shape(cContainerAssignShape);
+
+        for (auto _ : aState)
+        {
+            vOutput = vInput * 2;
+        }
+    }
+
+    static void Xtensor_Uint16_2000x2000_Maximum_StdTransform(benchmark::State& aState)
+    {
+        xt::xtensor<uint16_t, 2> vInput1 = generateRandomInt16From0To100(cContainerAssignShape);
+        xt::xtensor<uint16_t, 2> vInput2 = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::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<uint16_t, 2> vInput1 = generateRandomInt16From0To100(cContainerAssignShape);
+        xt::xtensor<uint16_t, 2> vInput2 = generateRandomInt16From0To100(cContainerAssignShape);
+        auto vOutput = xt::xtensor<uint16_t, 2>::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
index 59b60296d..78569955e 100644
--- a/benchmark/benchmark_view_access.cpp
+++ b/benchmark/benchmark_view_access.cpp
@@ -8,14 +8,14 @@
 
 #include <benchmark/benchmark.h>
 
-// #include "xtensor/xshape.hpp"
-#include "xtensor/xadapt.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xstorage.hpp"
-#include "xtensor/xutils.hpp"
-#include "xtensor/xview.hpp"
+// #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
 {
@@ -23,10 +23,12 @@ namespace xt
     class simple_array
     {
     public:
+
         using self_type = simple_array<T, N>;
         using shape_type = std::array<ptrdiff_t, N>;
 
         simple_array() = default;
+
         explicit simple_array(const std::array<ptrdiff_t, N>& shape)
             : m_shape(shape)
         {
@@ -66,11 +68,13 @@ namespace xt
             }
             return memory[offset];
         }
+
         xt::uvector<T> memory;
         std::array<ptrdiff_t, N> m_shape, m_strides;
     };
 
-    void xview_access_calc(benchmark::State &state) {
+    void xview_access_calc(benchmark::State& state)
+    {
         xt::xtensor<double, 4> A = xt::random::rand<double>({100, 100, 4, 4});
         xt::xtensor<double, 3> elemvec = xt::random::rand<double>({100, 4, 4});
         xt::xtensor<double, 2> eps = xt::empty<double>({2, 2});
@@ -87,15 +91,14 @@ namespace xt
                     // - 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(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());
                 }
@@ -103,7 +106,8 @@ namespace xt
         }
     }
 
-    void raw_access_calc(benchmark::State &state) {
+    void raw_access_calc(benchmark::State& state)
+    {
         xt::xtensor<double, 4> A = xt::random::rand<double>({100, 100, 4, 4});
         xt::xtensor<double, 3> elemvec = xt::random::rand<double>({100, 4, 4});
         xt::xtensor<double, 2> eps = xt::empty<double>({2, 2});
@@ -117,15 +121,15 @@ namespace xt
                     // - 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(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());
                 }
@@ -133,7 +137,8 @@ namespace xt
         }
     }
 
-    void unchecked_access_calc(benchmark::State &state) {
+    void unchecked_access_calc(benchmark::State& state)
+    {
         xt::xtensor<double, 4> A = xt::random::rand<double>({100, 100, 4, 4});
         xt::xtensor<double, 3> elemvec = xt::random::rand<double>({100, 4, 4});
         xt::xtensor<double, 2> eps = xt::empty<double>({2, 2});
@@ -147,26 +152,23 @@ namespace xt
                     // - 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(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());
                 }
@@ -174,7 +176,8 @@ namespace xt
         }
     }
 
-    void simplearray_access_calc(benchmark::State &state) {
+    void simplearray_access_calc(benchmark::State& state)
+    {
         simple_array<double, 4> A(std::array<ptrdiff_t, 4>{100, 100, 4, 2});
         simple_array<double, 3> elemvec(std::array<ptrdiff_t, 3>{100, 4, 2});
         simple_array<double, 2> eps(std::array<ptrdiff_t, 2>{2, 2});
@@ -188,23 +191,15 @@ namespace xt
                     // - 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(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);
                 }
@@ -212,9 +207,9 @@ namespace xt
         }
     }
 
-    #define M_NELEM 3600
-    #define M_NNE 4
-    #define M_NDIM 2
+#define M_NELEM 3600
+#define M_NNE 4
+#define M_NDIM 2
 
     template <class X, layout_type L>
     class jumping_random
@@ -224,8 +219,8 @@ namespace xt
         using shape_type = typename X::shape_type;
 
         jumping_random()
-            : m_dofs(shape_type{3721, 2}),
-              m_conn(shape_type{3600, 4})
+            : 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);
 
@@ -241,28 +236,47 @@ namespace xt
         auto calc_dofval(xt::xtensor<double, 3, L>& elemvec, xt::xtensor<double, 1, L>& 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)
+            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<double, 3>& elemvec, simple_array<double, 1>& 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)
+            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<double, 3, L>& elemvec, xt::xtensor<double, 1, L>& 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.unchecked(m_dofs.unchecked(m_conn.unchecked(e, m), i)) += elemvec.unchecked(e, m, i);
+            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;
@@ -317,4 +331,4 @@ namespace xt
     BENCHMARK_TEMPLATE(jumping_access_unchecked, layout_type::row_major);
     BENCHMARK_TEMPLATE(jumping_access_unchecked, layout_type::column_major);
     BENCHMARK(jumping_access_simplearray);
-}
\ No newline at end of file
+}
diff --git a/benchmark/benchmark_view_adapt.cpp b/benchmark/benchmark_view_adapt.cpp
index 06f25a80a..2523cb725 100644
--- a/benchmark/benchmark_view_adapt.cpp
+++ b/benchmark/benchmark_view_adapt.cpp
@@ -1,44 +1,44 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xview.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xadapt.hpp"
+#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<double, xt::xshape<2,2>>;
+        using T2 = xt::xtensor_fixed<double, xt::xshape<2, 2>>;
 
-        T2 foo(const T2 &A)
+        T2 foo(const T2& A)
         {
             return 2. * A;
         }
 
         void random_view(benchmark::State& state)
         {
-            xt::xtensor<double,4> A = xt::random::randn<double>({2000,8,2,2});
-            xt::xtensor<double,4> B = xt::empty<double>(A.shape());
+            xt::xtensor<double, 4> A = xt::random::randn<double>({2000, 8, 2, 2});
+            xt::xtensor<double, 4> B = xt::empty<double>(A.shape());
 
             for (auto _ : state)
             {
-                for ( size_t i = 0 ; i < A.shape()[0] ; ++i )
+                for (size_t i = 0; i < A.shape()[0]; ++i)
                 {
-                    for ( size_t j = 0 ; j < A.shape()[1] ; ++j )
+                    for (size_t j = 0; j < A.shape()[1]; ++j)
                     {
                         auto a = xt::view(A, i, j);
                         auto b = xt::view(B, i, j);
@@ -52,17 +52,17 @@ namespace xt
 
         void random_adapt(benchmark::State& state)
         {
-            xt::xtensor<double,4> A = xt::random::randn<double>({2000,8,2,2});
-            xt::xtensor<double,4> B = xt::empty<double>(A.shape());
+            xt::xtensor<double, 4> A = xt::random::randn<double>({2000, 8, 2, 2});
+            xt::xtensor<double, 4> B = xt::empty<double>(A.shape());
 
             for (auto _ : state)
             {
-                for ( size_t i = 0 ; i < A.shape()[0] ; ++i )
+                for (size_t i = 0; i < A.shape()[0]; ++i)
                 {
-                    for ( size_t j = 0 ; j < A.shape()[1] ; ++j )
+                    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>());
+                        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);
                     }
diff --git a/benchmark/benchmark_view_assignment.cpp b/benchmark/benchmark_view_assignment.cpp
index 20a502109..3d5ae314b 100644
--- a/benchmark/benchmark_view_assignment.cpp
+++ b/benchmark/benchmark_view_assignment.cpp
@@ -1,18 +1,18 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <benchmark/benchmark.h>
 
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xrandom.hpp"
+#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
 {
@@ -61,23 +61,24 @@ namespace xt
         }
     }
 
-    inline void assign_create_strided_view(benchmark::State& state)
-    {
-        xt::xtensor<double, 4> tens = xt::random::rand<double>({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<double, 2> vas = v;
-                    benchmark::ClobberMemory();
-                }
-            }
-        }
-    }
-
+    /**
+     *     inline void assign_create_strided_view(benchmark::State& state)
+     *     {
+     *         xt::xtensor<double, 4> tens = xt::random::rand<double>({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<double, 2> vas = v;
+     *                     benchmark::ClobberMemory();
+     *                 }
+     *             }
+     *         }
+     *     }
+     */
     inline void assign_create_manual_view(benchmark::State& state)
     {
         xt::xtensor<double, 4> tens = xt::random::rand<double>({100, 100, 3, 3});
@@ -151,9 +152,9 @@ namespace xt
     BENCHMARK(create_strided_view_outofplace);
     BENCHMARK(create_strided_view_inplace);
     BENCHMARK(assign_create_manual_noview);
-    BENCHMARK(assign_create_strided_view);
+    //    BENCHMARK(assign_create_strided_view);
     BENCHMARK(assign_create_view);
     BENCHMARK(assign_create_manual_view);
-    BENCHMARK(data_offset);
+    // BENCHMARK(data_offset);
     BENCHMARK(data_offset_view);
-}
\ No newline at end of file
+}
diff --git a/benchmark/benchmark_views.cpp b/benchmark/benchmark_views.cpp
index 5e8a45cad..f2c34d510 100644
--- a/benchmark/benchmark_views.cpp
+++ b/benchmark/benchmark_views.cpp
@@ -1,29 +1,29 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <cstddef>
 #include <chrono>
+#include <cstddef>
 #include <string>
 
 #include <benchmark/benchmark.h>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xstrided_view.hpp"
-#include "xtensor/xmanipulation.hpp"
-#include "xtensor/xstrides.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xview.hpp"
+#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/QuantStack/xtensor/issues/695
+    // https://github.com/xtensor-stack/xtensor/issues/695
     namespace view_benchmarks
     {
         constexpr int SIZE = 1000;
@@ -31,10 +31,10 @@ namespace xt
         template <class V>
         void view_dynamic_iterator(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE/2});
+            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());
@@ -45,10 +45,10 @@ namespace xt
         template <class V>
         void view_iterator(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::view(data, xt::all(), SIZE/2);
+            auto v = xt::view(data, xt::all(), SIZE / 2);
             for (auto _ : state)
             {
                 std::copy(v.begin(), v.end(), res.begin());
@@ -59,13 +59,13 @@ namespace xt
         template <class V>
         void view_loop(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE/2});
+            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)
+                for (std::size_t k = 0; k < v.shape()[0]; ++k)
                 {
                     res(k) = v(k);
                 }
@@ -76,13 +76,13 @@ namespace xt
         template <class V>
         void view_loop_view(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
             auto v = xt::view(data, xt::all(), SIZE / 2);
             for (auto _ : state)
             {
-                for(std::size_t k = 0; k < v.shape()[0]; ++k)
+                for (std::size_t k = 0; k < v.shape()[0]; ++k)
                 {
                     res(k) = v(k);
                 }
@@ -93,13 +93,13 @@ namespace xt
         template <class V>
         void view_loop_raw(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
             for (auto _ : state)
             {
                 std::size_t j = SIZE / 2;
-                for(std::size_t k = 0; k < SIZE; ++k)
+                for (std::size_t k = 0; k < SIZE; ++k)
                 {
                     res(k) = data(k, j);
                 }
@@ -110,10 +110,10 @@ namespace xt
         template <class V>
         void view_assign(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE/2});
+            auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE / 2});
             for (auto _ : state)
             {
                 xt::noalias(res) = v;
@@ -124,10 +124,10 @@ namespace xt
         template <class V>
         void view_assign_view(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::view(data, xt::all(), SIZE/2);
+            auto v = xt::view(data, xt::all(), SIZE / 2);
             auto r = xt::view(res, xt::all());
             for (auto _ : state)
             {
@@ -139,10 +139,10 @@ namespace xt
         template <class V>
         void view_assign_strided_view(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE/2});
+            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)
@@ -155,10 +155,10 @@ namespace xt
         template <class V>
         void view_assign_view_noalias(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::view(data, xt::all(), SIZE/2);
+            auto v = xt::view(data, xt::all(), SIZE / 2);
             auto r = xt::view(res, xt::all());
             for (auto _ : state)
             {
@@ -170,10 +170,10 @@ namespace xt
         template <class V>
         void view_assign_strided_view_noalias(benchmark::State& state)
         {
-            xt::xtensor<V, 2> data = xt::ones<V>({SIZE,SIZE});
+            xt::xtensor<V, 2> data = xt::ones<V>({SIZE, SIZE});
             xt::xtensor<V, 1> res = xt::ones<V>({SIZE});
 
-            auto v = xt::strided_view(data, xt::xstrided_slice_vector{xt::all(), SIZE/2});
+            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)
@@ -195,6 +195,75 @@ namespace xt
         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<size_t, 3> shape = {size, size, size};
+                xt::xtensor<double, 3> 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<size_t, 3> shape = {size, size, size};
+                xt::xtensor<double, 3> 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<size_t, 3> shape = {size, size, size};
+                xt::xtensor<double, 3> 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
     {
diff --git a/benchmark/benchmark_xshape.cpp b/benchmark/benchmark_xshape.cpp
index 237140ba9..6656b912f 100644
--- a/benchmark/benchmark_xshape.cpp
+++ b/benchmark/benchmark_xshape.cpp
@@ -1,10 +1,10 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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
@@ -12,9 +12,8 @@
 
 #include <benchmark/benchmark.h>
 
-#include "xtensor/xshape.hpp"
-#include "xtensor/xstorage.hpp"
-
+#include "xtensor/containers/xstorage.hpp"
+#include "xtensor/core/xshape.hpp"
 
 namespace xt
 {
@@ -43,7 +42,7 @@ namespace xt
         template <class T>
         void xshape_access(benchmark::State& state)
         {
-            T a({3,2,1,3});
+            T a({3, 2, 1, 3});
             for (auto _ : state)
             {
                 a[0] = a[1] * a[2] + a[3];
@@ -67,4 +66,4 @@ namespace xt
     }
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/benchmark/copyGBenchmark.cmake.in b/benchmark/copyGBenchmark.cmake.in
index d753bd155..e11eaed96 100644
--- a/benchmark/copyGBenchmark.cmake.in
+++ b/benchmark/copyGBenchmark.cmake.in
@@ -6,7 +6,7 @@
 # The full license is in the file LICENSE, distributed with this software. #
 ############################################################################
 
-cmake_minimum_required(VERSION 2.8.2)
+cmake_minimum_required(VERSION 3.5)
 
 project(googlebenchmark-download NONE)
 
@@ -19,4 +19,4 @@ ExternalProject_Add(benchmark
     BUILD_COMMAND     ""
     INSTALL_COMMAND   ""
     TEST_COMMAND      ""
-)
\ No newline at end of file
+)
diff --git a/benchmark/downloadGBenchmark.cmake.in b/benchmark/downloadGBenchmark.cmake.in
index f6b7b6999..7af348b1e 100644
--- a/benchmark/downloadGBenchmark.cmake.in
+++ b/benchmark/downloadGBenchmark.cmake.in
@@ -6,18 +6,19 @@
 # The full license is in the file LICENSE, distributed with this software. #
 ############################################################################
 
-cmake_minimum_required(VERSION 2.8.2)
+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.3.0
+    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      ""
-)
\ No newline at end of file
+)
diff --git a/benchmark/main.cpp b/benchmark/main.cpp
index 1b184e127..39491c225 100644
--- a/benchmark/main.cpp
+++ b/benchmark/main.cpp
@@ -1,17 +1,17 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 <iostream>
 
 #include <benchmark/benchmark.h>
 
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
 
 #ifdef XTENSOR_USE_XSIMD
 #ifdef __GNUC__
@@ -42,6 +42,9 @@ int main(int argc, char** argv)
 {
     print_stats();
     benchmark::Initialize(&argc, argv);
-    if (benchmark::ReportUnrecognizedArguments(argc, argv)) return 1;
+    if (benchmark::ReportUnrecognizedArguments(argc, argv))
+    {
+        return 1;
+    }
     benchmark::RunSpecifiedBenchmarks();
 }
diff --git a/cmake/FindTBB.cmake b/cmake/FindTBB.cmake
index f4b6b333b..0fafa84f7 100644
--- a/cmake/FindTBB.cmake
+++ b/cmake/FindTBB.cmake
@@ -184,7 +184,12 @@ if(NOT TBB_FOUND)
   ##################################
 
   if(TBB_INCLUDE_DIRS)
-    file(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _tbb_version_file)
+    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"
@@ -300,4 +305,4 @@ if(NOT TBB_FOUND)
   unset(TBB_LIB_PATH_SUFFIX)
   unset(TBB_DEFAULT_SEARCH_DIR)
 
-endif()
\ No newline at end of file
+endif()
diff --git a/cmake/sanitizers.cmake b/cmake/sanitizers.cmake
new file mode 100644
index 000000000..11c7a1075
--- /dev/null
+++ b/cmake/sanitizers.cmake
@@ -0,0 +1,50 @@
+set(AVALAIBLE_SANITIZERS "address;leak;memory;thread;undefined")
+OPTION(USE_SANITIZER "Enable sanitizer(s). Options are: ${AVALAIBLE_SANITIZERS}. Case insensitive; multiple options delimited by comma or space possible." "")
+string(TOLOWER "${USE_SANITIZER}" USE_SANITIZER)
+
+if((CMAKE_BUILD_TYPE IN_LIST "Debug;RelWithDebInfo") AND USE_SANITIZER)
+    message(FATAL_ERROR "❌ Sanitizer only supported in Debug and RelWithDebInfo build types.")
+endif()
+
+if(USE_SANITIZER)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+        set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
+
+        if(USE_SANITIZER MATCHES "address")
+            list(APPEND SANITIZER_COMPILE_OPTIONS /fsanitize=address /D_DISABLE_VECTOR_ANNOTATION /D_DISABLE_STRING_ANNOTATION)
+        else()
+            message(FATAL_ERROR "❌ Sanitizer not supported by MSVC: ${USE_SANITIZER}. It only supports 'address'.")
+        endif()
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
+        if(USE_SANITIZER MATCHES "address")
+            list(APPEND SANITIZER_COMPILE_OPTIONS /fsanitize=address /D_DISABLE_VECTOR_ANNOTATION /D_DISABLE_STRING_ANNOTATION)
+            list(APPEND SANITIZER_LINK_LIBRARIES clang_rt.asan_dynamic-x86_64 clang_rt.asan_dynamic_runtime_thunk-x86_64)
+        else()
+            message(FATAL_ERROR "❌ Sanitizer not supported by Clang-MSVC: ${USE_SANITIZER}. It only supports 'address'.")
+        endif()
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        foreach(sanitizer ${USE_SANITIZER})
+            if(NOT ${sanitizer} IN_LIST AVALAIBLE_SANITIZERS)
+                message(FATAL_ERROR "❌ Sanitizer not supported: ${sanitizer}. It should be one of: ${AVALAIBLE_SANITIZERS}.")
+            endif()
+            list(APPEND SANITIZER_COMPILE_OPTIONS -fsanitize=${sanitizer})
+            list(APPEND SANITIZER_LINK_OPTIONS -fsanitize=${sanitizer})
+            if (${sanitizer} MATCHES "undefined")
+                list(APPEND SANITIZER_COMPILE_OPTIONS -fno-sanitize=signed-integer-overflow)
+            endif()
+            if (${sanitizer} MATCHES "memory")
+                list(APPEND SANITIZER_LINK_LIBRARIES -fsanitize-memory-track-origins -fPIE -pie)
+                list(APPEND SANITIZER_LINK_OPTIONS -fsanitize-memory-track-origins -fPIE -pie)
+            endif()
+        endforeach()
+        list(APPEND SANITIZER_COMPILE_OPTIONS -fno-omit-frame-pointer)
+    else()
+        message(FATAL_ERROR "❌ Sanitizer: Unsupported compiler: ${CMAKE_CXX_COMPILER_ID}")
+    endif()
+
+    list(REMOVE_DUPLICATES SANITIZER_COMPILE_OPTIONS)
+    list(REMOVE_DUPLICATES SANITIZER_LINK_OPTIONS)
+    list(REMOVE_DUPLICATES SANITIZER_LINK_LIBRARIES)
+
+    message(STATUS "🔍 Using sanitizer: ${USE_SANITIZER}")
+endif()
diff --git a/docs/Doxyfile b/docs/Doxyfile
index 409ba8752..d0b8d6e08 100644
--- a/docs/Doxyfile
+++ b/docs/Doxyfile
@@ -1,14 +1,23 @@
-PROJECT_NAME      = "xtensor"
-XML_OUTPUT        = xml
-INPUT             = ../include
-GENERATE_LATEX    = NO
-GENERATE_MAN      = NO
-GENERATE_RTF      = NO
-CASE_SENSE_NAMES  = NO
-GENERATE_HTML     = NO
-GENERATE_XML      = YES
-RECURSIVE         = YES
-QUIET             = YES
+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/ghp_environment.yml b/docs/ghp_environment.yml
new file mode 100644
index 000000000..9584ae39d
--- /dev/null
+++ b/docs/ghp_environment.yml
@@ -0,0 +1,4 @@
+channels:
+- conda-forge
+dependencies:
+- doxygen
diff --git a/docs/make.bat b/docs/make.bat
index 0df92b465..07de3322c 100644
--- a/docs/make.bat
+++ b/docs/make.bat
@@ -3,48 +3,48 @@
 REM Command file for Sphinx documentation
 
 if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
+    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%
+    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 ^<target^>` where ^<target^> 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
+    :help
+    echo.Please use `make ^<target^>` where ^<target^> 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
+    for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
+    del /q /s %BUILDDIR%\*
+    goto end
 )
 
 
@@ -58,15 +58,15 @@ goto sphinx_ok
 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
+    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
@@ -74,191 +74,191 @@ if errorlevel 9009 (
 
 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
+    %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
+    %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
+    %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
+    %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
+    %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 ^
+    %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
+    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 ^
+    %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
+    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
+    %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
+    %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
+    %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
+    %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
+    %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
+    %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
+    %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
+    %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
+    %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
+    %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 ^
+    %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
+    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 ^
+    %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
+    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 ^
+    %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
+    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
+    %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
+    %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/environment.yml b/docs/rtd_environment.yml
similarity index 51%
rename from docs/environment.yml
rename to docs/rtd_environment.yml
index 3b9b55633..54fb700ca 100644
--- a/docs/environment.yml
+++ b/docs/rtd_environment.yml
@@ -1,7 +1,8 @@
 name: xtensor-docs
 
 channels:
-  - conda-forge
+- conda-forge
 
 dependencies:
-  - breathe
+- breathe
+- sphinx_rtd_theme
diff --git a/docs/source/_static/goatcounter.js b/docs/source/_static/goatcounter.js
new file mode 100644
index 000000000..a26dd2a26
--- /dev/null
+++ b/docs/source/_static/goatcounter.js
@@ -0,0 +1,9 @@
+(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/adaptor.rst b/docs/source/adaptor.rst
index b5e5d4ba1..64fd7caf3 100644
--- a/docs/source/adaptor.rst
+++ b/docs/source/adaptor.rst
@@ -7,21 +7,21 @@
 Adapting 1-D containers
 =======================
 
-`xtensor` can adapt one-dimensional containers in place, and provide them a tensor interface.
+*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`:
+*xtensor*:
 
 .. code::
 
     #include <cstddef>
     #include <vector>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xadapt.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/containers/xadapt.hpp>
 
     std::vector<double> v = {1., 2., 3., 4., 5., 6. };
     std::vector<std::size_t> shape = { 2, 3 };
@@ -44,13 +44,13 @@ the corresponding value in ``v``:
 Adapting C-style arrays
 -----------------------
 
-`xtensor` provides two ways for adapting C-style array; the first one does not take the
+*xtensor* provides two ways for adapting a C-style array; the first one does not take the
 ownership of the array:
 
 .. code::
 
     #include <cstddef>
-    #include "xtensor/xadapt.hpp"
+    #include <xtensor/containers/xadapt.hpp>
 
     void compute(double* data, std::size_t size)
     {
@@ -76,14 +76,14 @@ ownership of the array:
         // prints 0 2 (data is still available here)
     }
 
-However if you replace ``xt::no_ownership`` with ``xt::acquire_ownership``, the adaptor will take
+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 <cstddef>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xadapt.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/containers/xadapt.hpp>
 
     void compute(double*& data, std::size_t size)
     {
@@ -119,9 +119,9 @@ adaptor before calling ``compute`` and pass it to the function:
 .. code::
 
     #include <cstddef>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xadapt.hpp"
-    
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/containers/xadapt.hpp>
+
     template <class A>
     void compute(A& a)
     {
@@ -129,7 +129,7 @@ adaptor before calling ``compute`` and pass it to the function:
         b.reshape({2, 1});
         a = a * b; // size has changed, shape is now { 2, 2 }
     }
-    
+
     int main()
     {
         std::size_t size = 2;
@@ -144,3 +144,89 @@ adaptor before calling ``compute`` and pass it to the function:
         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 <cstddef>
+    #include <vector>
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/containers/xadapt.hpp>
+
+    double v[6] = {1., 2., 3., 4., 5., 6. };
+    std::vector<std::size_t> shape = { 2, 3 };
+    auto a1 = xt::adapt(v, shape);
+
+    xt::xarray<double> a2 = {{ 1., 2., 3.},
+                             { 4., 5., 6.}};
+
+    xt::xarray<double> 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 <memory>
+    #include <xtensor/containers/xadapt.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    std::shared_ptr<double> sptr(new double[8], std::default_delete<double[]>());
+    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 <memory>
+    #include <xtensor/containers/xadapt.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    struct Buffer {
+        Buffer(std::vector<double>& buf) : m_buf(buf) {}
+        ~Buffer() { std::cout << "deleted" << std::endl; }
+        std::vector<double> m_buf;
+    };
+
+    auto data = std::vector<double>{1,2,3,4,5,6,7,8};
+    auto shared_buf = std::make_shared<Buffer>(data);
+    auto unique_buf = std::make_unique<Buffer>(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
index 64ed2bdbf..1842912e1 100644
--- a/docs/source/api/accumulating_functions.rst
+++ b/docs/source/api/accumulating_functions.rst
@@ -9,18 +9,7 @@ Accumulating functions
 
 **xtensor** provides the following accumulating functions for xexpressions:
 
-Defined in ``xtensor/xmath.hpp``
+Defined in ``xtensor/core/xmath.hpp``
 
-.. _cumsum-function-reference:
-.. doxygenfunction:: cumsum(E&&)
-   :project: xtensor
-
-.. doxygenfunction:: cumsum(E&&, std::ptrdiff_t)
-   :project: xtensor
-
-.. _cumprod-function-reference:
-.. doxygenfunction:: cumprod(E&&)
-   :project: xtensor
-
-.. doxygenfunction:: cumprod(E&&, std::ptrdiff_t)
-   :project: xtensor
\ No newline at end of file
+.. doxygengroup:: acc_functions
+   :members:
diff --git a/docs/source/api/basic_functions.rst b/docs/source/api/basic_functions.rst
index 6fc54a6c1..c6e8020b8 100644
--- a/docs/source/api/basic_functions.rst
+++ b/docs/source/api/basic_functions.rst
@@ -9,53 +9,7 @@ Basic functions
 
 **xtensor** provides the following basic functions for xexpressions and scalars:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _abs-function-reference:
-.. doxygenfunction:: abs(E&&)
-   :project: xtensor
-
-.. _fabs-function-reference:
-.. doxygenfunction:: fabs(E&&)
-   :project: xtensor
-
-.. _fmod-function-reference:
-.. doxygenfunction:: fmod(E1&&, E2&&)
-   :project: xtensor
-
-.. _remainder-func-ref:
-.. doxygenfunction:: remainder(E1&&, E2&&)
-   :project: xtensor
-
-.. _fma-function-reference:
-.. doxygenfunction:: fma(E1&&, E2&&, E3&&)
-   :project: xtensor
-
-.. _maximum-func-ref:
-.. doxygenfunction:: maximum(E1&&, E2&&)
-   :project: xtensor
-
-.. _minimum-func-ref:
-.. doxygenfunction:: minimum(E1&&, E2&&)
-   :project: xtensor
-
-.. _fmax-function-reference:
-.. doxygenfunction:: fmax(E1&&, E2&&)
-   :project: xtensor
-
-.. _fmin-function-reference:
-.. doxygenfunction:: fmin(E1&&, E2&&)
-   :project: xtensor
-
-.. _fdim-function-reference:
-.. doxygenfunction:: fdim(E1&&, E2&&)
-   :project: xtensor
-
-.. _clip-function-reference:
-.. doxygenfunction:: clip(E1&&, E2&&, E3&&)
-   :project: xtensor
-
-.. _sign-function-reference:
-.. doxygenfunction:: sign(E&&)
-   :project: xtensor
+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
index 6cbf6a7cb..f39602b2b 100644
--- a/docs/source/api/classif_functions.rst
+++ b/docs/source/api/classif_functions.rst
@@ -9,25 +9,7 @@ Classification functions
 
 **xtensor** provides the following classification functions for xexpressions and scalars:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _isfinite-func-ref:
-.. doxygenfunction:: isfinite(E&&)
-   :project: xtensor
-
-.. _isinf-func-ref:
-.. doxygenfunction:: isinf(E&&)
-   :project: xtensor
-
-.. _isnan-func-ref:
-.. doxygenfunction:: isnan(E&&)
-   :project: xtensor
-
-.. _isclose-func-ref:
-.. doxygenfunction:: isclose(E1&&, E2&&, double, double, bool)
-   :project: xtensor
-
-.. _allclose-func-ref:
-.. doxygenfunction:: allclose(E1&&, E2&, double, double)
-   :project: xtensor
+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
index d21898633..ef8c0ba84 100644
--- a/docs/source/api/container_index.rst
+++ b/docs/source/api/container_index.rst
@@ -7,15 +7,22 @@
 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
@@ -25,3 +32,5 @@ Containers and views
    xbroadcast
    xindex_view
    xfunctor_view
+   xrepeat
+   xfft
diff --git a/docs/source/api/error_functions.rst b/docs/source/api/error_functions.rst
index 350d9cb0b..be2312f08 100644
--- a/docs/source/api/error_functions.rst
+++ b/docs/source/api/error_functions.rst
@@ -9,21 +9,7 @@ Error and gamma functions
 
 **xtensor** provides the following error and gamma functions for xexpressions:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _erf-function-reference:
-.. doxygenfunction:: erf(E&&)
-   :project: xtensor
-
-.. _erfc-function-reference:
-.. doxygenfunction:: erfc(E&&)
-   :project: xtensor
-
-.. _tgamma-func-ref:
-.. doxygenfunction:: tgamma(E&&)
-   :project: xtensor
-
-.. _lgamma-func-ref:
-.. doxygenfunction:: lgamma(E&&)
-   :project: xtensor
+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
index ce082d3c1..65caeed74 100644
--- a/docs/source/api/exponential_functions.rst
+++ b/docs/source/api/exponential_functions.rst
@@ -9,33 +9,7 @@ Exponential functions
 
 **xtensor** provides the following exponential functions for xexpressions:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _exp-function-reference:
-.. doxygenfunction:: exp(E&&)
-   :project: xtensor
-
-.. _exp2-function-reference:
-.. doxygenfunction:: exp2(E&&)
-   :project: xtensor
-
-.. _expm1-func-ref:
-.. doxygenfunction:: expm1(E&&)
-   :project: xtensor
-
-.. _log-function-reference:
-.. doxygenfunction:: log(E&&)
-   :project: xtensor
-
-.. _log2-function-reference:
-.. doxygenfunction:: log2(E&&)
-   :project: xtensor
-
-.. _log10-func-ref:
-.. doxygenfunction:: log10(E&&)
-   :project: xtensor
-
-.. _log1p-func-ref:
-.. doxygenfunction:: log1p(E&&)
-   :project: xtensor
+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
index 4f2c80e6c..c257117db 100644
--- a/docs/source/api/expression_index.rst
+++ b/docs/source/api/expression_index.rst
@@ -7,6 +7,10 @@
 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
diff --git a/docs/source/api/function_index.rst b/docs/source/api/function_index.rst
index 5c31a4008..b4e3a22cf 100644
--- a/docs/source/api/function_index.rst
+++ b/docs/source/api/function_index.rst
@@ -16,5 +16,7 @@ Functions and generators
    xbuilder
    xmanipulation
    xsort
+   xset_operation
    xrandom
    xhistogram
+   xpad
diff --git a/docs/source/api/hyperbolic_functions.rst b/docs/source/api/hyperbolic_functions.rst
index 8898ea1e8..757c77409 100644
--- a/docs/source/api/hyperbolic_functions.rst
+++ b/docs/source/api/hyperbolic_functions.rst
@@ -9,29 +9,7 @@ Hyperbolic functions
 
 **xtensor** provides the following hyperbolic functions for xexpressions:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _sinh-function-reference:
-.. doxygenfunction:: sinh(E&&)
-   :project: xtensor
-
-.. _cosh-function-reference:
-.. doxygenfunction:: cosh(E&&)
-   :project: xtensor
-
-.. _tanh-function-reference:
-.. doxygenfunction:: tanh(E&&)
-   :project: xtensor
-
-.. _asinh-func-ref:
-.. doxygenfunction:: asinh(E&&)
-   :project: xtensor
-
-.. _acosh-func-ref:
-.. doxygenfunction:: acosh(E&&)
-   :project: xtensor
-
-.. _atanh-func-ref:
-.. doxygenfunction:: atanh(E&&)
-   :project: xtensor
+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
new file mode 100644
index 000000000..f7de8fdc2
--- /dev/null
+++ b/docs/source/api/index_related.rst
@@ -0,0 +1,15 @@
+.. 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/iterator_index.rst b/docs/source/api/iterator_index.rst
new file mode 100644
index 000000000..7640a740a
--- /dev/null
+++ b/docs/source/api/iterator_index.rst
@@ -0,0 +1,16 @@
+.. 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
index 2a5a05c9a..918039bce 100644
--- a/docs/source/api/nan_functions.rst
+++ b/docs/source/api/nan_functions.rst
@@ -9,30 +9,7 @@ NaN functions
 
 **xtensor** provides the following functions that deal with NaNs in xexpressions:
 
-Defined in ``xtensor/xmath.hpp``
+Defined in ``xtensor/core/xmath.hpp``
 
-.. _nan-to-num-function-reference:
-.. doxygenfunction:: nan_to_num(E&&)
-   :project: xtensor
-
-.. _nansum-function-reference:
-.. doxygenfunction:: nansum(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _nanprod-function-reference:
-.. doxygenfunction:: nanprod(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _nancumsum-function-reference:
-.. doxygenfunction:: nancumsum(E&&)
-   :project: xtensor
-
-.. doxygenfunction:: nancumsum(E&&, std::ptrdiff_t)
-   :project: xtensor
-
-.. _nancumprod-function-reference:
-.. doxygenfunction:: nancumprod(E&&)
-   :project: xtensor
-
-.. doxygenfunction:: nancumprod(E&&, std::ptrdiff_t)
-   :project: xtensor
+.. doxygengroup:: nan_functions
+   :members:
diff --git a/docs/source/api/nearint_operations.rst b/docs/source/api/nearint_operations.rst
index 02340039a..59dd61d19 100644
--- a/docs/source/api/nearint_operations.rst
+++ b/docs/source/api/nearint_operations.rst
@@ -9,29 +9,7 @@ Nearest integer floating point operations
 
 **xtensor** provides the following rounding operations for xexpressions:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _ceil-function-reference:
-.. doxygenfunction:: ceil(E&&)
-   :project: xtensor
-
-.. _floor-func-ref:
-.. doxygenfunction:: floor(E&&)
-   :project: xtensor
-
-.. _trunc-func-ref:
-.. doxygenfunction:: trunc(E&&)
-   :project: xtensor
-
-.. _round-func-ref:
-.. doxygenfunction:: round(E&&)
-   :project: xtensor
-
-.. _nearbyint-func-ref:
-.. doxygenfunction:: nearbyint(E&&)
-   :project: xtensor
-
-.. _rint-function-reference:
-.. doxygenfunction:: rint(E&&)
-   :project: xtensor
+Defined in ``xtensor/core/xmath.hpp``
 
+.. doxygengroup:: nearint_functions
+   :members:
diff --git a/docs/source/api/operators.rst b/docs/source/api/operators.rst
index c6b67ff4b..00df9458d 100644
--- a/docs/source/api/operators.rst
+++ b/docs/source/api/operators.rst
@@ -7,120 +7,19 @@
 Operators and related functions
 ===============================
 
-Defined in ``xtensor/xmath.hpp`` and ``xtensor/xoperation.hpp``
+Defined in ``xtensor/core/xmath.hpp`` and ``xtensor/core/xoperation.hpp``
 
-.. _identity-op-ref:
-.. doxygenfunction:: operator+(E&&)
-   :project: xtensor
+.. doxygengroup:: arithmetic_operators
+   :members:
 
-.. _neg-op-ref:
-.. doxygenfunction:: operator-(E&&)
-   :project: xtensor
+.. doxygengroup:: logical_operators
+   :members:
 
-.. _plus-op-ref:
-.. doxygenfunction:: operator+(E1&&, E2&&)
-   :project: xtensor
+.. doxygengroup:: comparison_operators
+   :members:
 
-.. _minus-op-ref:
-.. doxygenfunction:: operator-(E1&&, E2&&)
-   :project: xtensor
+.. doxygengroup:: bitwise_operators
+   :members:
 
-.. _mul-op-ref:
-.. doxygenfunction:: operator*(E1&&, E2&&)
-   :project: xtensor
-
-.. _div-op-ref:
-.. doxygenfunction:: operator/(E1&&, E2&&)
-   :project: xtensor
-
-.. _or-op-ref:
-.. doxygenfunction:: operator||(E1&&, E2&&)
-   :project: xtensor
-
-.. _and-op-ref:
-.. doxygenfunction:: operator&&(E1&&, E2&&)
-   :project: xtensor
-
-.. _not-op-ref:
-.. doxygenfunction:: operator!(E&&)
-   :project: xtensor
-
-.. _where-op-ref:
-.. doxygenfunction:: where(E1&&, E2&&, E3&&)
-   :project: xtensor
-
-.. _nonzero-op-ref:
-.. doxygenfunction:: nonzero(const T&)
-   :project: xtensor
-
-.. _wherec-op-ref:
-.. doxygenfunction:: where(const T&)
-   :project: xtensor
-
-.. _any-op-ref:
-.. doxygenfunction:: any(E&&)
-   :project: xtensor
-
-.. _all-op-ref:
-.. doxygenfunction:: all(E&&)
-   :project: xtensor
-
-.. _less-op-ref:
-.. doxygenfunction:: operator<(E1&&, E2&&)
-   :project: xtensor
-
-.. _less-eq-op-ref:
-.. doxygenfunction:: operator<=(E1&&, E2&&)
-   :project: xtensor
-
-.. _greater-op-ref:
-.. doxygenfunction:: operator>(E1&&, E2&&)
-   :project: xtensor
-
-.. _greater-eq-op-ref:
-.. doxygenfunction:: operator>=(E1&&, E2&&)
-   :project: xtensor
-
-.. _equal-op-ref:
-.. doxygenfunction:: operator==(const xexpression<E1>&, const xexpression<E2>&)
-   :project: xtensor
-
-.. _nequal-op-ref:
-.. doxygenfunction:: operator!=(const xexpression<E1>&, const xexpression<E2>&)
-   :project: xtensor
-
-.. _equal-fn-ref:
-.. doxygenfunction:: equal(E1&&, E2&&)
-   :project: xtensor
-
-.. _nequal-fn-ref:
-.. doxygenfunction:: not_equal(E1&&, E2&&)
-   :project: xtensor
-
-.. _bitwise-and-op-ref:
-.. doxygenfunction:: operator&(E1&&, E2&&)
-   :project: xtensor
-
-.. _bitwise-or-op-ref:
-.. doxygenfunction:: operator|(E1&&, E2&&)
-   :project: xtensor
-
-.. _bitwise-xor-op-ref:
-.. doxygenfunction:: operator^(E1&&, E2&&)
-   :project: xtensor
-
-.. _bitwise-not-op-ref:
-.. doxygenfunction:: operator~(E&&)
-   :project: xtensor
-
-.. _left-shift-op-ref:
-.. doxygenfunction:: left_shift(E1&&, E2&&)
-   :project: xtensor
-
-.. _right-shift-op-ref:
-.. doxygenfunction:: right_shift(E1&&, E2&&)
-   :project: xtensor
-
-.. _cast-ref:
-.. doxygenfunction:: cast(E&&)
-   :project: xtensor
+.. doxygengroup:: casting_operators
+   :members:
diff --git a/docs/source/api/power_functions.rst b/docs/source/api/power_functions.rst
index 45d53e95f..5ac5a1546 100644
--- a/docs/source/api/power_functions.rst
+++ b/docs/source/api/power_functions.rst
@@ -10,30 +10,7 @@ Power functions
 
 **xtensor** provides the following power functions for xexpressions and scalars:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _pow-function-reference:
-.. doxygenfunction:: pow(E1&&, E2&&)
-   :project: xtensor
-
-.. doxygenfunction:: pow(E&&)
-   :project: xtensor
-
-.. doxygenfunction:: square(E1&&)
-   :project: xtensor
-
-.. doxygenfunction:: cube(E1&&)
-   :project: xtensor
-
-.. _sqrt-function-reference:
-.. doxygenfunction:: sqrt(E&&)
-   :project: xtensor
-
-.. _cbrt-function-reference:
-.. doxygenfunction:: cbrt(E&&)
-   :project: xtensor
-
-.. _hypot-func-ref:
-.. doxygenfunction:: hypot(E1&&, E2&&)
-   :project: xtensor
+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
index 4709d9573..89c0baff5 100644
--- a/docs/source/api/reducing_functions.rst
+++ b/docs/source/api/reducing_functions.rst
@@ -9,82 +9,7 @@ Reducing functions
 
 **xtensor** provides the following reducing functions for xexpressions:
 
-Defined in ``xtensor/xmath.hpp``
+Defined in ``xtensor/core/xmath.hpp`` and ``xtensor/reducers/xnorm.hpp``.
 
-.. _sum-function-reference:
-.. doxygenfunction:: sum(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _prod-function-reference:
-.. doxygenfunction:: prod(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _mean-function-reference:
-.. doxygenfunction:: mean(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _variance-function-reference:
-.. doxygenfunction:: variance(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _stddev-function-reference:
-.. doxygenfunction:: stddev(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _diff-function-reference:
-.. doxygenfunction:: diff(const xexpression<T>&, unsigned int, std::ptrdiff_t)
-   :project: xtensor
-
-.. _amax-function-reference:
-.. doxygenfunction:: amax(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _amin-function-reference:
-.. doxygenfunction:: amin(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _trapz-function-reference:
-.. doxygenfunction:: trapz(const xexpression<T>&, double, std::ptrdiff_t)
-   :project: xtensor
-
-.. _trapz-function-reference2:
-.. doxygenfunction:: trapz(const xexpression<T>&, const xexpression<E>&, std::ptrdiff_t)
-   :project: xtensor
-
-Defined in ``xtensor/xnorm.hpp``
-
-.. _norm-l0-func-ref:
-.. doxygenfunction:: norm_l0(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _norm-l1-func-ref:
-.. doxygenfunction:: norm_l1(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _norm-sq-func-ref:
-.. doxygenfunction:: norm_sq(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _norm-l2-func-ref:
-.. doxygenfunction:: norm_l2(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _norm-linf-func-ref:
-.. doxygenfunction:: norm_linf(E&&, X&&, EVS)
-   :project: xtensor
-
-.. _nlptop-func-ref:
-.. doxygenfunction:: norm_lp_to_p(E&&, double, X&&, EVS)
-   :project: xtensor
-
-.. _norm-lp-func-ref:
-.. doxygenfunction:: norm_lp(E&&, double, X&&, EVS)
-   :project: xtensor
-
-.. _nind-l1-ref:
-.. doxygenfunction:: norm_induced_l1(E&&, EVS)
-   :project: xtensor
-
-.. _nilinf-ref:
-.. doxygenfunction:: norm_induced_linf(E&&, EVS)
-   :project: xtensor
+.. doxygengroup:: red_functions
+   :members:
diff --git a/docs/source/api/shape.rst b/docs/source/api/shape.rst
new file mode 100644
index 000000000..a35434ac9
--- /dev/null
+++ b/docs/source/api/shape.rst
@@ -0,0 +1,13 @@
+.. 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
index 84ae190c2..e76d151b5 100644
--- a/docs/source/api/trigonometric_functions.rst
+++ b/docs/source/api/trigonometric_functions.rst
@@ -9,33 +9,7 @@ Trigonometric functions
 
 **xtensor** provides the following trigonometric functions for xexpressions and scalars:
 
-Defined in ``xtensor/xmath.hpp``
-
-.. _sin-function-reference:
-.. doxygenfunction:: sin(E&&)
-   :project: xtensor
-
-.. _cos-function-reference:
-.. doxygenfunction:: cos(E&&)
-   :project: xtensor
-
-.. _tan-function-reference:
-.. doxygenfunction:: tan(E&&)
-   :project: xtensor
-
-.. _asin-function-reference:
-.. doxygenfunction:: asin(E&&)
-   :project: xtensor
-
-.. _acos-function-reference:
-.. doxygenfunction:: acos(E&&)
-   :project: xtensor
-
-.. _atan-function-reference:
-.. doxygenfunction:: atan(E&&)
-   :project: xtensor
-
-.. _atan2-func-ref:
-.. doxygenfunction:: atan2(E1&&, E2&&)
-   :project: xtensor
+Defined in ``xtensor/core/xmath.hpp``
 
+.. doxygengroup:: trigo_functions
+   :members:
diff --git a/docs/source/api/xaccessible.rst b/docs/source/api/xaccessible.rst
new file mode 100644
index 000000000..237fc029d
--- /dev/null
+++ b/docs/source/api/xaccessible.rst
@@ -0,0 +1,16 @@
+.. 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
index 18ded9152..906f5288e 100644
--- a/docs/source/api/xaccumulator.rst
+++ b/docs/source/api/xaccumulator.rst
@@ -7,10 +7,8 @@
 xaccumulator
 ============
 
-Defined in ``xtensor/xaccumulator.hpp``
+Defined in ``xtensor/reducers/xaccumulator.hpp``
 
 .. doxygenfunction:: xt::accumulate(F&&, E&&, EVS)
-   :project: xtensor
 
 .. doxygenfunction:: xt::accumulate(F&&, E&&, std::ptrdiff_t, EVS)
-   :project: xtensor
diff --git a/docs/source/api/xadapt.rst b/docs/source/api/xadapt.rst
new file mode 100644
index 000000000..86f9e4eb2
--- /dev/null
+++ b/docs/source/api/xadapt.rst
@@ -0,0 +1,16 @@
+.. 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
index cc55e0235..18e06692e 100644
--- a/docs/source/api/xarray.rst
+++ b/docs/source/api/xarray.rst
@@ -7,14 +7,11 @@
 xarray
 ======
 
-Defined in ``xtensor/xarray.hpp``
+Defined in ``xtensor/containers/xarray.hpp``
 
 .. doxygenclass:: xt::xarray_container
-   :project: xtensor
    :members:
 
 .. doxygentypedef:: xt::xarray
-   :project: xtensor
 
 .. doxygentypedef:: xt::xarray_optional
-   :project: xtensor
diff --git a/docs/source/api/xarray_adaptor.rst b/docs/source/api/xarray_adaptor.rst
index 82b7dedcd..d1110c7ba 100644
--- a/docs/source/api/xarray_adaptor.rst
+++ b/docs/source/api/xarray_adaptor.rst
@@ -7,25 +7,7 @@
 xarray_adaptor
 ==============
 
-Defined in ``xtensor/xarray.hpp``
+Defined in ``xtensor/containers/xarray.hpp``
 
 .. doxygenclass:: xt::xarray_adaptor
-   :project: xtensor
    :members:
-
-adapt (xarray_adaptor)
-=======================
-
-Defined in ``xtensor/xadapt.hpp``
-
-.. doxygenfunction:: xt::adapt(C&&, const SC&, layout_type)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(C&&, SC&&, SS&&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(P&&, typename A::size_type, O, const SC&, layout_type, const A&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(P&&, typename A::size_type, O, SC&&, SS&&, const A&)
-   :project: xtensor
diff --git a/docs/source/api/xaxis_iterator.rst b/docs/source/api/xaxis_iterator.rst
new file mode 100644
index 000000000..e43bae3ee
--- /dev/null
+++ b/docs/source/api/xaxis_iterator.rst
@@ -0,0 +1,26 @@
+.. 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<CT>&, const xaxis_iterator<CT>&)
+
+
+.. doxygenfunction:: operator!=(const xaxis_iterator<CT>&, const xaxis_iterator<CT>&)
+
+.. doxygenfunction:: axis_begin(E&&)
+
+.. doxygenfunction:: axis_begin(E&&, typename std::decay_t<E>::size_type)
+
+.. doxygenfunction:: axis_end(E&&)
+
+.. doxygenfunction:: axis_end(E&&, typename std::decay_t<E>::size_type)
diff --git a/docs/source/api/xaxis_slice_iterator.rst b/docs/source/api/xaxis_slice_iterator.rst
new file mode 100644
index 000000000..4882fc292
--- /dev/null
+++ b/docs/source/api/xaxis_slice_iterator.rst
@@ -0,0 +1,27 @@
+
+.. 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<CT>&, const xaxis_slice_iterator<CT>&)
+
+
+.. doxygenfunction:: operator!=(const xaxis_slice_iterator<CT>&, const xaxis_slice_iterator<CT>&)
+
+.. doxygenfunction:: axis_slice_begin(E&&)
+
+.. doxygenfunction:: axis_slice_begin(E&&, typename std::decay_t<E>::size_type)
+
+.. doxygenfunction:: axis_slice_end(E&&)
+
+.. doxygenfunction:: axis_slice_end(E&&, typename std::decay_t<E>::size_type)
diff --git a/docs/source/api/xbroadcast.rst b/docs/source/api/xbroadcast.rst
index 35f1f9041..e5fe1790f 100644
--- a/docs/source/api/xbroadcast.rst
+++ b/docs/source/api/xbroadcast.rst
@@ -7,11 +7,9 @@
 xbroadcast
 ==========
 
-Defined in ``xtensor/xbroadcast.hpp``
+Defined in ``xtensor/views/xbroadcast.hpp``
 
 .. doxygenclass:: xt::xbroadcast
-   :project: xtensor
    :members:
 
 .. doxygenfunction:: xt::broadcast(E&&, const S&)
-   :project: xtensor
diff --git a/docs/source/api/xbuilder.rst b/docs/source/api/xbuilder.rst
index d47e082eb..b315c3730 100644
--- a/docs/source/api/xbuilder.rst
+++ b/docs/source/api/xbuilder.rst
@@ -7,70 +7,52 @@
 xbuilder
 ========
 
-Defined in ``xtensor/xbuilder.hpp``
+Defined in ``xtensor/generators/xbuilder.hpp``
 
 .. doxygenfunction:: xt::ones(S)
-   :project: xtensor
 
 .. doxygenfunction:: xt::ones(const I (&)[L])
-   :project: xtensor
 
 .. doxygenfunction:: xt::zeros(S)
-   :project: xtensor
 
 .. doxygenfunction:: xt::zeros(const I (&)[L])
-   :project: xtensor
 
 .. doxygenfunction:: xt::empty(const S&)
-   :project: xtensor
 
-.. doxygenfunction:: xt::full_like(const xexpression<E>&)
-   :project: xtensor
+.. doxygenfunction:: xt::full_like(const xexpression<E>&, typename E::value_type)
 
 .. doxygenfunction:: xt::empty_like(const xexpression<E>&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::zeros_like(const xexpression<E>&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::ones_like(const xexpression<E>&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::eye(const std::vector<std::size_t>&, int)
-   :project: xtensor
 
 .. doxygenfunction:: xt::eye(std::size_t, int)
-   :project: xtensor
 
-.. doxygenfunction:: xt::arange(T, T, T)
-   :project: xtensor
+.. doxygenfunction:: xt::arange(T, T, S)
 
 .. doxygenfunction:: xt::arange(T)
-   :project: xtensor
 
 .. doxygenfunction:: xt::linspace
-   :project: xtensor
 
 .. doxygenfunction:: xt::logspace
-   :project: xtensor
 
-.. doxygenfunction:: xt::concatenate
-   :project: xtensor
+.. doxygenfunction:: xt::concatenate(std::tuple<CT...>&&, std::size_t)
 
 .. doxygenfunction:: xt::stack
-   :project: xtensor
+
+.. doxygenfunction:: xt::hstack
+
+.. doxygenfunction:: xt::vstack
 
 .. doxygenfunction:: xt::meshgrid
-   :project: xtensor
 
 .. doxygenfunction:: xt::diag
-   :project: xtensor
 
 .. doxygenfunction:: xt::diagonal
-   :project: xtensor
 
 .. doxygenfunction:: xt::tril
-   :project: xtensor
 
 .. doxygenfunction:: xt::triu
-   :project: xtensor
diff --git a/docs/source/api/xchunked_array.rst b/docs/source/api/xchunked_array.rst
new file mode 100644
index 000000000..f3971bf4f
--- /dev/null
+++ b/docs/source/api/xchunked_array.rst
@@ -0,0 +1,14 @@
+.. 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
index 780a4d591..24fbf6c47 100644
--- a/docs/source/api/xcontainer.rst
+++ b/docs/source/api/xcontainer.rst
@@ -7,29 +7,24 @@
 layout
 ======
 
-Defined in ``xtensor/xlayout.hpp``
+Defined in ``xtensor/core/xlayout.hpp``
 
 .. doxygenenum:: xt::layout_type
-   :project: xtensor
 
 .. doxygenfunction:: xt::compute_layout(Args... args)
-   :project: xtensor
 
 xcontainer
 ==========
 
-Defined in ``xtensor/xcontainer.hpp``
+Defined in ``xtensor/containers/xcontainer.hpp``
 
 .. doxygenclass:: xt::xcontainer
-   :project: xtensor
    :members:
 
 xstrided_container
 ==================
 
-Defined in ``xtensor/xcontainer.hpp``
+Defined in ``xtensor/containers/xcontainer.hpp``
 
 .. doxygenclass:: xt::xstrided_container
-   :project: xtensor
    :members:
-
diff --git a/docs/source/api/xcontainer_semantic.rst b/docs/source/api/xcontainer_semantic.rst
index 736f65564..c69866083 100644
--- a/docs/source/api/xcontainer_semantic.rst
+++ b/docs/source/api/xcontainer_semantic.rst
@@ -7,8 +7,7 @@
 xcontainer_semantic
 ===================
 
-Defined in ``xtensor/xsemantic.hpp``
+Defined in ``xtensor/core/xsemantic.hpp``
 
 .. doxygenclass:: xt::xcontainer_semantic
-   :project: xtensor
    :members:
diff --git a/docs/source/api/xcsv.rst b/docs/source/api/xcsv.rst
index 5e5d12d18..bc762b00f 100644
--- a/docs/source/api/xcsv.rst
+++ b/docs/source/api/xcsv.rst
@@ -7,10 +7,8 @@
 xcsv: read/write CSV files
 ==========================
 
-Defined in ``xtensor/xcsv.hpp``
+Defined in ``xtensor/io/xcsv.hpp``
 
 .. doxygenfunction:: xt::load_csv
-   :project: xtensor
 
 .. doxygenfunction:: xt::dump_csv
-   :project: xtensor
diff --git a/docs/source/api/xeval.rst b/docs/source/api/xeval.rst
index 74e103c62..c70420965 100644
--- a/docs/source/api/xeval.rst
+++ b/docs/source/api/xeval.rst
@@ -7,7 +7,8 @@
 xeval
 =====
 
-Defined in ``xtensor/xeval.hpp``
+.. cpp:namespace-push:: xt
 
-.. doxygenfunction:: xt::eval(E&& e)
-   :project: xtensor
+.. doxygengroup:: xt_xeval
+
+.. cpp:namespace-pop::
diff --git a/docs/source/api/xexpression.rst b/docs/source/api/xexpression.rst
index 5b6d6273b..61f117592 100644
--- a/docs/source/api/xexpression.rst
+++ b/docs/source/api/xexpression.rst
@@ -7,15 +7,16 @@
 xexpression
 ===========
 
-Defined in ``xtensor/xexpression.hpp``
+Defined in ``xtensor/core/xexpression.hpp``
 
 .. doxygenclass:: xt::xexpression
-   :project: xtensor
    :members:
 
 .. doxygenclass:: xt::xshared_expression
-   :project: xtensor
    :members:
 
 .. doxygenfunction:: make_xshared
-   :project: xtensor
\ No newline at end of file
+
+.. doxygenfunction:: share(xexpression<E>&)
+
+.. doxygenfunction:: share(xexpression<E>&&)
diff --git a/docs/source/api/xfft.rst b/docs/source/api/xfft.rst
new file mode 100644
index 000000000..a05766ff7
--- /dev/null
+++ b/docs/source/api/xfft.rst
@@ -0,0 +1,16 @@
+.. 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
index ec56a9bda..b9afc6d7b 100644
--- a/docs/source/api/xfixed.rst
+++ b/docs/source/api/xfixed.rst
@@ -7,12 +7,9 @@
 xtensor_fixed
 =============
 
-Defined in ``xtensor/xfixed.hpp``
+Defined in ``xtensor/containers/xfixed.hpp``
 
 .. doxygenclass:: xt::xfixed_container
-   :project: xtensor
    :members:
 
 .. doxygentypedef:: xt::xtensor_fixed
-   :project: xtensor
-
diff --git a/docs/source/api/xfunction.rst b/docs/source/api/xfunction.rst
index 035d49e62..e572e463b 100644
--- a/docs/source/api/xfunction.rst
+++ b/docs/source/api/xfunction.rst
@@ -7,13 +7,11 @@
 xfunction
 =========
 
-Defined in ``xtensor/xfunction.hpp``
+Defined in ``xtensor/core/xfunction.hpp``
 
 .. doxygenclass:: xt::xfunction
-   :project: xtensor
    :members:
 
-Defined in ``xtensor/xmath.hpp``
+Defined in ``xtensor/core/xmath.hpp``
 
 .. doxygenfunction:: make_lambda_xfunction
-   :project: xtensor
diff --git a/docs/source/api/xfunctor_view.rst b/docs/source/api/xfunctor_view.rst
index be4a7607b..53ee7573d 100644
--- a/docs/source/api/xfunctor_view.rst
+++ b/docs/source/api/xfunctor_view.rst
@@ -7,16 +7,12 @@
 xfunctor_view
 =============
 
-Defined in ``xtensor/xfunctor_view.hpp``
+.. cpp:namespace-push:: xt
 
-.. doxygenclass:: xt::xfunctor_view
-   :project: xtensor
+.. doxygengroup:: xt_xfunctor_view
    :members:
+   :undoc-members:
 
-Defined in ``xtensor/xcomplex.hpp``
+.. doxygengroup:: xt_xcomplex
 
-.. doxygenfunction:: xt::real(E&&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::imag(E&&)
-   :project: xtensor
+.. cpp:namespace-pop::
diff --git a/docs/source/api/xgenerator.rst b/docs/source/api/xgenerator.rst
index ed45631ba..8d96da7f3 100644
--- a/docs/source/api/xgenerator.rst
+++ b/docs/source/api/xgenerator.rst
@@ -7,9 +7,7 @@
 xgenerator
 ==========
 
-Defined in ``xtensor/xgenerator.hpp``
+Defined in ``xtensor/generators/xgenerator.hpp``
 
 .. doxygenclass:: xt::xgenerator
-   :project: xtensor
    :members:
-
diff --git a/docs/source/api/xhistogram.rst b/docs/source/api/xhistogram.rst
index a268e3141..4d1e3e639 100644
--- a/docs/source/api/xhistogram.rst
+++ b/docs/source/api/xhistogram.rst
@@ -7,37 +7,16 @@
 xhistogram
 ==========
 
-Defined in ``xtensor/xhistogram.hpp``
+Defined in ``xtensor/misc/xhistogram.hpp``
 
-.. doxygenenum:: xt::histogram_algorithm
-   :project: xtensor
+.. doxygengroup:: digitize
+   :members:
 
-.. doxygenfunction:: xt::histogram(E1&&, E2&&, E3&&, bool)
-   :project: xtensor
+.. doxygengroup:: histogram
+   :members:
 
 .. doxygenfunction:: xt::bincount(E1&&, E2&&, std::size_t)
-   :project: xtensor
 
-.. doxygenfunction:: xt::histogram_bin_edges(E1&&, E2&&, E3, E3, std::size_t, histogram_algorithm)
-   :project: xtensor
+.. doxygenfunction:: xt::bin_items(size_t, E&&)
 
-Further overloads
------------------
-
-.. doxygenfunction:: xt::histogram(E1&&, E2&&, bool)
-   :project: xtensor
-
-.. doxygenfunction:: xt::histogram(E1&&, std::size_t, bool)
-   :project: xtensor
-
-.. doxygenfunction:: xt::histogram(E1&&, std::size_t, E2&&, bool)
-   :project: xtensor
-
-.. doxygenfunction:: xt::histogram_bin_edges(E1&&, E2, E2, std::size_t, histogram_algorithm)
-   :project: xtensor
-
-.. doxygenfunction:: xt::histogram_bin_edges(E1&&, E2&&, std::size_t, histogram_algorithm)
-   :project: xtensor
-
-.. doxygenfunction:: xt::histogram_bin_edges(E1&&, std::size_t, histogram_algorithm)
-   :project: xtensor
+.. doxygenfunction:: xt::bin_items(size_t, size_t)
diff --git a/docs/source/api/xindex_view.rst b/docs/source/api/xindex_view.rst
index 1d47bb3a7..d47ab3733 100644
--- a/docs/source/api/xindex_view.rst
+++ b/docs/source/api/xindex_view.rst
@@ -7,21 +7,16 @@
 xindex_view
 ===========
 
-Defined in ``xtensor/xindex_view.hpp``
+Defined in ``xtensor/views/xindex_view.hpp``
 
 .. doxygenclass:: xt::xindex_view
-   :project: xtensor
    :members:
 
 .. doxygenclass:: xt::xfiltration
-   :project: xtensor
    :members:
 
 .. doxygenfunction:: xt::index_view(E&&, I&&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::filter
-   :project: xtensor
 
 .. doxygenfunction:: xt::filtration
-   :project: xtensor
diff --git a/docs/source/api/xio.rst b/docs/source/api/xio.rst
index 179b191b9..7af4c5d09 100644
--- a/docs/source/api/xio.rst
+++ b/docs/source/api/xio.rst
@@ -7,15 +7,15 @@
 xio: pretty printing
 ====================
 
-Defined in ``xtensor/xio.hpp``
+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 <xtensor/xio.hpp>
-    #include <xtensor/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
+    #include <xtensor/containers/xarray.hpp>
 
     int main()
     {
@@ -24,7 +24,7 @@ overloads for the ``<<`` operator for std::ostreams and xexpressions.
         return 0;
     }
 
-Will print 
+Will print
 
 .. code::
 
@@ -34,27 +34,19 @@ Will print
 With the following functions, the global print options can be set:
 
 .. doxygenfunction:: xt::print_options::set_line_width
-   :project: xtensor
 
 .. doxygenfunction:: xt::print_options::set_threshold
-   :project: xtensor
 
 .. doxygenfunction:: xt::print_options::set_edge_items
-   :project: xtensor
 
 .. doxygenfunction:: xt::print_options::set_precision
-   :project: xtensor
 
 On can also locally overwrite the print options with io manipulators:
 
 .. doxygenclass:: xt::print_options::line_width
-   :project: xtensor
 
 .. doxygenclass:: xt::print_options::threshold
-   :project: xtensor
 
 .. doxygenclass:: xt::print_options::edge_items
-   :project: xtensor
 
 .. doxygenclass:: xt::print_options::precision
-   :project: xtensor
diff --git a/docs/source/api/xiterable.rst b/docs/source/api/xiterable.rst
index 294461cef..f0ad5637d 100644
--- a/docs/source/api/xiterable.rst
+++ b/docs/source/api/xiterable.rst
@@ -7,17 +7,13 @@
 xiterable
 =========
 
-Defined in ``xtensor/xiterable.hpp``
+Defined in ``xtensor/core/xiterable.hpp``
 
 .. doxygenclass:: xt::xconst_iterable
-   :project: xtensor
    :members:
 
 .. doxygenclass:: xt::xiterable
-   :project: xtensor
    :members:
 
 .. doxygenclass:: xt::xcontiguous_iterable
-   :project: xtensor
    :members:
-
diff --git a/docs/source/api/xjson.rst b/docs/source/api/xjson.rst
index 0de7017aa..138c5b9de 100644
--- a/docs/source/api/xjson.rst
+++ b/docs/source/api/xjson.rst
@@ -7,10 +7,12 @@
 xjson: serialize to/from JSON
 =============================
 
-Defined in ``xtensor/xjson.hpp``
+Defined in ``xtensor/io/xjson.hpp``
 
-.. doxygenfunction:: xt::to_json(nlohmann::json&, const E&);
-   :project: xtensor
+Available overload families
+---------------------------
 
-.. doxygenfunction:: xt::from_json(nlohmann::json&, const E&);
-   :project: xtensor
+- ``xt::to_json(nlohmann::basic_json<M>&, const E&)``
+- ``xt::from_json(const nlohmann::basic_json<M>&, 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
index 9e9f50860..779010da5 100644
--- a/docs/source/api/xmanipulation.rst
+++ b/docs/source/api/xmanipulation.rst
@@ -7,49 +7,10 @@
 xmanipulation
 =============
 
-Defined in ``xtensor/xmanipulation.hpp``
+Defined in ``xtensor/misc/xmanipulation.hpp``
 
-.. doxygenfunction:: xt::transpose(E&&)
-   :project: xtensor
+.. cpp:namespace-push:: xt
 
-.. doxygenfunction:: xt::transpose(E&&, S&&, Tag)
-   :project: xtensor
+.. doxygengroup:: xt_xmanipulation
 
-.. doxygenfunction:: xt::ravel
-   :project: xtensor
-
-.. doxygenfunction:: xt::flatten
-   :project: xtensor
-
-.. doxygenfunction:: xt::trim_zeros
-  :project: xtensor
-
-.. doxygenfunction:: xt::squeeze(E&&)
-  :project: xtensor
-
-.. doxygenfunction:: xt::squeeze(E&&, S&&, Tag)
-  :project: xtensor
-
-.. doxygenfunction:: xt::expand_dims
-  :project: xtensor
-
-.. doxygenfunction:: xt::split
-  :project: xtensor
-
-.. doxygenfunction:: xt::atleast_Nd
-  :project: xtensor
-
-.. doxygenfunction:: xt::atleast_1d
-  :project: xtensor
-
-.. doxygenfunction:: xt::atleast_2d
-  :project: xtensor
-
-.. doxygenfunction:: xt::atleast_3d
-  :project: xtensor
-
-.. doxygenfunction:: xt::rot90
-   :project: xtensor
-
-.. doxygenfunction:: xt::flip
-   :project: xtensor
+.. cpp:namespace-pop::
diff --git a/docs/source/api/xmasked_view.rst b/docs/source/api/xmasked_view.rst
index 7d199a817..b7df88ec3 100644
--- a/docs/source/api/xmasked_view.rst
+++ b/docs/source/api/xmasked_view.rst
@@ -7,8 +7,7 @@
 xmasked_view
 ============
 
-Defined in ``xtensor/xmasked_view.hpp``
+Defined in ``xtensor/views/xmasked_view.hpp``
 
 .. doxygenclass:: xt::xmasked_view
-   :project: xtensor
    :members:
diff --git a/docs/source/api/xmath.rst b/docs/source/api/xmath.rst
index c5601daa4..934879b8a 100644
--- a/docs/source/api/xmath.rst
+++ b/docs/source/api/xmath.rst
@@ -33,280 +33,353 @@ Mathematical functions
 
    operators
 
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator+ <identity-op-ref>`      | identity                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator- <neg-op-ref>`           | opposite                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator+ <plus-op-ref>`          | addition                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator- <minus-op-ref>`         | substraction                             |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator* <mul-op-ref>`           | multiplication                           |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator/ <div-op-ref>`           | division                                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator|| <or-op-ref>`           | logical or                               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator&& <and-op-ref>`          | logical and                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator! <not-op-ref>`           | logical not                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`where <where-op-ref>`             | ternary selection                        |
-+-----------------------------------------+------------------------------------------+
-| :ref:`nonzero <nonzero-op-ref>`         | indices selection                        |
-+-----------------------------------------+------------------------------------------+
-| :ref:`where <wherec-op-ref>`            | indices selection                        |
-+-----------------------------------------+------------------------------------------+
-| :ref:`any <any-op-ref>`                 | return true if any value is truthy       |
-+-----------------------------------------+------------------------------------------+
-| :ref:`all <all-op-ref>`                 | return true if all the values are truthy |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator\< <less-op-ref>`         | element-wise lesser than                 |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator\<= <less-eq-op-ref>`     | element-wise less or equal               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator> <greater-op-ref>`       | element-wise greater than                |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator>= <greater-eq-op-ref>`   | element-wise greater or equal            |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator== <equal-op-ref>`        | expression equality                      |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator!= <nequal-op-ref>`       | expression inequality                    |
-+-----------------------------------------+------------------------------------------+
-| :ref:`equal <equal-fn-ref>`             | element-wise equality                    |
-+-----------------------------------------+------------------------------------------+
-| :ref:`not_equal <nequal-fn-ref>`        | element-wise inequality                  |
-+-----------------------------------------+------------------------------------------+
-| :ref:`cast <cast-ref>`                  | element-wise `static_cast`               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator& <bitwise-and-op-ref>`   | bitwise and                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator| <bitwise-or-op-ref>`    | bitwise or                               |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator^ <bitwise-xor-op-ref>`   | bitwise xor                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`operator~ <bitwise-not-op-ref>`   | bitwise not                              |
-+-----------------------------------------+------------------------------------------+
-| :ref:`left_shift <left-shift-op-ref>`   | bitwise shift left                       |
-+-----------------------------------------+------------------------------------------+
-| :ref:`right_shift <right-shift-op-ref>` | bitwise shift right                      |
-+-----------------------------------------+------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`abs <abs-function-reference>`   | absolute value                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fabs <fabs-function-reference>` | absolute value                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fmod <fmod-function-reference>` | remainder of the floating point division operation |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`remainder <remainder-func-ref>` | signed remainder of the division operation         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fma <fma-function-reference>`   | fused multiply-add operation                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`minimum <minimum-func-ref>`     | element-wise minimum                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`maximum <maximum-func-ref>`     | element-wise maximum                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fmin <fmin-function-reference>` | element-wise minimum for floating point values     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fmax <fmax-function-reference>` | element-wise maximum for floating point values     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`fdim <fdim-function-reference>` | element-wise positive difference                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`clip <clip-function-reference>` | element-wise clipping operation                    |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sign <sign-function-reference>` | element-wise indication of the sign                |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`exp <exp-function-reference>`   | natural exponential function                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`exp2 <exp2-function-reference>` | base 2 exponential function                        |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`expm1 <expm1-func-ref>`         | natural exponential function, minus one            |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log <log-function-reference>`   | natural logarithm function                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log2 <log2-function-reference>` | base 2 logarithm function                          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log10 <log10-func-ref>`         | base 10 logarithm function                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`log1p <log1p-func-ref>`         | natural logarithm of one plus function             |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`pow <pow-function-reference>`   | power function                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sqrt <sqrt-function-reference>` | square root function                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`cbrt <cbrt-function-reference>` | cubic root function                                |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`hypot <hypot-func-ref>`         | hypotenuse function                                |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sin <sin-function-reference>`   | sine function                                      |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`cos <cos-function-reference>`   | cosine function                                    |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`tan <tan-function-reference>`   | tangent function                                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`asin <asin-function-reference>` | arc sine function                                  |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`acos <acos-function-reference>` | arc cosine function                                |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`atan <atan-function-reference>` | arc tangent function                               |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`atan2 <atan2-func-ref>`         | arc tangent function, determining quadrants        |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`sinh <sinh-function-reference>` | hyperbolic sine function                           |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`cosh <cosh-function-reference>` | hyperbolic cosine function                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`tanh <tanh-function-reference>` | hyperbolic tangent function                        |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`asinh <asinh-func-ref>`         | inverse hyperbolic sine function                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`acosh <acosh-func-ref>`         | inverse hyperbolic cosine function                 |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`atanh <atanh-func-ref>`         | inverse hyperbolic tangent function                |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`erf <erf-function-reference>`   | error function                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`erfc <erfc-function-reference>` | complementary error function                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`tgamma <tgamma-func-ref>`       | gamma function                                     |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`lgamma <lgamma-func-ref>`       | natural logarithm of the gamma function            |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`ceil <ceil-function-reference>` | nearest integers not less                          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`floor <floor-func-ref>`         | nearest integers not greater                       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`trunc <trunc-func-ref>`         | nearest integers not greater in magnitude          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`round <round-func-ref>`         | nearest integers, rounding away from zero          |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`nearbyint <nearbyint-func-ref>` | nearest integers using current rounding mode       |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`rint <rint-function-reference>` | nearest integers using current rounding mode       |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isfinite <isfinite-func-ref>`   | checks for finite values                           |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isinf <isinf-func-ref>`         | checks for infinite values                         |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isnan <isnan-func-ref>`         | checks for NaN values                              |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`isclose <isclose-func-ref>`     | element-wise closeness detection                   |
-+---------------------------------------+----------------------------------------------------+
-| :ref:`allclose <allclose-func-ref>`   | closeness reduction                                |
-+---------------------------------------+----------------------------------------------------+
+.. 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
 
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`sum <sum-function-reference>`           | sum of elements over given axes                                     |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`prod <prod-function-reference>`         | product of elements over given axes                                 |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`mean <mean-function-reference>`         | mean of elements over given axes                                    |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`variance <variance-function-reference>` | variance of elements over given axes                                |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`stddev <stddev-function-reference>`     | standard deviation of elements over given axes                      |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`diff <diff-function-reference>`         | Calculate the n-th discrete difference along the given axis         |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`amax <amax-function-reference>`         | amax of elements over given axes                                    |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`amin <amin-function-reference>`         | amin of elements over given axes                                    |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`trapz <trapz-function-reference>`       | Integrate along the given axis using the composite trapezoidal rule |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_l0 <norm-l0-func-ref>`             | L0 pseudo-norm over given axes                                      |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_l1 <norm-l1-func-ref>`             | L1 norm over given axes                                             |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_sq <norm-sq-func-ref>`             | Squared L2 norm over given axes                                     |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_l2 <norm-l2-func-ref>`             | L2 norm over given axes                                             |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_linf <norm-linf-func-ref>`         | Infinity norm over given axes                                       |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_lp_to_p <nlptop-func-ref>`         | p_th power of Lp norm over given axes                               |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_lp <norm-lp-func-ref>`             | Lp norm over given axes                                             |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_induced_l1 <nind-l1-ref>`          | Induced L1 norm of a matrix                                         |
-+-----------------------------------------------+---------------------------------------------------------------------+
-| :ref:`norm_induced_linf <nilinf-ref>`         | Induced L-infinity norm of a matrix                                 |
-+-----------------------------------------------+---------------------------------------------------------------------+
+.. 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
 
-+---------------------------------------------+-------------------------------------------------+
-| :ref:`cumsum <cumsum-function-reference>`   | cumulative sum of elements over a given axis    |
-+---------------------------------------------+-------------------------------------------------+
-| :ref:`cumprod <cumprod-function-reference>` | cumulative product of elements over given axes  |
-+---------------------------------------------+-------------------------------------------------+
+.. 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
 
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nan_to_num <nan-to-num-function-reference>` | convert NaN and +/- inf to finite numbers                  |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nansum <nansum-function-reference>`         | sum of elements over a given axis, replacing NaN with 0    |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nanprod <nanprod-function-reference>`       | product of elements over given axes, replacing NaN with 1  |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nancumsum <nancumsum-function-reference>`   | cumsum of elements over a given axis, replacing NaN with 0 |
-+---------------------------------------------------+------------------------------------------------------------+
-| :ref:`nancumprod <nancumprod-function-reference>` | cumprod of elements over given axes, replacing NaN with 1  |
-+---------------------------------------------------+------------------------------------------------------------+
+.. 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
index 39096ebb6..0c1f3320a 100644
--- a/docs/source/api/xnpy.rst
+++ b/docs/source/api/xnpy.rst
@@ -7,10 +7,12 @@
 xnpy: read/write NPY files
 ==========================
 
-Defined in ``xtensor/xnpy.hpp``
+Defined in ``xtensor/io/xnpy.hpp``
 
-.. doxygenfunction:: xt::load_npy
-   :project: xtensor
+.. doxygenfunction:: xt::load_npy(std::istream&)
 
-.. doxygenfunction:: xt::dump_npy
-   :project: xtensor
+.. doxygenfunction:: xt::load_npy(const std::string&)
+
+.. doxygenfunction:: xt::dump_npy(const std::string&, const xexpression<E>&)
+
+.. doxygenfunction:: xt::dump_npy(const xexpression<E>&)
diff --git a/docs/source/api/xoptional_assembly.rst b/docs/source/api/xoptional_assembly.rst
index bfdaed18d..e40d6bd9a 100644
--- a/docs/source/api/xoptional_assembly.rst
+++ b/docs/source/api/xoptional_assembly.rst
@@ -7,8 +7,7 @@
 xoptional_assembly
 ==================
 
-Defined in ``xtensor/xoptional_assembly.hpp``
+Defined in ``xtensor/optional/xoptional_assembly.hpp``
 
 .. doxygenclass:: xt::xoptional_assembly
-   :project: xtensor
    :members:
diff --git a/docs/source/api/xoptional_assembly_adaptor.rst b/docs/source/api/xoptional_assembly_adaptor.rst
index 6e2f31bd8..f58c06690 100644
--- a/docs/source/api/xoptional_assembly_adaptor.rst
+++ b/docs/source/api/xoptional_assembly_adaptor.rst
@@ -7,8 +7,7 @@
 xoptional_assembly_adaptor
 ==========================
 
-Defined in ``xtensor/xoptional_assembly.hpp``
+Defined in ``xtensor/optional/xoptional_assembly.hpp``
 
 .. doxygenclass:: xt::xoptional_assembly_adaptor
-   :project: xtensor
    :members:
diff --git a/docs/source/api/xoptional_assembly_base.rst b/docs/source/api/xoptional_assembly_base.rst
index 78978a5dc..37fa07427 100644
--- a/docs/source/api/xoptional_assembly_base.rst
+++ b/docs/source/api/xoptional_assembly_base.rst
@@ -7,8 +7,7 @@
 xoptional_assembly_base
 =======================
 
-Defined in ``xtensor/xoptional_assembly_base.hpp``
+Defined in ``xtensor/optional/xoptional_assembly_base.hpp``
 
 .. doxygenclass:: xt::xoptional_assembly_base
-   :project: xtensor
    :members:
diff --git a/docs/source/api/xpad.rst b/docs/source/api/xpad.rst
new file mode 100644
index 000000000..971a14d04
--- /dev/null
+++ b/docs/source/api/xpad.rst
@@ -0,0 +1,22 @@
+.. 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<std::vector<S>>&, pad_mode, V)
+
+.. doxygenfunction:: xt::pad(E&& , const std::vector<S>&, pad_mode, V)
+
+.. doxygenfunction:: xt::pad(E&& , S, pad_mode, V)
+
+.. doxygenfunction:: xt::tile(E&& , std::initializer_list<S>)
+
+.. doxygenfunction:: xt::tile(E&& , S)
diff --git a/docs/source/api/xrandom.rst b/docs/source/api/xrandom.rst
index 4f3be9cf5..c2040e48c 100644
--- a/docs/source/api/xrandom.rst
+++ b/docs/source/api/xrandom.rst
@@ -7,28 +7,49 @@
 xrandom
 =======
 
-Defined in ``xtensor/xrandom.hpp``
+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
-   :project: xtensor
 
 .. doxygenfunction:: xt::random::seed
-   :project: xtensor
 
 .. doxygenfunction:: xt::random::rand(const S&, T, T, E&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::random::randint(const S&, T, T, E&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::random::randn(const S&, T, T, E&)
-   :project: xtensor
 
-.. doxygenfunction:: xt::random::choice
-   :project: xtensor
+.. 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<T>&, std::size_t, bool, E&)
+.. doxygenfunction:: xt::random::choice(const xexpression<T>&, std::size_t, const xexpression<W>&, bool, E&)
 
 .. doxygenfunction:: xt::random::shuffle
-   :project: xtensor
 
 .. doxygenfunction:: xt::random::permutation(T, E&)
-   :project: xtensor
diff --git a/docs/source/api/xreducer.rst b/docs/source/api/xreducer.rst
index 1b513d4fd..4e896e099 100644
--- a/docs/source/api/xreducer.rst
+++ b/docs/source/api/xreducer.rst
@@ -7,11 +7,14 @@
 xreducer
 ========
 
-Defined in ``xtensor/xreducer.hpp``
+Defined in ``xtensor/reducers/xreducer.hpp``
 
 .. doxygenclass:: xt::xreducer
-   :project: xtensor
    :members:
 
-.. doxygenfunction:: xt::reduce(F&&, E&&, X&&, EVS)
-   :project: xtensor
+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
new file mode 100644
index 000000000..5e3db7c82
--- /dev/null
+++ b/docs/source/api/xrepeat.rst
@@ -0,0 +1,13 @@
+.. 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
index 2fdbea795..c6062cf91 100644
--- a/docs/source/api/xsemantic_base.rst
+++ b/docs/source/api/xsemantic_base.rst
@@ -7,8 +7,7 @@
 xsemantic_base
 ==============
 
-Defined in ``xtensor/xsemantic.hpp``
+Defined in ``xtensor/core/xsemantic.hpp``
 
 .. doxygenclass:: xt::xsemantic_base
-   :project: xtensor
    :members:
diff --git a/docs/source/api/xset_operation.rst b/docs/source/api/xset_operation.rst
new file mode 100644
index 000000000..14ea65cda
--- /dev/null
+++ b/docs/source/api/xset_operation.rst
@@ -0,0 +1,21 @@
+.. 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
new file mode 100644
index 000000000..72f28b2ea
--- /dev/null
+++ b/docs/source/api/xshape.rst
@@ -0,0 +1,16 @@
+.. 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
index bbaaf79a4..082532d52 100644
--- a/docs/source/api/xsort.rst
+++ b/docs/source/api/xsort.rst
@@ -7,31 +7,10 @@
 xsort
 =====
 
-Defined in ``xtensor/xsort.hpp``
+Defined in ``xtensor/misc/xsort.hpp``
 
-.. doxygenfunction:: xt::sort(const xexpression<E>&, placeholders::xtuph)
-   :project: xtensor
+.. cpp:namespace-push:: xt
 
-.. doxygenfunction:: xt::sort(const xexpression<E>&, std::ptrdiff_t)
-   :project: xtensor
+.. doxygengroup:: xt_xsort
 
-.. doxygenfunction:: xt::argsort(const xexpression<E>&, placeholders::xtuph)
-    :project: xtensor
-
-.. doxygenfunction:: xt::argsort(const xexpression<E>&, std::ptrdiff_t)
-    :project: xtensor
-
-.. doxygenfunction:: xt::argmin(const xexpression<E>&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::argmin(const xexpression<E>&, std::size_t)
-   :project: xtensor
-
-.. doxygenfunction:: xt::argmax(const xexpression<E>&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::argmax(const xexpression<E>&, std::size_t)
-   :project: xtensor
-
-.. doxygenfunction:: xt::unique(const xexpression<E>&)
-   :project: xtensor
+.. cpp:namespace-pop::
diff --git a/docs/source/api/xstrided_view.rst b/docs/source/api/xstrided_view.rst
index b169df31a..351b09da9 100644
--- a/docs/source/api/xstrided_view.rst
+++ b/docs/source/api/xstrided_view.rst
@@ -7,20 +7,15 @@
 xstrided_view
 =============
 
-Defined in ``xtensor/xstrided_view.hpp``
+Defined in ``xtensor/views/xstrided_view.hpp``
 
 .. doxygenclass:: xt::xstrided_view
-   :project: xtensor
    :members:
 
 .. doxygentypedef:: xt::xstrided_slice_vector
-   :project: xtensor
 
 .. doxygenfunction:: xt::strided_view(E&&, S&&, X&&, std::size_t, layout_type)
-   :project: xtensor
 
 .. doxygenfunction:: xt::strided_view(E&&, const xstrided_slice_vector&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::reshape_view(E&&, S&&, layout_type)
-   :project: xtensor
diff --git a/docs/source/api/xstrides.rst b/docs/source/api/xstrides.rst
new file mode 100644
index 000000000..a09540557
--- /dev/null
+++ b/docs/source/api/xstrides.rst
@@ -0,0 +1,16 @@
+.. 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
index ad7ca96bf..f896da812 100644
--- a/docs/source/api/xtensor.rst
+++ b/docs/source/api/xtensor.rst
@@ -7,14 +7,17 @@
 xtensor
 =======
 
-Defined in ``xtensor/xtensor.hpp``
+Defined in ``xtensor/containers/xtensor.hpp``
 
 .. doxygenclass:: xt::xtensor_container
-   :project: xtensor
    :members:
 
 .. doxygentypedef:: xt::xtensor
-   :project: xtensor
 
 .. doxygentypedef:: xt::xtensor_optional
-   :project: xtensor
+
+.. 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
index 26d2d0862..84e21f23e 100644
--- a/docs/source/api/xtensor_adaptor.rst
+++ b/docs/source/api/xtensor_adaptor.rst
@@ -7,31 +7,7 @@
 xtensor_adaptor
 ===============
 
-Defined in ``xtensor/xtensor.hpp``
+Defined in ``xtensor/containers/xtensor.hpp``
 
 .. doxygenclass:: xt::xtensor_adaptor
-   :project: xtensor
    :members:
-
-adapt (xtensor_adaptor)
-========================
-
-Defined in ``xtensor/xadapt.hpp``
-
-.. doxygenfunction:: xt::adapt(C&&, layout_type)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(C&&, const SC&, layout_type)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(C&&, SC&&, SS&&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(P&&, typename A::size_type, O, layout_type, const A&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(P&&, typename A::size_type, O, const SC&, layout_type, const A&)
-   :project: xtensor
-
-.. doxygenfunction:: xt::adapt(P&&, typename A::size_type, O, SC&&, SS&&, const A&)
-   :project: xtensor
diff --git a/docs/source/api/xview.rst b/docs/source/api/xview.rst
index 063d144c0..d9e72ad72 100644
--- a/docs/source/api/xview.rst
+++ b/docs/source/api/xview.rst
@@ -7,34 +7,28 @@
 xview
 =====
 
-Defined in ``xtensor/xview.hpp``
+Defined in ``xtensor/views/xview.hpp``
 
 .. doxygenclass:: xt::xview
-   :project: xtensor
-   :members:
 
 .. doxygenfunction:: xt::view
-   :project: xtensor
 
-Defined in ``xtensor/xslice.hpp``
+.. doxygenfunction:: xt::row
+
+.. doxygenfunction:: xt::col
+
+Defined in ``xtensor/views/xslice.hpp``
 
 .. doxygenfunction:: xt::range(A, B)
-   :project: xtensor
 
 .. doxygenfunction:: xt::range(A, B, C)
-   :project: xtensor
 
 .. doxygenfunction:: xt::all
-   :project: xtensor
 
 .. doxygenfunction:: xt::newaxis
-   :project: xtensor
 
 .. doxygenfunction:: xt::ellipsis
-   :project: xtensor
 
 .. doxygenfunction:: xt::keep(T&&)
-   :project: xtensor
 
 .. doxygenfunction:: xt::drop(T&&)
-   :project: xtensor
diff --git a/docs/source/api/xview_semantic.rst b/docs/source/api/xview_semantic.rst
index ad951f84f..211b27223 100644
--- a/docs/source/api/xview_semantic.rst
+++ b/docs/source/api/xview_semantic.rst
@@ -7,8 +7,7 @@
 xview_semantic
 ==============
 
-Defined in ``xtensor/xsemantic.hpp``
+Defined in ``xtensor/core/xsemantic.hpp``
 
 .. doxygenclass:: xt::xview_semantic
-   :project: xtensor
    :members:
diff --git a/docs/source/binder-logo.svg b/docs/source/binder-logo.svg
index bd8e188ee..d288b74fd 100644
--- a/docs/source/binder-logo.svg
+++ b/docs/source/binder-logo.svg
@@ -1,36 +1,36 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 <svg version="1.1" id="Layer_1"
-	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="424.236px"
-	 height="131.176px" viewBox="0 0 212.118 65.883" enable-background="new 0 0 212.118 65.883" xml:space="preserve">
-<switch>
-	<g>
-		<g>
-			<path fill="#545454" d="M50.751,48.727V12.472h7.251v17.547c1.885-2.32,4.544-3.094,7.299-3.094
-				c6.042,0,10.586,5.269,10.586,11.167S71.344,49.21,65.302,49.21c-2.755,0-5.849-0.87-7.299-3.046v2.562H50.751z M63.078,43.409
-				c2.9,0,5.076-2.514,5.076-5.317s-2.175-5.317-5.076-5.317s-5.076,2.514-5.076,5.317S60.178,43.409,63.078,43.409z"/>
-			<path fill="#545454" d="M84.35,15.855c2.32,0,4.254,1.885,4.254,4.254c0,2.32-1.934,4.254-4.254,4.254
-				c-2.369,0-4.254-1.934-4.254-4.254C80.096,17.741,81.981,15.855,84.35,15.855z M80.724,48.727V27.409h7.251v21.318H80.724z"/>
-			<path fill="#545454" d="M115.819,48.727h-7.25V36.642c0-2.514-0.967-3.867-3.239-3.867s-4.061,2.417-4.061,5.317v10.635h-7.251
-				V27.409h7.251v2.61c1.45-1.837,3.722-3.094,6.526-3.094c5.704,0,8.024,3.916,8.024,9.716V48.727z"/>
-			<path fill="#545454" d="M144.826,48.727h-7.251v-2.562c-1.45,2.176-4.592,3.046-7.299,3.046c-6.043,0-10.587-5.221-10.587-11.118
-				s4.544-11.167,10.587-11.167c2.707,0,5.414,0.773,7.299,3.094V12.472h7.251V48.727z M132.499,32.774
-				c-2.9,0-5.075,2.514-5.075,5.317s2.175,5.317,5.075,5.317s5.076-2.514,5.076-5.317S135.399,32.774,132.499,32.774z"/>
-			<path fill="#545454" d="M173.639,38.962h-16.532c0,2.466,1.74,5.075,4.592,5.075c2.562,0,4.158-1.691,4.206-3.238h7.396
-				c-1.256,5.607-5.801,8.411-11.456,8.411c-7.348,0-12.423-4.351-12.423-11.118c0-6.671,5.269-11.167,12.423-11.167
-				c6.478,0,11.843,3.867,11.843,10.683C173.687,38.043,173.639,38.527,173.639,38.962z M166.726,35.53c0,0-0.338-3.964-4.736-3.964
-				c-4.545,0-4.786,3.964-4.786,3.964H166.726z"/>
-			<path fill="#545454" d="M185.532,38.092v10.635h-7.251V27.409h7.251v2.61c1.111-1.595,2.949-3.094,5.607-3.094
-				c0.629,0,1.596,0.193,2.176,0.483v6.574h-0.098c-0.725-0.87-1.788-1.208-2.9-1.208C187.61,32.774,185.532,35.53,185.532,38.092z"
-				/>
-		</g>
-		<circle fill="none" stroke="#F5A252" stroke-width="4.8342" stroke-miterlimit="10" cx="27.879" cy="23.939" r="9.542"/>
-		<circle fill="none" stroke="#579ACA" stroke-width="4.8342" stroke-miterlimit="10" cx="27.879" cy="42.499" r="9.543"/>
-		<circle fill="none" stroke="#E66581" stroke-width="4.8342" stroke-miterlimit="10" cx="18.551" cy="33.289" r="9.543"/>
-		<path fill="none" stroke="#579ACA" stroke-width="4.8342" stroke-miterlimit="10" d="M20.196,36.836
-			c0.759-1.031,1.74-1.927,2.921-2.607c4.566-2.63,10.401-1.06,13.031,3.507"/>
-		<path fill="none" stroke="#F5A252" stroke-width="4.8342" stroke-miterlimit="10" d="M19.61,28.701
-			c-2.63-4.566-1.061-10.401,3.507-13.032c4.567-2.63,10.401-1.059,13.031,3.508"/>
-	</g>
-</switch>
-</svg>
+     xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="424.236px"
+     height="131.176px" viewBox="0 0 212.118 65.883" enable-background="new 0 0 212.118 65.883" xml:space="preserve">
+<switch>
+    <g>
+        <g>
+            <path fill="#545454" d="M50.751,48.727V12.472h7.251v17.547c1.885-2.32,4.544-3.094,7.299-3.094
+                c6.042,0,10.586,5.269,10.586,11.167S71.344,49.21,65.302,49.21c-2.755,0-5.849-0.87-7.299-3.046v2.562H50.751z M63.078,43.409
+                c2.9,0,5.076-2.514,5.076-5.317s-2.175-5.317-5.076-5.317s-5.076,2.514-5.076,5.317S60.178,43.409,63.078,43.409z"/>
+            <path fill="#545454" d="M84.35,15.855c2.32,0,4.254,1.885,4.254,4.254c0,2.32-1.934,4.254-4.254,4.254
+                c-2.369,0-4.254-1.934-4.254-4.254C80.096,17.741,81.981,15.855,84.35,15.855z M80.724,48.727V27.409h7.251v21.318H80.724z"/>
+            <path fill="#545454" d="M115.819,48.727h-7.25V36.642c0-2.514-0.967-3.867-3.239-3.867s-4.061,2.417-4.061,5.317v10.635h-7.251
+                V27.409h7.251v2.61c1.45-1.837,3.722-3.094,6.526-3.094c5.704,0,8.024,3.916,8.024,9.716V48.727z"/>
+            <path fill="#545454" d="M144.826,48.727h-7.251v-2.562c-1.45,2.176-4.592,3.046-7.299,3.046c-6.043,0-10.587-5.221-10.587-11.118
+                s4.544-11.167,10.587-11.167c2.707,0,5.414,0.773,7.299,3.094V12.472h7.251V48.727z M132.499,32.774
+                c-2.9,0-5.075,2.514-5.075,5.317s2.175,5.317,5.075,5.317s5.076-2.514,5.076-5.317S135.399,32.774,132.499,32.774z"/>
+            <path fill="#545454" d="M173.639,38.962h-16.532c0,2.466,1.74,5.075,4.592,5.075c2.562,0,4.158-1.691,4.206-3.238h7.396
+                c-1.256,5.607-5.801,8.411-11.456,8.411c-7.348,0-12.423-4.351-12.423-11.118c0-6.671,5.269-11.167,12.423-11.167
+                c6.478,0,11.843,3.867,11.843,10.683C173.687,38.043,173.639,38.527,173.639,38.962z M166.726,35.53c0,0-0.338-3.964-4.736-3.964
+                c-4.545,0-4.786,3.964-4.786,3.964H166.726z"/>
+            <path fill="#545454" d="M185.532,38.092v10.635h-7.251V27.409h7.251v2.61c1.111-1.595,2.949-3.094,5.607-3.094
+                c0.629,0,1.596,0.193,2.176,0.483v6.574h-0.098c-0.725-0.87-1.788-1.208-2.9-1.208C187.61,32.774,185.532,35.53,185.532,38.092z"
+                />
+        </g>
+        <circle fill="none" stroke="#F5A252" stroke-width="4.8342" stroke-miterlimit="10" cx="27.879" cy="23.939" r="9.542"/>
+        <circle fill="none" stroke="#579ACA" stroke-width="4.8342" stroke-miterlimit="10" cx="27.879" cy="42.499" r="9.543"/>
+        <circle fill="none" stroke="#E66581" stroke-width="4.8342" stroke-miterlimit="10" cx="18.551" cy="33.289" r="9.543"/>
+        <path fill="none" stroke="#579ACA" stroke-width="4.8342" stroke-miterlimit="10" d="M20.196,36.836
+            c0.759-1.031,1.74-1.927,2.921-2.607c4.566-2.63,10.401-1.06,13.031,3.507"/>
+        <path fill="none" stroke="#F5A252" stroke-width="4.8342" stroke-miterlimit="10" d="M19.61,28.701
+            c-2.63-4.566-1.061-10.401,3.507-13.032c4.567-2.63,10.401-1.059,13.031,3.508"/>
+    </g>
+</switch>
+</svg>
diff --git a/docs/source/bindings.rst b/docs/source/bindings.rst
new file mode 100644
index 000000000..54a2a09f0
--- /dev/null
+++ b/docs/source/bindings.rst
@@ -0,0 +1,286 @@
+.. 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 <class E>
+    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 <class E>
+    void compute(const xexpression<E>& 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 <class E>
+    void compute(xexpression<E>& e);
+
+    template <class E>
+    void compute(xexpression<E>&& 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<pytensor<double, 2>>);
+    }
+
+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 <class E>
+        void compute_impl(E&&);
+    }
+
+    template <class T>
+    void compute(const xtensor<T, 2>& t)
+    {
+        detail::compute_impl(t);
+    }
+
+Exposing it to the Python is just as simple:
+
+.. code::
+
+    template <class T>
+    void compute(const pytensor<T, 2>& t)
+    {
+        detail::compute_impl(t);
+    }
+
+    PYBIND11_MODULE(pymod, m)
+    {
+        xt::import_numpy();
+
+        m.def("compute", &compute<double>);
+    }
+
+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 <class C, class T, std::size_t N>
+    struct tensor_container;
+
+    // Specialization for xtensor library (or C++)
+    template <class T, std::size_t N>
+    struct tensor_container<xtensor_c, T, N>
+    {
+        using type = xt::xtensor<T, N>;
+    };
+
+    template <class C, class T, std::size_t N>
+    using tensor_container_t = typename tensor_container<C, T, N>::type;
+
+The function signature then becomes
+
+.. code::
+
+    template <class T, class C = xtensor_c>
+    void compute(const tensor_container_t<C, T, 2>& t);
+
+The Python bindings only require that we specialize the ``tensor_container`` structure
+
+.. code::
+
+    struct pytensor_c
+    {
+    };
+
+    template <class T, std::size_t N>
+    struct tensor_container<pytensor_c, T, N>
+    {
+        using type = pytensor<T, N>;
+    };
+
+    PYBIND11_MODULE(pymod, m)
+    {
+        xt::import_numpy();
+
+        m.def("compute", &compute<double, pytensor_c>);
+    }
+
+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<double, 2> t {{1., 2., 3.}, {4., 5., 6.}};
+
+    compute<double>(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 <class C, class T>
+    struct array_container;
+
+    template <class C, class T>
+    struct array_container<xtensor_c, T>
+    {
+        using type = xt::xarray<T>;
+    };
+
+    template <class C, class T>
+    using array_container_t = typename array_container<C, T>::type;
+
+    template <class T, class C = xtensor_c>
+    void compute(const array_container_t<C, 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 <class C>
+    struct is_tensor : std::false_type
+    {
+    };
+
+    template <class T, std::size_t N, layout_type L, class Tag>
+    struct is_tensor<xtensor<T, N, L, Tag>> : std::true_type
+    {
+    };
+
+    template <class T, template <class> class C = is_tensor,
+              std::enable_if_t<C<T>::value, bool> = true>
+    void compute(const T& t);
+
+Here when ``C<T>::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 <template<class> class C, class T>
+    using check_constraints = std::enable_if_t<C<T>::value, bool>;
+    template <class T, template <class> class C = is_tensor,
+              check_constraints<C, T> = 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<T>::value || is_array<T>::value
+    template <class T>
+    struct is_container : xtl::disjunction<is_tensor<T>, is_array<T>>
+    {
+    };
+
+    template <class T, template <class> class C = is_container,
+              check_constraints<C, T> = 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 <class T, std::size_t N, layout_type L>
+    struct is_tensor<pytensor<T, N, L>> : std::true_type
+    {
+    };
+
+    PYBIND11_MODULE(pymod, m)
+    {
+        xt::import_numpy();
+
+        m.def("compute", &compute<pytensor<double, 2>>);
+    }
+
+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
index 5dbeaec3f..25e32ceb9 100644
--- a/docs/source/build-options.rst
+++ b/docs/source/build-options.rst
@@ -4,70 +4,120 @@
 
    The full license is in the file LICENSE, distributed with this software.
 
+.. _build-configuration:
+
 Build and configuration
 =======================
 
-Build
------
+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`` build supports the following options:
+- ``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.
 
-- ``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
+.. _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.
 
-All these options are disabled by default. Enabling ``DOWNLOAD_GTEST`` or
-setting ``GTEST_SRC_DIR`` enables ``BUILD_TESTS``.
+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:
 
-If the ``BUILD_TESTS`` option is enabled, the following targets are available:
+.. code:: cmake
 
-- xtest: builds an run the test suite.
-- xbenchmark: builds and runs the benchmarks.
+    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)
 
-For instance, building the test suite of ``xtensor`` with assertions enabled:
+    # the target now sets the proper defines (e.g. "XTENSOR_USE_XSIMD")
+    target_link_libraries(... xtensor)
 
-.. code::
 
-    mkdir build
-    cd build
-    cmake -DBUILD_TESTS=ON -DXTENSOR_ENABLE_ASSERT=ON ../
-    make xtest
+Build and optimization
+----------------------
 
-Building the test suite of ``xtensor`` where the sources of ``gtest`` are
-located in e.g. ``/usr/share/gtest``:
+Windows
+~~~~~~~
 
-.. code::
+Windows users must activate the ``/bigobj`` flag, otherwise it's almost certain that the compilation fails. More generally,
+the following options are recommended:
 
-    mkdir build
-    cd build
-    cmake -DGTEST_SRC_DIR=/usr/share/gtest ../
-    make xtest
+.. code:: cmake
 
-.. _configuration-label:
+    target_link_libraries(... xtensor xtensor::optimize)
+    set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
 
-Configuration
--------------
+    # OR
 
-``xtensor`` can be configured via macros, which must be defined *before*
-including any of its header. Here is a list of available macros:
+    target_compile_options(target_name PRIVATE /EHsc /MP /bigobj)
+    set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
 
-- ``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_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.
+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/QuantStack/xsimd
+.. _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
index 4872b61bc..04b193def 100644
--- a/docs/source/builder.rst
+++ b/docs/source/builder.rst
@@ -7,45 +7,76 @@
 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.
+*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
 --------------
 
-- ``zeros(shape)``: generates an expression containing zeros of the specified shape.
-- ``ones(shape)``: generates an expression containing ones of the specified shape.
-- ``eye(shape, k=0)``: generates an expression of the specified shape, with ones on the k-th diagonal.
-- ``eye(n, k = 0)``: generates an expression with ones on the k-th diagonal.
+- :cpp:func:`xt::zeros(shape) <xt::zeros>`: generates an expression containing zeros of the specified shape.
+- :cpp:func:`xt::ones(shape) <xt::ones>`: generates an expression containing ones of the specified shape.
+- :cpp:func:`xt::eye(shape, k=0) <xt::eye>`: generates an expression of the specified shape, with ones on the k-th diagonal.
+- :cpp:func:`xt::eye(n, k = 0) <xt::eye>`: generates an expression of shape ``(n, n)`` with ones on the k-th diagonal.
 
 Numerical ranges
 ----------------
 
-- ``arange(start=0, stop, step=1)``: generates numbers evenly spaced within given half-open interval.
-- ``linspace(start, stop, num_samples)``: generates num_samples evenly spaced numbers over given interval.
-- ``logspace(start, stop, num_samples)``: generates num_samples evenly spaced on a log scale over given interval
+- :cpp:func:`xt::arange(start=0, stop, step=1) <xt::arange>`: generates numbers evenly spaced within given half-open interval.
+- :cpp:func:`xt::linspace(start, stop, num_samples) <xt::linspace>`: generates num_samples evenly spaced numbers over given interval.
+- :cpp:func:`xt::logspace(start, stop, num_samples) <xt::logspace>`: generates num_samples evenly spaced on a log scale over given interval
 
 Joining expressions
 -------------------
 
-- ``concatenate(tuple, axis=0)``: concatenates a list of expressions along the given axis.
-- ``stack(tuple, axis=0)``: stacks a list of expressions along the given axis.
+- :cpp:func:`xt::concatenate(tuple, axis=0) <xt::concatenate>`: concatenates a list of expressions along the given axis.
+- :cpp:func:`xt::stack(tuple, axis=0) <xt::stack>`: stacks a list of expressions along the given axis.
+- :cpp:func:`xt::hstack(tuple) <xt::hstack>`: stacks expressions in sequence horizontally (i.e. column-wise).
+- :cpp:func:`xt::vstack(tuple) <xt::vstack>`: stacks expressions in sequence vertically (i.e. row wise).
 
 Random distributions
 --------------------
 
-- ``rand(shape, lower, upper)``: generates an expression of the specified shape, containing uniformly
-  distributed random numbers in the half-open interval [lower, upper).
-- ``randint(shape, lower, upper)``: generates an expression of the specified shape, containing uniformly
-  distributed random integers in the half-open interval [lower, upper).
-- ``randn(shape, mean, std_dev)``: generates an expression of the specified shape, containing numbers
-  sampled from the Normal random number distribution.
+.. 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) <xt::random::rand>`: 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) <xt::random::randint>`: 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) <xt::random::randn>`: generates an expression of the specified
+  shape, containing numbers sampled from the Normal random number distribution.
+- :cpp:func:`xt::random::binomial(shape, trials, prob) <xt::random::binomial>`: generates an expression of the specified
+  shape, containing numbers sampled from the binomial random number distribution.
+- :cpp:func:`xt::random::geometric(shape, prob) <xt::random::geometric>`: 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) <xt::random::negative_binomial>`: generates an expression
+  of the specified shape, containing numbers sampled from the negative binomial random number distribution.
+- :cpp:func:`xt::random::poisson(shape, rate) <xt::random::poisson>`: generates an expression of the specified shape,
+  containing numbers sampled from the Poisson random number distribution.
+- :cpp:func:`xt::random::exponential(shape, rate) <xt::random::exponential>`: generates an expression of the specified
+  shape, containing numbers sampled from the exponential random number distribution.
+- :cpp:func:`xt::random::gamma(shape, alpha, beta) <xt::random::gamma>`: generates an expression of the specified shape,
+  containing numbers sampled from the gamma random number distribution.
+- :cpp:func:`xt::random::weibull(shape, a, b) <xt::random::weibull>`: 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) <xt::random::extreme_value>`: 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) <xt::random::lognormal>`: 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) <xt::random::chi_squared>`: 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) <xt::random::cauchy>`: 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) <xt::random::fisher_f>`: 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) <xt::random::student_t>`: generates an expression of the specified shape,
+  containing numbers sampled from the Student-t random number distribution.
 
 Meshes
 ------
 
-- ``meshgrid(x1, x2,...)```: generates N-D coordinate expressions given one-dimensional coordinate arrays ``x1``, ``x2``...
+- :cpp:func:`xt::meshgrid(x1, x2,...) <xt::meshgrid>`: 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
index 82df393f4..982773051 100644
--- a/docs/source/changelog.rst
+++ b/docs/source/changelog.rst
@@ -7,43 +7,1487 @@
 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 <https://github.com/xtensor-stack/xtensor/pull/2283>`_
+- Upgraded to xtl 0.7.0
+  `#2284 <https://github.com/xtensor-stack/xtensor/pull/2284>`_
+
+Other changes
+~~~~~~~~~~~~~
+
+- Harmonize #include statements in doc
+  `#2280 <https://github.com/xtensor-stack/xtensor/pull/2280>`_
+- Added missing shape_type in xfunctor_stepper
+  `#2285 <https://github.com/xtensor-stack/xtensor/pull/2285>`_
+
+0.22.0
+------
+
+Breaking changes
+~~~~~~~~~~~~~~~~
+
+- Drop support of 3.* Clang versions
+  `#2251 <https://github.com/xtensor-stack/xtensor/pull/2251>`_
+- Fix reducers assignment
+  `#2254 <https://github.com/xtensor-stack/xtensor/pull/2254>`_
+- Removed reducer ``big_promote_type``
+  `#2277 <https://github.com/xtensor-stack/xtensor/pull/2277>`_
+
+Other changes
+~~~~~~~~~~~~~
+
+- Improve histogram performance with equal bin sizes
+  `#2088 <https://github.com/xtensor-stack/xtensor/pull/2088>`_
+- Added missing header in xfixed
+  `#2225 <https://github.com/xtensor-stack/xtensor/pull/2225>`_
+- Implement xt::random::choice with weights vector
+  `#2241 <https://github.com/xtensor-stack/xtensor/pull/2241>`_
+- Testing alignment
+  `#2246 <https://github.com/xtensor-stack/xtensor/pull/2246>`_
+- Add reducers tests
+  `#2252 <https://github.com/xtensor-stack/xtensor/pull/2252>`_
+- Fix binary operators on complex
+  `#2253 <https://github.com/xtensor-stack/xtensor/pull/2253>`_
+- Removed not implemented assign method from xchunked_array
+  `#2256 <https://github.com/xtensor-stack/xtensor/pull/2256>`_
+- Support initialized list for chunked_array shapes
+  `#2258 <https://github.com/xtensor-stack/xtensor/pull/2258>`_
+- Add as_strided free function
+  `#2261 <https://github.com/xtensor-stack/xtensor/pull/2261>`_
+- Fix histogram compatibility with containers beyond xtensor
+  `#2263 <https://github.com/xtensor-stack/xtensor/pull/2263>`_
+- Fixed broadcasting with keep_slice that holds a single element
+  `#2270 <https://github.com/xtensor-stack/xtensor/pull/2270>`_
+- Make xt::cast and xtl::optional compatible
+  `#2271 <https://github.com/xtensor-stack/xtensor/pull/2271>`_
+- Fix minor warnings detected by clang
+  `#2272 <https://github.com/xtensor-stack/xtensor/pull/2272>`_
+- Extra assert in mean computation wrt. ddof
+  `#2273 <https://github.com/xtensor-stack/xtensor/pull/2273>`_
+- Provide a -Werror mode and ensure xtensor passes with it
+  `#2274 <https://github.com/xtensor-stack/xtensor/pull/2274>`_
+- Moved layout_remove_any to xlayout.hpp
+  `#2275 <https://github.com/xtensor-stack/xtensor/pull/2275>`_
+- Provide a -Werror mode and ensure xtensor passes with it
+  `#2274 <https://github.com/xtensor-stack/xtensor/pull/2274>`_
+- Slight reorganization of the documentation
+  `#2276 <https://github.com/xtensor-stack/xtensor/pull/2276>`_
+- Updated reducer docs according to recent changes
+  `#2278 <https://github.com/xtensor-stack/xtensor/pull/2278>`_
+- Added template parameter for initial value type in accumulators
+  `#2279 <https://github.com/xtensor-stack/xtensor/pull/2279>`_
+
+0.21.10
+-------
+
+- Document chunked arrays
+  `#2102 <https://github.com/xtensor-stack/xtensor/pull/2102>`_
+- Removed ``zarray`` files
+  `#2221 <https://github.com/xtensor-stack/xtensor/pull/2221>`_
+- Improved ``xeval``
+  `#2223 <https://github.com/xtensor-stack/xtensor/pull/2223>`_
+- Fixed various warnings
+  `#2224 <https://github.com/xtensor-stack/xtensor/pull/2224>`_
+
+0.21.9
+------
+
+- Adding macro ``XTENSOR_SELECT_ALIGN``
+  `#2152 <https://github.com/xtensor-stack/xtensor/pull/2152>`_
+- xcontainer.hpp: Renamed a shadowing type name inside a function
+  `#2208 <https://github.com/xtensor-stack/xtensor/pull/2208>`_
+- Add chunk_memory_layout to chunked_array factory
+  `#2211 <https://github.com/xtensor-stack/xtensor/pull/2211>`_
+- CMake: Modernized GTest-integration
+  `#2212 <https://github.com/xtensor-stack/xtensor/pull/2212>`_
+- ``xnpy.hpp``: fix multiple definition of 'host_endian_char' variable when included in different linked objects
+  `#2214 <https://github.com/xtensor-stack/xtensor/pull/2214>`_
+- Made global variable const to force internal linkage
+  `#2216 <https://github.com/xtensor-stack/xtensor/pull/2216>`_
+- Use xtl::endianness instead of bundling it
+  `#2218 <https://github.com/xtensor-stack/xtensor/pull/2218>`_
+- Fix call to resize of chunk container
+  `#2219 <https://github.com/xtensor-stack/xtensor/pull/2219>`_
+
+0.21.8
+------
+
+- Fix undefined behavior while testing shifts
+  `#2175 <https://github.com/xtensor-stack/xtensor/pull/2175>`_
+- Fix ``zarray`` initialization from ``zarray``
+  `#2180 <https://github.com/xtensor-stack/xtensor/pull/2180>`_
+- Portable and generic implementation of endianess detection
+  `#2182 <https://github.com/xtensor-stack/xtensor/pull/2182>`_
+- Fix xnpy save padding computation
+  `#2183 <https://github.com/xtensor-stack/xtensor/pull/2183>`_
+- Only use ``-march=native`` if it's available
+  `#2184 <https://github.com/xtensor-stack/xtensor/pull/2184>`_
+- Fix ``xchunked_array`` assignment
+  `#2177 <https://github.com/xtensor-stack/xtensor/pull/2177>`_
+- Add specific ``xchunked_array`` constructor for ``xchunk_store_manager``
+  `#2188 <https://github.com/xtensor-stack/xtensor/pull/2188>`_
+- Make xnpy tests aware of both little and big endian targets
+  `#2189 <https://github.com/xtensor-stack/xtensor/pull/2189>`_
+- Fixed constructors of ``xchunked_array``
+  `#2190 <https://github.com/xtensor-stack/xtensor/pull/2190>`_
+- First implementation of ``zchunked_wrapper``
+  `#2193 <https://github.com/xtensor-stack/xtensor/pull/2193>`_
+- Don't mark dirty a resized or reshaped ``xfile_array``
+  `#2194 <https://github.com/xtensor-stack/xtensor/pull/2194>`_
+- Replaced catch-all constructor of ``zarray`` with more restrictive ones
+  `#2195 <https://github.com/xtensor-stack/xtensor/pull/2195>`_
+- Fixed SFINAE based on ``xchunked_store_manager``
+  `#2197 <https://github.com/xtensor-stack/xtensor/pull/2197>`_
+- Fix generated cmake config to include missing required lib
+  `#2200 <https://github.com/xtensor-stack/xtensor/pull/2200>`_
+- Add ``set_chunk_shape`` to the first chunk of the pool
+  `#2198 <https://github.com/xtensor-stack/xtensor/pull/2198>`_
+- Chunked array refactoring
+  `#2201 <https://github.com/xtensor-stack/xtensor/pull/2201>`_
+- Refactored ``xchunked_array`` semantic
+  `#2202 <https://github.com/xtensor-stack/xtensor/pull/2202>`_
+- Added missing header to CMakeLists.txt
+  `#2203 <https://github.com/xtensor-stack/xtensor/pull/2203>`_
+- Fixed ``load_simd`` for ``xcomplex``
+  `#2204 <https://github.com/xtensor-stack/xtensor/pull/2204>`_
+- Upgraded to xtl 0.6.20
+  `#2206 <https://github.com/xtensor-stack/xtensor/pull/2206>`_
+- changed std traits to new ``xtl::xtraits``
+  `#2205 <https://github.com/xtensor-stack/xtensor/pull/2205>`_
+- ``xstorage.hpp``: Renamed a shadowing variable inside a function
+  `#2207 <https://github.com/xtensor-stack/xtensor/pull/2207>`_
+
+0.21.7
+------
+
+- Removed zheaders from single header
+  `#2157 <https://github.com/xtensor-stack/xtensor/pull/2157>`_
+- Implemented insertion of range and intializer list in svector
+  `#2165 <https://github.com/xtensor-stack/xtensor/pull/2165>`_
+- Adding has_shape
+  `#2163 <https://github.com/xtensor-stack/xtensor/pull/2163>`_
+- Adding get_rank and has_fixed_rank
+  `#2162 <https://github.com/xtensor-stack/xtensor/pull/2162>`_
+- Zrefactoring
+  `#2140 <https://github.com/xtensor-stack/xtensor/pull/2140>`_
+- Added missing header
+  `#2169 <https://github.com/xtensor-stack/xtensor/pull/2169>`_
+- Extending docs random
+  `#2173 <https://github.com/xtensor-stack/xtensor/pull/2173>`_
+
+0.21.6
+------
+
+- Added implementation of ``isin`` and ``in1d``
+  `#2021 <https://github.com/xtensor-stack/xtensor/pull/2021>`_
+- Wrote single include header
+  `#2031 <https://github.com/xtensor-stack/xtensor/pull/2031>`_
+- Added details for ``xt::random`` to docs
+  `#2043 <https://github.com/xtensor-stack/xtensor/pull/2043>`_
+- Added ``digitize``, ``searchsorted``, and ``bin_items``
+  `#2037 <https://github.com/xtensor-stack/xtensor/pull/2037>`_
+- Fixed error with zero tensor size in ``xt::mean``
+  `#2047 <https://github.com/xtensor-stack/xtensor/pull/2047>`_
+- Fixed initialization order in ``xfunction``
+  `#2050 <https://github.com/xtensor-stack/xtensor/pull/2050>`_
+- ``adapt_smart_ptr`` overloads now accept STL-like container as shape
+  `#2052 <https://github.com/xtensor-stack/xtensor/pull/2052>`_
+- Added ``xchunked_array``
+  `#2076 <https://github.com/xtensor-stack/xtensor/pull/2076>`_
+- ``xchunked_array`` inherits from ``xiterable``
+  `#2082 <https://github.com/xtensor-stack/xtensor/pull/2082>`_
+- ``xchunked_array`` inherits from ``xcontainer_semantic``
+  `#2083 <https://github.com/xtensor-stack/xtensor/pull/2083>`_
+- Fixed assignment operator of ``xchunked_array``
+  `#2084 <https://github.com/xtensor-stack/xtensor/pull/2084>`_
+- Added constructors from ``xexpression`` and ``chunk_shape`` to ``xchunked_array``
+  `#2087 <https://github.com/xtensor-stack/xtensor/pull/2087>`_
+- Fixed chunk layout
+  `#2091 <https://github.com/xtensor-stack/xtensor/pull/2091>`_
+- Copy constructor gets expression's chunk_shape if it is chunked
+  `#2092 <https://github.com/xtensor-stack/xtensor/pull/2092>`_
+- Replaced template parameter chunk_type with chunk_storage
+  `#2095 <https://github.com/xtensor-stack/xtensor/pull/2095>`_
+- Implemented on-disk chunked array
+  `#2096 <https://github.com/xtensor-stack/xtensor/pull/2096>`_
+- Implemented chunk pool in xchunk_store_manager
+  `#2099 <https://github.com/xtensor-stack/xtensor/pull/2099>`_
+- ``xfile_array`` is now an expression
+  `#2107 <https://github.com/xtensor-stack/xtensor/pull/2107>`_
+- ``xchunked_array`` code cleanup
+  `#2109 <https://github.com/xtensor-stack/xtensor/pull/2109>`_
+- ``xchunked_store_manager`` code cleanup
+  `#2110 <https://github.com/xtensor-stack/xtensor/pull/2110>`_
+- Refactored ``xfile_array``
+  `#2117 <https://github.com/xtensor-stack/xtensor/pull/2117>`_
+- Added simd accessors to ``xfil_array_container``
+  `#2118 <https://github.com/xtensor-stack/xtensor/pull/2118>`_
+- Abstracted file format through a formal class
+  `#2115 <https://github.com/xtensor-stack/xtensor/pull/2115>`_
+- Added ``xchunked_array`` extension template
+  `#2122 <https://github.com/xtensor-stack/xtensor/pull/2122>`_
+- Refactored ``xdisk_io_handler``
+  `#2123 <https://github.com/xtensor-stack/xtensor/pull/2123>`_
+- Fixed exception for file write operation
+  `#2125 <https://github.com/xtensor-stack/xtensor/pull/2125>`_
+- Implemented ``zarray``
+  `#2127 <https://github.com/xtensor-stack/xtensor/pull/2127>`_
+- Implemented the skeleton of the dynamic expression system
+  `#2129 <https://github.com/xtensor-stack/xtensor/pull/2129>`_
+- Implemented zfunctions, equivalent of xfunction for dynamic expression system
+  `#2130 <https://github.com/xtensor-stack/xtensor/pull/2130>`_
+- Implemented ``allocate_result`` in ``zfunction``
+  `#2132 <https://github.com/xtensor-stack/xtensor/pull/2132>`_
+- Implemented assign mechanism for ``zarray``
+  `#2133 <https://github.com/xtensor-stack/xtensor/pull/2133>`_
+- Added xindex_path to transform indexes into path
+  `#2131 <https://github.com/xtensor-stack/xtensor/pull/2131>`_
+- Fixing various compiler warnings
+  `#2145 <https://github.com/xtensor-stack/xtensor/pull/2145>`_
+- Removed conversion and initialization warnings
+  `#2141 <https://github.com/xtensor-stack/xtensor/pull/2141>`_
+
+0.21.5
+------
+
+- Fix segfault when using ``xt::drop`` on an empty list of indices
+  `#1990 <https://github.com/xtensor-stack/xtensor/pull/1990>`_
+- Implemented missing methods in ``xrepeat`` class
+  `#1993 <https://github.com/xtensor-stack/xtensor/pull/1993>`_
+- Added extension base to ``xrepeat`` and clean up ``xbroadcast``
+  `#1994 <https://github.com/xtensor-stack/xtensor/pull/1994>`_
+- Fix return type of ``nanmean`` and add unittest
+  `#1996 <https://github.com/xtensor-stack/xtensor/pull/1996>`_
+- Add result type template argument for ``stddev``, ``variance``, ``nanstd`` and ``nanvar``
+  `#1999 <https://github.com/xtensor-stack/xtensor/pull/1999>`_
+- Fix variance overload
+  `#2002 <https://github.com/xtensor-stack/xtensor/pull/2002>`_
+- Added missing ``xaxis_slice_iterator`` header to CMakeLists.txt
+  `#2009 <https://github.com/xtensor-stack/xtensor/pull/2009>`_
+- Fixed xview on const keep and const drop slices
+  `#2010 <https://github.com/xtensor-stack/xtensor/pull/2010>`_
+- Added ``static_assert`` to ``adapt`` methods
+  `#2015 <https://github.com/xtensor-stack/xtensor/pull/2015>`_
+- Removed allocator deprecated calls
+  `#2018 <https://github.com/xtensor-stack/xtensor/pull/2018>`_
+- Added missing overload of ``push_back`` to ``svector``
+  `#2024 <https://github.com/xtensor-stack/xtensor/pull/2024>`_
+- Initialized all members of ``xfunciton_cache_impl``
+  `#2026 <https://github.com/xtensor-stack/xtensor/pull/2026>`_
+
+0.21.4
+------
+
+- Fix warning -Wsign-conversion in ``xview``
+  `#1902 <https://github.com/xtensor-stack/xtensor/pull/1902>`_
+- Fixed issue due to thread_local storage on some architectures
+  `#1905 <https://github.com/xtensor-stack/xtensor/pull/1905>`_
+- benchmark/CMakeLists.txt: fixed a tiny spelling mistake
+  `#1904 <https://github.com/xtensor-stack/xtensor/pull/1904>`_
+- nd-iterator implementation
+  `#1891 <https://github.com/xtensor-stack/xtensor/pull/1891>`_
+- Add GoatCounter analytics for the documentation
+  `#1908 <https://github.com/xtensor-stack/xtensor/pull/1908>`_
+- Added ``noexcept`` in ``svector``
+  `#1919 <https://github.com/xtensor-stack/xtensor/pull/1919>`_
+- Add implementation of repeat (similar to NumPy)
+  `#1896 <https://github.com/xtensor-stack/xtensor/pull/1896>`_
+- Fix initialization of out shape in ``xt::tile``
+  `#1923 <https://github.com/xtensor-stack/xtensor/pull/1923>`_
+- ``xaxis_slice_iterator`` – Iterates over 1D slices oriented along the specified axis
+  `#1916 <https://github.com/xtensor-stack/xtensor/pull/1916>`_
+- Fixed cxx11 lib guard
+  `#1925 <https://github.com/xtensor-stack/xtensor/pull/1925>`_
+- Fixed CXX11 ABI when _GLIBCXX_USE_DUAL_ABI is set to 0
+  `#1927 <https://github.com/xtensor-stack/xtensor/pull/1927>`_
+- Enabling array-bounds warning
+  `#1933 <https://github.com/xtensor-stack/xtensor/pull/1933>`_
+- Fixed warnings
+  `#1934 <https://github.com/xtensor-stack/xtensor/pull/1934>`_
+- Compile with g++ instead of gcc, clarify include directories
+  `#1938 <https://github.com/xtensor-stack/xtensor/pull/1938>`_
+- broadcast function now accepts fixed shapes
+  `#1939 <https://github.com/xtensor-stack/xtensor/pull/1939>`_
+- Don't print decimal point after ``inf`` or ``nan``
+  `#1940 <https://github.com/xtensor-stack/xtensor/pull/1940>`_
+- Improved performance of ``xt::tile``
+  `#1943 <https://github.com/xtensor-stack/xtensor/pull/1943>`_
+- Refactoring CI
+  `#1942 <https://github.com/xtensor-stack/xtensor/pull/1942>`_
+- Documentation build: Switched to channel QuantStack
+  `#1948 <https://github.com/xtensor-stack/xtensor/pull/1948>`_
+- Removed warnings due to gtest upgrade
+  `#1949 <https://github.com/xtensor-stack/xtensor/pull/1949>`_
+- Fixed flatten view of view
+  `#1950 <https://github.com/xtensor-stack/xtensor/pull/1950>`_
+- Improved narrative documentation of reducers
+  `#1958 <https://github.com/xtensor-stack/xtensor/pull/1958>`_
+- Add test for printing xarray of type ``size_t``
+  `#1947 <https://github.com/xtensor-stack/xtensor/pull/1947>`_
+- Added documentation for iterators
+  `#1961 <https://github.com/xtensor-stack/xtensor/pull/1961>`_
+- Fixed ``check_element_index`` behavior for 0-D expressions
+  `#1965 <https://github.com/xtensor-stack/xtensor/pull/1965>`_
+- Fixed ``element`` method of xreducer
+  `#1966 <https://github.com/xtensor-stack/xtensor/pull/1966>`_
+- Fixed ``cast`` for third-party types
+  `#1967 <https://github.com/xtensor-stack/xtensor/pull/1967>`_
+- fix ``xoperation``
+  `#1790 <https://github.com/xtensor-stack/xtensor/pull/1790>`_
+- Added installation instruction with MinGW
+  `#1969 <https://github.com/xtensor-stack/xtensor/pull/1969>`_
+- ``xrepeat`` now stores ``const_xclosure_t<E>`` instead of ``E``
+  `#1968 <https://github.com/xtensor-stack/xtensor/pull/1968>`_
+- Fixed ``argpartition`` leading axis test
+  `#1971 <https://github.com/xtensor-stack/xtensor/pull/1971>`_
+- Added tests with C++20 enabled
+  `#1974 <https://github.com/xtensor-stack/xtensor/pull/1974>`_
+- Added documentation for ``repeat``
+  `#1975 <https://github.com/xtensor-stack/xtensor/pull/1975>`_
+- Fixed sort and partition
+  `#1976 <https://github.com/xtensor-stack/xtensor/pull/1976>`_
+- xt::view now supports negative indices
+  `#1979 <https://github.com/xtensor-stack/xtensor/pull/1979>`_
+
+0.21.3
+------
+
+- Allow use of cmake add_subdirectory(xtensor) by checking for xtl target
+  `#1865 <https://github.com/xtensor-stack/xtensor/pull/1865>`_
+- Simplifying CMake config
+  `#1856 <https://github.com/xtensor-stack/xtensor/pull/1856>`_
+- Fixed ``reshape`` with signed integers
+  `#1867 <https://github.com/xtensor-stack/xtensor/pull/1867>`_
+- Disabled MSVC iterator checks
+  `#1874 <https://github.com/xtensor-stack/xtensor/pull/1874>`_
+- Added covariance function
+  `#1847 <https://github.com/xtensor-stack/xtensor/pull/1847>`_
+- Fix for older cmake
+  `#1880 <https://github.com/xtensor-stack/xtensor/pull/1880>`_
+- Added row and col facade for 2-D contianers
+  `#1876 <https://github.com/xtensor-stack/xtensor/pull/1876>`_
+- Implementation of ``xt::tile``
+  `#1888 <https://github.com/xtensor-stack/xtensor/pull/1888>`_
+- Fixed ``reshape`` return
+  `#1886 <https://github.com/xtensor-stack/xtensor/pull/1886>`_
+- Enabled ``add_subdirectory`` for *xsimd*
+  `#1889 <https://github.com/xtensor-stack/xtensor/pull/1889>`_
+- Support ``ddof`` argument for ``xt::variance``
+  `#1893 <https://github.com/xtensor-stack/xtensor/pull/1893>`_
+- Set -march=native only if the user did not set another -march already
+  `#1899 <https://github.com/xtensor-stack/xtensor/pull/1899>`_
+- Assemble new container in ``xpad``
+  `#1808 <https://github.com/xtensor-stack/xtensor/pull/1808>`_
+
+0.21.2
+------
+
+- Upgraded to gtest 1.10.0
+  `#1859 <https://github.com/xtensor-stack/xtensor/pull/1859>`_
+- Upgraded to xsimd 7.4.4
+  `#1864 <https://github.com/xtensor-stack/xtensor/pull/1864>`_
+- Removed allocator deprecated calls
+  `#1862 <https://github.com/xtensor-stack/xtensor/pull/1862>`_
+
+0.21.1
+------
+
+- Added circular includes check
+  `#1853 <https://github.com/xtensor-stack/xtensor/pull/1853>`_
+- Removed cricular dependencies
+  `#1854 <https://github.com/xtensor-stack/xtensor/pull/1854>`_
+
+0.21.0
+------
+
+Breaking changes
+~~~~~~~~~~~~~~~~
+
+- Dynamic SIMD assign
+  `#1762 <https://github.com/xtensor-stack/xtensor/pull/1762>`_
+
+Other changes
+~~~~~~~~~~~~~
+
+- Updated links to other projects
+  `#1773 <https://github.com/xtensor-stack/xtensor/pull/1773>`_
+- Updated license
+  `#1774 <https://github.com/xtensor-stack/xtensor/pull/1774>`_
+- Updated related projects
+  `#1775 <https://github.com/xtensor-stack/xtensor/pull/1775>`_
+- Fixed ``has_simd_interface`` for non existing ``simd_return_type``
+  `#1779 <https://github.com/xtensor-stack/xtensor/pull/1779>`_
+- Added average overload for default equal weights
+  `#1789 <https://github.com/xtensor-stack/xtensor/pull/1789>`_
+- Implemented concatenation of ``fixed_shape`` tensors
+  `#1793 <https://github.com/xtensor-stack/xtensor/pull/1793>`_
+- Replaced ``new`` with ``unique_ptr`` in headers
+  `#1800 <https://github.com/xtensor-stack/xtensor/pull/1800>`_
+- Fixed reallocation when an ``xbuffer`` is copied over
+  `#1799 <https://github.com/xtensor-stack/xtensor/pull/1799>`_
+- Added hte ability to use the library with ``-fnoexception``
+  `#1801 <https://github.com/xtensor-stack/xtensor/pull/1801>`_
+- Minor efficiency improvement
+  `#1807 <https://github.com/xtensor-stack/xtensor/pull/1807>`_
+- Unified ``xt::concatenate`` and ``xt::concatenate_fixed``
+  `#1805 <https://github.com/xtensor-stack/xtensor/pull/1805>`_
+- Have ``reshape`` method return a reference to self
+  `#1813 <https://github.com/xtensor-stack/xtensor/pull/1813>`_
+- Enabling tests of ``xtensor_fixed`` on Windows with clang.
+  `#1815 <https://github.com/xtensor-stack/xtensor/pull/1815>`_
+- Disabled SIMD assignment when bool conversion occurs
+  `#1818 <https://github.com/xtensor-stack/xtensor/pull/1818>`_
+- Speed up views, added SIMD interface to strided views
+  `#1627 <https://github.com/xtensor-stack/xtensor/pull/1627>`_
+- Fixed assignment of scalar to complex
+  `#1828 <https://github.com/xtensor-stack/xtensor/pull/1828>`_
+- Fixed concurrency issue in ``flat_expression_adaptor``
+  `#1831 <https://github.com/xtensor-stack/xtensor/pull/1831>`_
+- Implemented an equivalent to ``numpy.roll``
+  `#1823 <https://github.com/xtensor-stack/xtensor/pull/1823>`_
+- Upgraded to ``xtl 0.6.9``
+  `#1839 <https://github.com/xtensor-stack/xtensor/pull/1839>`_
+- Fixed type of OpenMP's index variable on Windows
+  `#1838 <https://github.com/xtensor-stack/xtensor/pull/1838>`_
+- Implemented ``hstack`` and ``vstack``
+  `#1841 <https://github.com/xtensor-stack/xtensor/pull/1841>`_
+- Implemented ``hsplit`` and ``vsplit``
+  `#1842 <https://github.com/xtensor-stack/xtensor/pull/1842>`_
+- Fixed behavior of ``diff`` when ``n`` is greater thant the number of elements
+  `#1843 <https://github.com/xtensor-stack/xtensor/pull/1843>`_
+- Added treshold to OpenMP parallelization
+  `#1849 <https://github.com/xtensor-stack/xtensor/pull/1849>`_
+- Added missing assign operator in ``xmasked_view``
+  `#1850 <https://github.com/xtensor-stack/xtensor/pull/1850>`_
+- Updated CMake target
+  `#1851 <https://github.com/xtensor-stack/xtensor/pull/1851>`_
+
+0.20.10
+-------
+
+- Simplified functors definition
+  `#1756 <https://github.com/xtensor-stack/xtensor/pull/1756>`_
+- Fixed ``container_simd_return_type``
+  `#1759 <https://github.com/xtensor-stack/xtensor/pull/1759>`_
+- Fixed reducer init for ``xtensor_fixed`` value type
+  `#1761 <https://github.com/xtensor-stack/xtensor/pull/1761>`_
+
+0.20.9
+------
+
+- Added alias to check if type is ``xsemantic_base``
+  `#1673 <https://github.com/xtensor-stack/xtensor/pull/1673>`_
+- Added missing include ``xoperation.hpp``
+  `#1674 <https://github.com/xtensor-stack/xtensor/pull/1674>`_
+- Moved XSIMD and TBB dependencies to tests only
+  `#1676 <https://github.com/xtensor-stack/xtensor/pull/1676>`_
+- Added missing coma
+  `#1680 <https://github.com/xtensor-stack/xtensor/pull/1680>`_
+- Added NumPy-like parameter in ``load_csv``
+  `#1682 <https://github.com/xtensor-stack/xtensor/pull/1682>`_
+- Added ``shape()`` method to ``xshape.hpp``
+  `#1592 <https://github.com/xtensor-stack/xtensor/pull/1592>`_
+- Added shape print tip to docs
+  `#1693 <https://github.com/xtensor-stack/xtensor/pull/1693>`_
+- Fix lvalue npy_file heap corruption in MSVC
+  `#1697 <https://github.com/xtensor-stack/xtensor/pull/1697>`_
+- Fix UB when parsing 1-dimension npy
+  `#1696 <https://github.com/xtensor-stack/xtensor/pull/1696>`_
+- Fixed compiler error (missing ``shape`` method in ``xbroadcast`` and ``xscalar``)
+  `#1699 <https://github.com/xtensor-stack/xtensor/pull/1699>`_
+- Added: deg2rad, rad2deg, degrees, radians
+  `#1700 <https://github.com/xtensor-stack/xtensor/pull/1700>`_
+- Despecialized xt::to_json and xt::from_json
+  `#1691 <https://github.com/xtensor-stack/xtensor/pull/1691>`_
+- Added coverity
+  `#1577 <https://github.com/xtensor-stack/xtensor/pull/1577>`_
+- Additional configuration for future coverity branch
+  `#1712 <https://github.com/xtensor-stack/xtensor/pull/1712>`_
+- More tests for coverity
+  `#1714 <https://github.com/xtensor-stack/xtensor/pull/1714>`_
+- Update README.md for Conan installation instructions
+  `#1717 <https://github.com/xtensor-stack/xtensor/pull/1717>`_
+- Reset stream's flags after output operation
+  `#1718 <https://github.com/xtensor-stack/xtensor/pull/1718>`_
+- Added missing include in ``xview.hpp``
+  `#1719 <https://github.com/xtensor-stack/xtensor/pull/1719>`_
+- Removed usage of allocator's members that are deprecated in C++17
+  `#1720 <https://github.com/xtensor-stack/xtensor/pull/1720>`_
+- Added tests for mixed assignment
+  `#1721 <https://github.com/xtensor-stack/xtensor/pull/1721>`_
+- Fixed ``step_simd`` when underlying iterator holds an ``xscalar_stepper``
+  `#1724 <https://github.com/xtensor-stack/xtensor/pull/1724>`_
+- Fixed accumulator for empty arrays
+  `#1725 <https://github.com/xtensor-stack/xtensor/pull/1725>`_
+- Use ``temporary_type`` in implementation of ``xt::diff``
+  `#1727 <https://github.com/xtensor-stack/xtensor/pull/1727>`_
+- CMakeLists.txt: bumped up xsimd required version to 7.2.6
+  `#1728 <https://github.com/xtensor-stack/xtensor/pull/1728>`_
+- Fixed reducers on empty arrays
+  `#1729 <https://github.com/xtensor-stack/xtensor/pull/1729>`_
+- Implemented additional random distributions
+  `#1708 <https://github.com/xtensor-stack/xtensor/pull/1708>`_
+- Fixed reducers: passing the same axis many times now throws
+  `#1730 <https://github.com/xtensor-stack/xtensor/pull/1730>`_
+- Made ``xfixed_container`` optionally sharable
+  `#1733 <https://github.com/xtensor-stack/xtensor/pull/1733>`_
+- ``step_simd`` template parameter is now the value type instead of the simd type
+  `#1736 <https://github.com/xtensor-stack/xtensor/pull/1736>`_
+- Implemented OpenMP Parallelization.
+  `#1739 <https://github.com/xtensor-stack/xtensor/pull/1739>`_
+- Readme improvements
+  `#1741 <https://github.com/xtensor-stack/xtensor/pull/1741>`_
+- Vectorized ``xt::where``
+  `#1738 <https://github.com/xtensor-stack/xtensor/pull/1738>`_
+- Fix typos and wording in documentation
+  `#1745 <https://github.com/xtensor-stack/xtensor/pull/1745>`_
+- Upgraded to xtl 0.6.6. and xsimd 7.4.0
+  `#1747 <https://github.com/xtensor-stack/xtensor/pull/1747>`_
+- Improve return value type for ``nanmean``
+  `#1749 <https://github.com/xtensor-stack/xtensor/pull/1749>`_
+- Allows (de)serialization of xexpressions in NumPy formatted strings and streams
+  `#1751 <https://github.com/xtensor-stack/xtensor/pull/1751>`_
+- Enabled vectorization of boolean operations
+  `#1748 <https://github.com/xtensor-stack/xtensor/pull/1748>`_
+- Added the list of contributors
+  `#1755 <https://github.com/xtensor-stack/xtensor/pull/1755>`_
+
+0.20.8
+------
+
+- Added traversal order to ``argwhere`` and ``filter``
+  `#1672 <https://github.com/xtensor-stack/xtensor/pull/1672>`_
+- ``flatten`` now returns the new type ``xtensor_view``
+  `#1671 <https://github.com/xtensor-stack/xtensor/pull/1671>`_
+- Error case handling in ``concatenate``
+  `#1669 <https://github.com/xtensor-stack/xtensor/pull/1669>`_
+- Added assign operator from ``temporary_type`` in ``xiterator_adaptor``
+  `#1668 <https://github.com/xtensor-stack/xtensor/pull/1668>`_
+- Improved ``index_view`` examples
+  `#1667 <https://github.com/xtensor-stack/xtensor/pull/1667>`_
+- Updated build option section of the documentation
+  `#1666 <https://github.com/xtensor-stack/xtensor/pull/1666>`_
+- Made ``xsequence_view`` convertible to arbitrary sequence type providing  iterators
+  `#1657 <https://github.com/xtensor-stack/xtensor/pull/1657>`_
+- Added overload of ``is_linear`` for expressions without ``strides`` method
+  `#1655 <https://github.com/xtensor-stack/xtensor/pull/1655>`_
+- Fixed reverse ``arange``
+  `#1653 <https://github.com/xtensor-stack/xtensor/pull/1653>`_
+- Add warnings for random number generation
+  `#1652 <https://github.com/xtensor-stack/xtensor/pull/1652>`_
+- Added common pitfalls section in the documentation
+  `#1649 <https://github.com/xtensor-stack/xtensor/pull/1649>`_
+- Added missing ``shape`` overload in ``xfunction``
+  `#1650 <https://github.com/xtensor-stack/xtensor/pull/1650>`_
+- Made ``xconst_accessible::shape(std::size_t)`` visible in ``xview``
+  `#1645 <https://github.com/xtensor-stack/xtensor/pull/1645>`_
+- Diff: added bounds-check on maximal recursion
+  `#1640 <https://github.com/xtensor-stack/xtensor/pull/1640>`_
+- Add ``xframe`` to related projects
+  `#1635 <https://github.com/xtensor-stack/xtensor/pull/1635>`_
+- Update ``indice.rst``
+  `#1626 <https://github.com/xtensor-stack/xtensor/pull/1626>`_
+- Remove unecessary arguments
+  `#1624 <https://github.com/xtensor-stack/xtensor/pull/1624>`_
+- Replace ``auto`` with explicit return type in ``make_xshared``
+  `#1621 <https://github.com/xtensor-stack/xtensor/pull/1621>`_
+- Add `z5` to related projects
+  `#1620 <https://github.com/xtensor-stack/xtensor/pull/1620>`_
+- Fixed long double complex offset views
+  `#1614 <https://github.com/xtensor-stack/xtensor/pull/1614>`_
+- Fixed ``xpad`` bugs
+  `#1607 <https://github.com/xtensor-stack/xtensor/pull/1602>`_
+- Workaround for annoying bug in VS2017
+  `#1602 <https://github.com/xtensor-stack/xtensor/pull/1607>`_
+
+0.20.7
+------
+
+- Fix reshape view assignment and allow setting traversal order
+  `#1598 <https://github.com/xtensor-stack/xtensor/pull/1598>`_
+
+0.20.6
+------
+
+- Added XTENSOR_DEFAULT_ALIGNMENT macro
+  `#1597 <https://github.com/xtensor-stack/xtensor/pull/1597>`_
+- Added missing comparison operators for const_array
+  `#1596 <https://github.com/xtensor-stack/xtensor/pull/1596>`_
+- Fixed reducer for expression with shape containing 0
+  `#1595 <https://github.com/xtensor-stack/xtensor/pull/1595>`_
+- Very minor spelling checks in comments
+  `#1591 <https://github.com/xtensor-stack/xtensor/pull/1591>`_
+- tests can be built in debug mode
+  `#1589 <https://github.com/xtensor-stack/xtensor/pull/1589>`_
+- strided views constructors forward shape argument
+  `#1587 <https://github.com/xtensor-stack/xtensor/pull/1587>`_
+- Remove unused type alias
+  `#1585 <https://github.com/xtensor-stack/xtensor/pull/1585>`_
+- Fixed reducers with empty list of axes
+  `#1582 <https://github.com/xtensor-stack/xtensor/pull/1582>`_
+- Fix typo in builder docs
+  `#1581 <https://github.com/xtensor-stack/xtensor/pull/1581>`_
+- Fixed return type of data in xstrided_view
+  `#1580 <https://github.com/xtensor-stack/xtensor/pull/1580>`_
+- Fixed reducers on expression with shape containing 1 as first elements
+  `#1579 <https://github.com/xtensor-stack/xtensor/pull/1579>`_
+- Fixed xview::element for range with more elements than view's dimension
+  `#1578 <https://github.com/xtensor-stack/xtensor/pull/1578>`_
+- Fixed broadcasting of shape containing 0-sized dimensions
+  `#1575 <https://github.com/xtensor-stack/xtensor/pull/1575>`_
+- Fixed norm return type for complex
+  `#1574 <https://github.com/xtensor-stack/xtensor/pull/1574>`_
+- Fixed iterator incremented or decremented by 0
+  `#1572 <https://github.com/xtensor-stack/xtensor/pull/1572>`_
+- Added complex exponential test
+  `#1571 <https://github.com/xtensor-stack/xtensor/pull/1571>`_
+- Strided views refactoring
+  `#1569 <https://github.com/xtensor-stack/xtensor/pull/1569>`_
+- Add clang-cl support
+  `#1559 <https://github.com/xtensor-stack/xtensor/pull/1559>`_
+
+0.20.5
+------
+
+- Fixed ``conj``
+  `#1556 <https://github.com/xtensor-stack/xtensor/pull/1556>`_
+- Fixed ``real``, ``imag``, and ``functor_view``
+  `#1554 <https://github.com/xtensor-stack/xtensor/pull/1554>`_
+- Allows to include *xsimd* without defining ``XTENSOR_USE_XSIMD``
+  `#1548 <https://github.com/xtensor-stack/xtensor/pull/1548>`_
+- Fixed ``argsort`` in column major
+  `#1547 <https://github.com/xtensor-stack/xtensor/pull/1547>`_
+- Fixed ``assign_to`` for ``arange`` on ``double``
+  `#1541 <https://github.com/xtensor-stack/xtensor/pull/1541>`_
+- Fix example code in container.rst
+  `#1544 <https://github.com/xtensor-stack/xtensor/pull/1544>`_
+- Removed return value from ``step_leading``
+  `#1536 <https://github.com/xtensor-stack/xtensor/pull/1536>`_
+- Bugfix: amax
+  `#1533 <https://github.com/xtensor-stack/xtensor/pull/1533>`_
+- Removed extra ;
+  `#1527 <https://github.com/xtensor-stack/xtensor/pull/1527>`_
+
+0.20.4
+------
+
+- Buffer adaptor default constructor
+  `#1524 <https://github.com/xtensor-stack/xtensor/pull/1524>`_
+
+0.20.3
+------
+
+- Fix xbuffer adaptor
+  `#1523 <https://github.com/xtensor-stack/xtensor/pull/1523>`_
+
+0.20.2
+------
+
+- Fixed broadcast linear assign
+  `#1493 <https://github.com/xtensor-stack/xtensor/pull/1493>`_
+- Fixed ``do_stirdes_match``
+  `#1497 <https://github.com/xtensor-stack/xtensor/pull/1497>`_
+- Removed unused capture
+  `#1499 <https://github.com/xtensor-stack/xtensor/pull/1499>`_
+- Upgraded to *xtl* 0.6.2
+  `#1502 <https://github.com/xtensor-stack/xtensor/pull/1502>`_
+- Added missing methods in ``xshared_expression``
+  `#1503 <https://github.com/xtensor-stack/xtensor/pull/1503>`_
+- Fixed iterator types of ``xcontainer``
+  `#1504 <https://github.com/xtensor-stack/xtensor/pull/1504>`_
+- Typo correction in external-structure.rst
+  `#1505 <https://github.com/xtensor-stack/xtensor/pull/1505>`_
+- Added extension base to adaptors
+  `#1507 <https://github.com/xtensor-stack/xtensor/pull/1507>`_
+- Fixed shared expression iterator methods
+  `#1509 <https://github.com/xtensor-stack/xtensor/pull/1509>`_
+- Strided view fixes
+  `#1512 <https://github.com/xtensor-stack/xtensor/pull/1512>`_
+- Improved range documentation
+  `#1515 <https://github.com/xtensor-stack/xtensor/pull/1515>`_
+- Fixed ``ravel`` and ``flatten`` implementation
+  `#1511 <https://github.com/xtensor-stack/xtensor/pull/1511>`_
+- Fixed ``xfixed_adaptor`` temporary assign
+  `#1516 <https://github.com/xtensor-stack/xtensor/pull/1516>`_
+- Changed struct -> class in ``xiterator_adaptor``
+  `#1513 <https://github.com/xtensor-stack/xtensor/pull/1513>`_
+- Fxed ``argmax`` for expressions with strides 0
+  `#1519 <https://github.com/xtensor-stack/xtensor/pull/1519>`_
+- Add ``has_linear_assign`` to ``sdynamic_view``
+  `#1520 <https://github.com/xtensor-stack/xtensor/pull/1520>`_
+
+0.20.1
+------
+
+- Add a test for mimetype rendering and fix forward declaration
+  `#1490 <https://github.com/xtensor-stack/xtensor/pull/1490>`_
+- Fix special case of view iteration
+  `#1491 <https://github.com/xtensor-stack/xtensor/pull/1491>`_
+
+0.20.0
+------
+
+Breaking changes
+~~~~~~~~~~~~~~~~
+
+- Removed ``xmasked_value`` and ``promote_type_t``
+  `#1389 <https://github.com/xtensor-stack/xtensor/pull/1389>`_
+- Removed deprecated type ``slice_vector``
+  `#1459 <https://github.com/xtensor-stack/xtensor/pull/1459>`_
+- Upgraded to *xtl* 0.6.1
+  `#1468 <https://github.com/xtensor-stack/xtensor/pull/1465>`_
+- Added ``keep_dims`` option to reducers
+  `#1474 <https://github.com/xtensor-stack/xtensor/pull/1474>`_
+- ``do_strides_match`` now accept an addition base stride value
+  `#1479 <https://github.com/xtensor-stack/xtensor/pull/1479>`_
+
+Other changes
+~~~~~~~~~~~~~
+
+- Add ``partition``, ``argpartition`` and ``median``
+  `#991 <https://github.com/xtensor-stack/xtensor/pull/991>`_
+- Fix tets on avx512
+  `#1410 <https://github.com/xtensor-stack/xtensor/pull/1410>`_
+- Implemented ``xcommon_tensor_t`` with tests
+  `#1412 <https://github.com/xtensor-stack/xtensor/pull/1412>`_
+- Code reorganization
+  `#1416 <https://github.com/xtensor-stack/xtensor/pull/1416>`_
+- ``reshape`` now accepts ``initializer_list`` parameter
+  `#1417 <https://github.com/xtensor-stack/xtensor/pull/1417>`_
+- Improved documentation
+  `#1419 <https://github.com/xtensor-stack/xtensor/pull/1419>`_
+- Fixed ``noexcept`` specifier
+  `#1418 <https://github.com/xtensor-stack/xtensor/pull/1418>`_
+- ``view`` now accepts lvalue slices
+  `#1420 <https://github.com/xtensor-stack/xtensor/pull/1420>`_
+- Removed warnings
+  `#1422 <https://github.com/xtensor-stack/xtensor/pull/1422>`_
+- Added ``reshape`` member to ``xgenerator`` to make ``arange`` more flexible
+  `#1421 <https://github.com/xtensor-stack/xtensor/pull/1421>`_
+- Add ``std::decay_t`` to ``shape_type`` in strided view
+  `#1425 <https://github.com/xtensor-stack/xtensor/pull/1425>`_
+- Generic reshape for ``xgenerator``
+  `#1426 <https://github.com/xtensor-stack/xtensor/pull/1426>`_
+- Fix out of bounds accessing in ``xview::compute_strides``
+  `#1437 <https://github.com/xtensor-stack/xtensor/pull/1437>`_
+- Added quick reference section to documentation
+  `#1438 <https://github.com/xtensor-stack/xtensor/pull/1438>`_
+- Improved getting started CMakeLists.txt
+  `#1440 <https://github.com/xtensor-stack/xtensor/pull/1440>`_
+- Added periodic indices
+  `#1430 <https://github.com/xtensor-stack/xtensor/pull/1430>`_
+- Added build section to narrative documentation
+  `#1442 <https://github.com/xtensor-stack/xtensor/pull/1442>`_
+- Fixed ``linspace`` corner case
+  `#1443 <https://github.com/xtensor-stack/xtensor/pull/1443>`_
+- Fixed type-o in documentation
+  `#1446 <https://github.com/xtensor-stack/xtensor/pull/1446>`_
+- Added ``xt::xpad``
+  `#1441 <https://github.com/xtensor-stack/xtensor/pull/1441>`_
+- Added warning in ``resize`` documentation
+  `#1447 <https://github.com/xtensor-stack/xtensor/pull/1447>`_
+- Added ``in_bounds`` method
+  `#1444 <https://github.com/xtensor-stack/xtensor/pull/1444>`_
+- ``xstrided_view_base`` is now a CRTP base class
+  `#1453 <https://github.com/xtensor-stack/xtensor/pull/1453>`_
+- Turned ``xfunctor_applier_base`` into a CRTP base class
+  `#1455 <https://github.com/xtensor-stack/xtensor/pull/1455>`_
+- Removed out of bound access in ``data_offset``
+  `#1456 <https://github.com/xtensor-stack/xtensor/pull/1456>`_
+- Added ``xaccessible`` base class
+  `#1451 <https://github.com/xtensor-stack/xtensor/pull/1451>`_
+- Refactored ``operator[]``
+  `#1460 <https://github.com/xtensor-stack/xtensor/pull/1460>`_
+- Splitted ``xaccessible``
+  `#1461 <https://github.com/xtensor-stack/xtensor/pull/1461>`_
+- Refactored ``size``
+  `#1462 <https://github.com/xtensor-stack/xtensor/pull/1462>`_
+- Implemented ``nanvar`` and ``nanstd`` with tests
+  `#1424 <https://github.com/xtensor-stack/xtensor/pull/1424>`_
+- Removed warnings
+  `#1463 <https://github.com/xtensor-stack/xtensor/pull/1463>`_
+- Added ``periodic`` and ``in_bounds`` method to ``xoptional_assembly_base``
+  `#1464 <https://github.com/xtensor-stack/xtensor/pull/1464>`_
+- Updated documentation according to last changes
+  `#1465 <https://github.com/xtensor-stack/xtensor/pull/1465>`_
+- Fixed ``flatten_sort_result_type``
+  `#1470 <https://github.com/xtensor-stack/xtensor/pull/1470>`_
+- Fixed ``unique`` with expressions not defining ``temporary_type``
+  `#1472 <https://github.com/xtensor-stack/xtensor/pull/1472>`_
+- Fixed ``xstrided_view_base`` constructor
+  `#1473 <https://github.com/xtensor-stack/xtensor/pull/1473>`_
+- Avoid signed integer overflow in integer printer
+  `#1475 <https://github.com/xtensor-stack/xtensor/pull/1475>`_
+- Fixed ``xview::inner_backstrides_type``
+  `#1480 <https://github.com/xtensor-stack/xtensor/pull/1480>`_
+- Fixed compiler warnings
+  `#1481 <https://github.com/xtensor-stack/xtensor/pull/1481>`_
+- ``slice_implementation_getter`` now forwards its lice argument
+  `#1486 <https://github.com/xtensor-stack/xtensor/pull/1486>`_
+- ``linspace`` can now be reshaped
+  `#1488 <https://github.com/xtensor-stack/xtensor/pull/1488>`_
+
+0.19.4
+------
+
+- Add missing include
+  `#1391 <https://github.com/xtensor-stack/xtensor/pull/1391>`_
+- Fixes in xfunctor_view
+  `#1393 <https://github.com/xtensor-stack/xtensor/pull/1393>`_
+- Add tests for xfunctor_view
+  `#1395 <https://github.com/xtensor-stack/xtensor/pull/1395>`_
+- Add `empty` method to fixed_shape
+  `#1396 <https://github.com/xtensor-stack/xtensor/pull/1396>`_
+- Add accessors to slice members
+  `#1401 <https://github.com/xtensor-stack/xtensor/pull/1401>`_
+- Allow adaptors on shared pointers
+  `#1218 <https://github.com/xtensor-stack/xtensor/pull/1218>`_
+- Fix `eye` with negative index
+  `#1406 <https://github.com/xtensor-stack/xtensor/pull/1406>`_
+- Add documentation for shared pointer adaptor
+  `#1407 <https://github.com/xtensor-stack/xtensor/pull/1407>`_
+- Add `nanmean` function
+  `#1408 <https://github.com/xtensor-stack/xtensor/pull/1408>`_
+
+0.19.3
+------
+
+- Fix arange
+  `#1361 <https://github.com/xtensor-stack/xtensor/pull/1361>`_.
+- Adaptors for C stack-allocated arrays
+  `#1363 <https://github.com/xtensor-stack/xtensor/pull/1363>`_.
+- Add support for optionals in ``conditional_ternary``
+  `#1365 <https://github.com/xtensor-stack/xtensor/pull/1365>`_.
+- Add tests for ternary operator on xoptionals
+  `#1368 <https://github.com/xtensor-stack/xtensor/pull/1368>`_.
+- Enable ternary operation for a mix of ``xoptional<value>`` and ``value``
+  `#1370 <https://github.com/xtensor-stack/xtensor/pull/1370>`_.
+- ``reduce`` now accepts a single reduction function
+  `#1371 <https://github.com/xtensor-stack/xtensor/pull/1371>`_.
+- Implemented share method
+  `#1372 <https://github.com/xtensor-stack/xtensor/pull/1372>`_.
+- Documentation of shared improved
+  `#1373 <https://github.com/xtensor-stack/xtensor/pull/1373>`_.
+- ``make_lambda_xfunction`` more generic
+  `#1374 <https://github.com/xtensor-stack/xtensor/pull/1374>`_.
+- minimum/maximum for ``xoptional``
+  `#1378 <https://github.com/xtensor-stack/xtensor/pull/1378>`_.
+- Added missing methods in ``uvector`` and ``svector``
+  `#1379 <https://github.com/xtensor-stack/xtensor/pull/1379>`_.
+- Clip ``xoptional_assembly``
+  `#1380 <https://github.com/xtensor-stack/xtensor/pull/1380>`_.
+- Improve gtest cmake
+  `#1382 <https://github.com/xtensor-stack/xtensor/pull/1382>`_.
+- Implement ternary operator for scalars
+  `#1385 <https://github.com/xtensor-stack/xtensor/pull/1385>`_.
+- Added missing ``at`` method in ``uvector`` and ``svector``
+  `#1386 <https://github.com/xtensor-stack/xtensor/pull/1386>`_.
+- Fixup binder environment
+  `#1387 <https://github.com/xtensor-stack/xtensor/pull/1387>`_.
+- Fixed ``resize`` and ``swap`` of ``svector``
+  `#1388 <https://github.com/xtensor-stack/xtensor/pull/1388>`_.
+
+0.19.2
+------
+
+- Enable CI for C++17
+  `#1324 <https://github.com/xtensor-stack/xtensor/pull/1324>`_.
+- Fix assignment of masked views
+  `#1328 <https://github.com/xtensor-stack/xtensor/pull/1328>`_.
+- Set CMAKE_CXX_STANDARD instead of CMAKE_CXX_FLAGS
+  `#1330 <https://github.com/xtensor-stack/xtensor/pull/1330>`_.
+- Allow specifying traversal order to argmin and argmax
+  `#1331 <https://github.com/xtensor-stack/xtensor/pull/1331>`_.
+- Update section on differences with NumPy
+  `#1336 <https://github.com/xtensor-stack/xtensor/pull/1336>`_.
+- Fix accumulators for shapes containing 1
+  `#1337 <https://github.com/xtensor-stack/xtensor/pull/1337>`_.
+- Decouple XTENSOR_DEFAULT_LAYOUT and XTENSOR_DEFAULT_TRAVERSAL
+  `#1339 <https://github.com/xtensor-stack/xtensor/pull/1339>`_.
+- Prevent embiguity with `xsimd::reduce`
+  `#1343 <https://github.com/xtensor-stack/xtensor/pull/1343>`_.
+- Require *xtl* 0.5.3
+  `#1346 <https://github.com/xtensor-stack/xtensor/pull/1346>`_.
+- Use concepts instead of SFINAE
+  `#1347 <https://github.com/xtensor-stack/xtensor/pull/1347>`_.
+- Document good practice for xtensor-based API design
+  `#1348 <https://github.com/xtensor-stack/xtensor/pull/1348>`_.
+- Fix rich display of tensor expressions
+  `#1353 <https://github.com/xtensor-stack/xtensor/pull/1353>`_.
+- Fix xview on fixed tensor
+  `#1354 <https://github.com/xtensor-stack/xtensor/pull/1354>`_.
+- Fix issue with `keep_slice` in case of `dynamic_view` on `view`
+  `#1355 <https://github.com/xtensor-stack/xtensor/pull/1355>`_.
+- Prevent installation of gtest artifacts
+  `#1357 <https://github.com/xtensor-stack/xtensor/pull/1357>`_.
+
+0.19.1
+------
+
+- Add string specialization to ``lexical_cast``
+  `#1281 <https://github.com/xtensor-stack/xtensor/pull/1281>`_.
+- Added HDF5 reference for ``xtensor-io``
+  `#1284 <https://github.com/xtensor-stack/xtensor/pull/1284>`_.
+- Fixed view index remap issue
+  `#1288 <https://github.com/xtensor-stack/xtensor/pull/1288>`_.
+- Fixed gcc 8.2 deleted functions
+  `#1289 <https://github.com/xtensor-stack/xtensor/pull/1289>`_.
+- Fixed reducer for 0d input
+  `#1292 <https://github.com/xtensor-stack/xtensor/pull/1292>`_.
+- Fixed ``check_element_index``
+  `#1295 <https://github.com/xtensor-stack/xtensor/pull/1295>`_.
+- Added comparison functions
+  `#1297 <https://github.com/xtensor-stack/xtensor/pull/1297>`_.
+- Add some tests to ensure chrono works with xexpressions
+  `#1272 <https://github.com/xtensor-stack/xtensor/pull/1272>`_.
+- Refactor ``functor_view``
+  `#1276 <https://github.com/xtensor-stack/xtensor/pull/1276>`_.
+- Documentation improved
+  `#1302 <https://github.com/xtensor-stack/xtensor/pull/1302>`_.
+- Implementation of shift operators
+  `#1304 <https://github.com/xtensor-stack/xtensor/pull/1304>`_.
+- Make functor adaptor stepper work for proxy specializations
+  `#1305 <https://github.com/xtensor-stack/xtensor/pull/1305>`_.
+- Replaced ``auto&`` with ``auto&&`` in ``assign_to``
+  `#1306 <https://github.com/xtensor-stack/xtensor/pull/1306>`_.
+- Fix namespace in ``xview_utils.hpp``
+  `#1308 <https://github.com/xtensor-stack/xtensor/pull/1308>`_.
+- Introducing ``flatten_indices`` and ``unravel_indices``
+  `#1300 <https://github.com/xtensor-stack/xtensor/pull/1300>`_.
+- Default layout parameter for ``ravel``
+  `#1311 <https://github.com/xtensor-stack/xtensor/pull/1311>`_.
+- Fixed ``xvie_stepper``
+  `#1317 <https://github.com/xtensor-stack/xtensor/pull/1317>`_.
+- Fixed assignment of view on view
+  `#1314 <https://github.com/xtensor-stack/xtensor/pull/1314>`_.
+- Documented indices
+  `#1318 <https://github.com/xtensor-stack/xtensor/pull/1318>`_.
+- Fixed shift operators return type
+  `#1319 <https://github.com/xtensor-stack/xtensor/pull/1319>`_.
+
+0.19.0
+------
+
+Breaking changes
+~~~~~~~~~~~~~~~~
+
+- Upgraded to ``xtl 0.5``
+  `#1275 <https://github.com/xtensor-stack/xtensor/pull/1275>`_.
+
+Other changes
+~~~~~~~~~~~~~
+
+- Removed type-o in docs, minor code style consistency update
+  `#1255 <https://github.com/xtensor-stack/xtensor/pull/1255>`_.
+- Removed most of the warnings
+  `#1261 <https://github.com/xtensor-stack/xtensor/pull/1261>`_.
+- Optional bitwise fixed
+  `#1263 <https://github.com/xtensor-stack/xtensor/pull/1263>`_.
+- Prevent macro expansion in ``std::max``
+  `#1265 <https://github.com/xtensor-stack/xtensor/pull/1265>`_.
+- Update numpy.rst
+  `#1267 <https://github.com/xtensor-stack/xtensor/pull/1267>`_.
+- Update getting_started.rst
+  `#1268 <https://github.com/xtensor-stack/xtensor/pull/1268>`_.
+- keep and drop ``step_size`` fixed
+  `#1270 <https://github.com/xtensor-stack/xtensor/pull/1270>`_.
+- Fixed typo in ``xadapt``
+  `#1277 <https://github.com/xtensor-stack/xtensor/pull/1277>`_.
+- Fixed typo
+  `#1278 <https://github.com/xtensor-stack/xtensor/pull/1278>`_.
+
+0.18.3
+------
+
+- Exporting optional dependencies
+  `#1253 <https://github.com/xtensor-stack/xtensor/pull/1253>`_.
+- 0-D HTML rendering
+  `#1252 <https://github.com/xtensor-stack/xtensor/pull/1252>`_.
+- Include nlohmann_json in xio for mime bundle repr
+  `#1251 <https://github.com/xtensor-stack/xtensor/pull/1251>`_.
+- Fixup xview scalar assignment
+  `#1250 <https://github.com/xtensor-stack/xtensor/pull/1250>`_.
+- Implemented `from_indices`
+  `#1240 <https://github.com/xtensor-stack/xtensor/pull/1240>`_.
+- xtensor_forward.hpp cleanup
+  `#1243 <https://github.com/xtensor-stack/xtensor/pull/1243>`_.
+- default layout-type for `unravel_from_strides` and `unravel_index`
+  `#1239 <https://github.com/xtensor-stack/xtensor/pull/1239>`_.
+- xfunction iterator fix
+  `#1241 <https://github.com/xtensor-stack/xtensor/pull/1241>`_.
+- xstepper fixes
+  `#1237 <https://github.com/xtensor-stack/xtensor/pull/1237>`_.
+- print_options io manipulators
+  `#1231 <https://github.com/xtensor-stack/xtensor/pull/1231>`_.
+- Add syntactic sugar for reducer on single axis
+  `#1228 <https://github.com/xtensor-stack/xtensor/pull/1228>`_.
+- Added view vs. adapt benchmark
+  `#1229 <https://github.com/xtensor-stack/xtensor/pull/1229>`_.
+- added precisions to the installation instructions
+  `#1226 <https://github.com/xtensor-stack/xtensor/pull/1226>`_.
+- removed data interface from dynamic view
+  `#1225 <https://github.com/xtensor-stack/xtensor/pull/1225>`_.
+- add xio docs
+  `#1223 <https://github.com/xtensor-stack/xtensor/pull/1223>`_.
+- Fixup xview assignment
+  `#1216 <https://github.com/xtensor-stack/xtensor/pull/1216>`_.
+- documentation updated to be consistent with last changes
+  `#1214 <https://github.com/xtensor-stack/xtensor/pull/1214>`_.
+- prevents macro expansion of std::max
+  `#1213 <https://github.com/xtensor-stack/xtensor/pull/1213>`_.
+- Fix minor typos
+  `#1212 <https://github.com/xtensor-stack/xtensor/pull/1212>`_.
+- Added missing assign operator in xstrided_view
+  `#1210 <https://github.com/xtensor-stack/xtensor/pull/1210>`_.
+- argmax on axis with single element fixed
+  `#1209 <https://github.com/xtensor-stack/xtensor/pull/1209>`_.
+
 0.18.2
 ------
 
 - expression tag system fixed
-  `#1207 <https://github.com/QuantStack/xtensor/pull/1207>`_.
+  `#1207 <https://github.com/xtensor-stack/xtensor/pull/1207>`_.
 - optional extension for generator
-  `#1206 <https://github.com/QuantStack/xtensor/pull/1206>`_.
+  `#1206 <https://github.com/xtensor-stack/xtensor/pull/1206>`_.
 - optional extension for ``xview``
-  `#1205 <https://github.com/QuantStack/xtensor/pull/1205>`_.
+  `#1205 <https://github.com/xtensor-stack/xtensor/pull/1205>`_.
 - optional extension for ``xstrided_view``
-  `#1204 <https://github.com/QuantStack/xtensor/pull/1204>`_.
+  `#1204 <https://github.com/xtensor-stack/xtensor/pull/1204>`_.
 - optional extension for reducer
-  `#1203 <https://github.com/QuantStack/xtensor/pull/1203>`_.
+  `#1203 <https://github.com/xtensor-stack/xtensor/pull/1203>`_.
 - optional extension for ``xindex_view``
-  `#1202 <https://github.com/QuantStack/xtensor/pull/1202>`_.
+  `#1202 <https://github.com/xtensor-stack/xtensor/pull/1202>`_.
 - optional extension for ``xfunctor_view``
-  `#1201 <https://github.com/QuantStack/xtensor/pull/1201>`_.
+  `#1201 <https://github.com/xtensor-stack/xtensor/pull/1201>`_.
 - optional extension for broadcast
-  `#1198 <https://github.com/QuantStack/xtensor/pull/1198>`_.
+  `#1198 <https://github.com/xtensor-stack/xtensor/pull/1198>`_.
 - extension API and code cleanup
-  `#1197 <https://github.com/QuantStack/xtensor/pull/1197>`_.
+  `#1197 <https://github.com/xtensor-stack/xtensor/pull/1197>`_.
 - ``xscalar`` optional refactoring
-  `#1196 <https://github.com/QuantStack/xtensor/pull/1196>`_.
+  `#1196 <https://github.com/xtensor-stack/xtensor/pull/1196>`_.
 - Extension mechanism
-  `#1192 <https://github.com/QuantStack/xtensor/pull/1192>`_.
+  `#1192 <https://github.com/xtensor-stack/xtensor/pull/1192>`_.
 - Many small fixes
-  `#1191 <https://github.com/QuantStack/xtensor/pull/1191>`_.
+  `#1191 <https://github.com/xtensor-stack/xtensor/pull/1191>`_.
 - Slight refactoring in ``step_size`` logic
-  `#1188 <https://github.com/QuantStack/xtensor/pull/1188>`_.
+  `#1188 <https://github.com/xtensor-stack/xtensor/pull/1188>`_.
 - Fixup call of const overload in assembly storage
-  `#1187 <https://github.com/QuantStack/xtensor/pull/1187>`_.
+  `#1187 <https://github.com/xtensor-stack/xtensor/pull/1187>`_.
 
 0.18.1
 ------
 
 - Fixup xio forward declaration
-  `#1185 <https://github.com/QuantStack/xtensor/pull/1185>`_.
+  `#1185 <https://github.com/xtensor-stack/xtensor/pull/1185>`_.
 
 0.18.0
 ------
@@ -52,174 +1496,174 @@ Breaking changes
 ~~~~~~~~~~~~~~~~
 
 - Assign and trivial_broadcast refactoring
-  `#1150 <https://github.com/QuantStack/xtensor/pull/1150>`_.
+  `#1150 <https://github.com/xtensor-stack/xtensor/pull/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 <https://github.com/QuantStack/xtensor/pull/1153>`_.
+  `#1153 <https://github.com/xtensor-stack/xtensor/pull/1153>`_.
 - iterator API improved
-  `#1155 <https://github.com/QuantStack/xtensor/pull/1155>`_.
+  `#1155 <https://github.com/xtensor-stack/xtensor/pull/1155>`_.
 - Fixed ``where`` and ``nonzero`` function behavior to mimic the behavior from NumPy
-  `#1157 <https://github.com/QuantStack/xtensor/pull/1157>`_.
+  `#1157 <https://github.com/xtensor-stack/xtensor/pull/1157>`_.
 - xsimd and functor refactoring
-  `#1173 <https://github.com/QuantStack/xtensor/pull/1173>`_.
+  `#1173 <https://github.com/xtensor-stack/xtensor/pull/1173>`_.
 
 New features
 ~~~~~~~~~~~~
 
 - Implement ``rot90``
-  `#1153 <https://github.com/QuantStack/xtensor/pull/1153>`_.
+  `#1153 <https://github.com/xtensor-stack/xtensor/pull/1153>`_.
 - Implement ``argwhere`` and ``flatnonzero``
-  `#1157 <https://github.com/QuantStack/xtensor/pull/1157>`_.
+  `#1157 <https://github.com/xtensor-stack/xtensor/pull/1157>`_.
 - Implemented ``xexpression_holder``
-  `#1164 <https://github.com/QuantStack/xtensor/pull/1164>`_.
+  `#1164 <https://github.com/xtensor-stack/xtensor/pull/1164>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - Warnings removed
-  `#1159 <https://github.com/QuantStack/xtensor/pull/1159>`_.
-- Added missing include 
-  `#1162 <https://github.com/QuantStack/xtensor/pull/1162>`_.
+  `#1159 <https://github.com/xtensor-stack/xtensor/pull/1159>`_.
+- Added missing include
+  `#1162 <https://github.com/xtensor-stack/xtensor/pull/1162>`_.
 - Removed unused type alias in ``xmath/average``
-  `#1163 <https://github.com/QuantStack/xtensor/pull/1163>`_.
+  `#1163 <https://github.com/xtensor-stack/xtensor/pull/1163>`_.
 - Slices improved
-  `#1168 <https://github.com/QuantStack/xtensor/pull/1168>`_.
+  `#1168 <https://github.com/xtensor-stack/xtensor/pull/1168>`_.
 - Fixed ``xdrop_slice``
-  `#1181 <https://github.com/QuantStack/xtensor/pull/1181>`_.
+  `#1181 <https://github.com/xtensor-stack/xtensor/pull/1181>`_.
 
 0.17.4
 ------
 
 - perfect forwarding in ``xoptional_function`` constructor
-  `#1101 <https://github.com/QuantStack/xtensor/pull/1101>`_.
+  `#1101 <https://github.com/xtensor-stack/xtensor/pull/1101>`_.
 - fix issue with ``base_simd``
-  `#1103 <https://github.com/QuantStack/xtensor/pull/1103>`_.
+  `#1103 <https://github.com/xtensor-stack/xtensor/pull/1103>`_.
 - ``XTENSOR_ASSERT`` fixed on Windows
-  `#1104 <https://github.com/QuantStack/xtensor/pull/1104>`_.
+  `#1104 <https://github.com/xtensor-stack/xtensor/pull/1104>`_.
 - Implement ``xmasked_value``
-  `#1032 <https://github.com/QuantStack/xtensor/pull/1032>`_.
+  `#1032 <https://github.com/xtensor-stack/xtensor/pull/1032>`_.
 - Added ``setdiff1d`` using stl interface
-  `#1109 <https://github.com/QuantStack/xtensor/pull/1109>`_.
+  `#1109 <https://github.com/xtensor-stack/xtensor/pull/1109>`_.
 - Added test case for ``setdiff1d``
-  `#1110 <https://github.com/QuantStack/xtensor/pull/1110>`_.
-- Added missing reference to ``diff`` in ``From numpy to xtensor`` section
-  `#1116 <https://github.com/QuantStack/xtensor/pull/1116>`_.
+  `#1110 <https://github.com/xtensor-stack/xtensor/pull/1110>`_.
+- Added missing reference to ``diff`` in ``From NumPy to xtensor`` section
+  `#1116 <https://github.com/xtensor-stack/xtensor/pull/1116>`_.
 - Add ``amax`` and ``amin`` to the documentation
-  `#1121 <https://github.com/QuantStack/xtensor/pull/1121>`_.
+  `#1121 <https://github.com/xtensor-stack/xtensor/pull/1121>`_.
 - ``histogram`` and ``histogram_bin_edges`` implementation
-  `#1108 <https://github.com/QuantStack/xtensor/pull/1108>`_.
-- Added numpy comparison for interp
-  `#1111 <https://github.com/QuantStack/xtensor/pull/1111>`_.
+  `#1108 <https://github.com/xtensor-stack/xtensor/pull/1108>`_.
+- Added NumPy comparison for interp
+  `#1111 <https://github.com/xtensor-stack/xtensor/pull/1111>`_.
 - Allow multiple return type reducer functions
-  `#1113 <https://github.com/QuantStack/xtensor/pull/1113>`_.
-- Fixes ``average`` bug + adds Numpy based tests
-  `#1118 <https://github.com/QuantStack/xtensor/pull/1118>`_.
+  `#1113 <https://github.com/xtensor-stack/xtensor/pull/1113>`_.
+- Fixes ``average`` bug + adds NumPy based tests
+  `#1118 <https://github.com/xtensor-stack/xtensor/pull/1118>`_.
 - Static ``xfunction`` cache for fixed sizes
-  `#1105 <https://github.com/QuantStack/xtensor/pull/1105>`_.
+  `#1105 <https://github.com/xtensor-stack/xtensor/pull/1105>`_.
 - Add negative reshaping axis
-  `#1120 <https://github.com/QuantStack/xtensor/pull/1120>`_.
+  `#1120 <https://github.com/xtensor-stack/xtensor/pull/1120>`_.
 - Updated ``xmasked_view`` using ``xmasked_value``
-  `#1074 <https://github.com/QuantStack/xtensor/pull/1074>`_.
+  `#1074 <https://github.com/xtensor-stack/xtensor/pull/1074>`_.
 - Clean documentation for views
-  `#1131 <https://github.com/QuantStack/xtensor/pull/1131>`_.
-- Build with ``xsimd`` on Windows fixed
-  `#1127 <https://github.com/QuantStack/xtensor/pull/1127>`_.
+  `#1131 <https://github.com/xtensor-stack/xtensor/pull/1131>`_.
+- Build with *xsimd* on Windows fixed
+  `#1127 <https://github.com/xtensor-stack/xtensor/pull/1127>`_.
 - Implement ``mime_bundle_repr`` for ``xmasked_view``
-  `#1132 <https://github.com/QuantStack/xtensor/pull/1132>`_.
+  `#1132 <https://github.com/xtensor-stack/xtensor/pull/1132>`_.
 - Modify shuffle to use identical algorithms for any number of dimensions
-  `#1135 <https://github.com/QuantStack/xtensor/pull/1135>`_.
+  `#1135 <https://github.com/xtensor-stack/xtensor/pull/1135>`_.
 - Warnings removal on windows
-  `#1139 <https://github.com/QuantStack/xtensor/pull/1135>`_.
+  `#1139 <https://github.com/xtensor-stack/xtensor/pull/1135>`_.
 - Add permutation function to random
-  `#1141 <https://github.com/QuantStack/xtensor/pull/1141>`_.
+  `#1141 <https://github.com/xtensor-stack/xtensor/pull/1141>`_.
 - ``xfunction_iterator`` permutation
-  `#933 <https://github.com/QuantStack/xtensor/pull/933>`_.
+  `#933 <https://github.com/xtensor-stack/xtensor/pull/933>`_.
 - Add ``bincount`` to ``xhistogram``
-  `#1140 <https://github.com/QuantStack/xtensor/pull/1140>`_.
+  `#1140 <https://github.com/xtensor-stack/xtensor/pull/1140>`_.
 - Add contiguous iterable base class and remove layout param from storage iterator
-  `#1057 <https://github.com/QuantStack/xtensor/pull/1057>`_.
+  `#1057 <https://github.com/xtensor-stack/xtensor/pull/1057>`_.
 - Add ``storage_iterator`` to view and strided view
-  `#1045 <https://github.com/QuantStack/xtensor/pull/1045>`_.
+  `#1045 <https://github.com/xtensor-stack/xtensor/pull/1045>`_.
 - Removes ``data_element`` from ``xoptional``
-  `#1137 <https://github.com/QuantStack/xtensor/pull/1137>`_.
+  `#1137 <https://github.com/xtensor-stack/xtensor/pull/1137>`_.
 - ``xtensor`` default constructor and scalar assign fixed
-  `#1148 <https://github.com/QuantStack/xtensor/pull/1148>`_.
+  `#1148 <https://github.com/xtensor-stack/xtensor/pull/1148>`_.
 - Add ``resize / reshape`` to ``xfixed_container``
-  `#1147 <https://github.com/QuantStack/xtensor/pull/1147>`_.
+  `#1147 <https://github.com/xtensor-stack/xtensor/pull/1147>`_.
 - Iterable refactoring
-  `#1149 <https://github.com/QuantStack/xtensor/pull/1149>`_.
+  `#1149 <https://github.com/xtensor-stack/xtensor/pull/1149>`_.
 - ``inner_strides_type`` imported in ``xstrided_view``
-  `#1151 <https://github.com/QuantStack/xtensor/pull/1151>`_.
+  `#1151 <https://github.com/xtensor-stack/xtensor/pull/1151>`_.
 
 0.17.3
 ------
 
 - ``xslice`` fix
-  `#1099 <https://github.com/QuantStack/xtensor/pull/1099>`_.
+  `#1099 <https://github.com/xtensor-stack/xtensor/pull/1099>`_.
 - added missing ``static_layout`` in ``xmasked_view``
-  `#1100 <https://github.com/QuantStack/xtensor/pull/1100>`_.
+  `#1100 <https://github.com/xtensor-stack/xtensor/pull/1100>`_.
 
 0.17.2
 ------
 
 - Add experimental TBB support for parallelized multicore assign
-  `#948 <https://github.com/QuantStack/xtensor/pull/948>`_.
+  `#948 <https://github.com/xtensor-stack/xtensor/pull/948>`_.
 - Add inline statement to all functions in xnpy
-  `#1097 <https://github.com/QuantStack/xtensor/pull/1097>`_.
+  `#1097 <https://github.com/xtensor-stack/xtensor/pull/1097>`_.
 - Fix strided assign for certain assignments
-  `#1095 <https://github.com/QuantStack/xtensor/pull/1095>`_.
+  `#1095 <https://github.com/xtensor-stack/xtensor/pull/1095>`_.
 - CMake, remove gtest warnings
-  `#1085 <https://github.com/QuantStack/xtensor/pull/1085>`_.
+  `#1085 <https://github.com/xtensor-stack/xtensor/pull/1085>`_.
 - Add conversion operators to slices
-  `#1093 <https://github.com/QuantStack/xtensor/pull/1093>`_.
+  `#1093 <https://github.com/xtensor-stack/xtensor/pull/1093>`_.
 - Add optimization to unchecked accessors when contiguous layout is known
-  `#1060 <https://github.com/QuantStack/xtensor/pull/1060>`_.
+  `#1060 <https://github.com/xtensor-stack/xtensor/pull/1060>`_.
 - Speedup assign by computing ``any`` layout on vectors
-  `#1063 <https://github.com/QuantStack/xtensor/pull/1063>`_.
+  `#1063 <https://github.com/xtensor-stack/xtensor/pull/1063>`_.
 - Skip resizing for fixed shapes
-  `#1072 <https://github.com/QuantStack/xtensor/pull/1072>`_.
+  `#1072 <https://github.com/xtensor-stack/xtensor/pull/1072>`_.
 - Add xsimd apply to xcomplex functors (conj, norm, arg)
-  `#1086 <https://github.com/QuantStack/xtensor/pull/1086>`_.
+  `#1086 <https://github.com/xtensor-stack/xtensor/pull/1086>`_.
 - Propagate contiguous layout through views
-  `#1039 <https://github.com/QuantStack/xtensor/pull/1039>`_.
+  `#1039 <https://github.com/xtensor-stack/xtensor/pull/1039>`_.
 - Fix C++17 ambiguity for GCC 7
-  `#1081 <https://github.com/QuantStack/xtensor/pull/1081>`_.
+  `#1081 <https://github.com/xtensor-stack/xtensor/pull/1081>`_.
 - Correct shape type in argmin, fix svector growth
-  `#1079 <https://github.com/QuantStack/xtensor/pull/1079>`_.
+  `#1079 <https://github.com/xtensor-stack/xtensor/pull/1079>`_.
 - Add ``interp`` function to xmath
-  `#1071 <https://github.com/QuantStack/xtensor/pull/1071>`_.
+  `#1071 <https://github.com/xtensor-stack/xtensor/pull/1071>`_.
 - Fix valgrind warnings + memory leak in xadapt
-  `#1078 <https://github.com/QuantStack/xtensor/pull/1078>`_.
+  `#1078 <https://github.com/xtensor-stack/xtensor/pull/1078>`_.
 - Remove more clang warnings & errors on OS X
-  `#1077 <https://github.com/QuantStack/xtensor/pull/1077>`_.
+  `#1077 <https://github.com/xtensor-stack/xtensor/pull/1077>`_.
 - Add move constructor from xtensor <-> xarray
-  `#1051 <https://github.com/QuantStack/xtensor/pull/1051>`_.
+  `#1051 <https://github.com/xtensor-stack/xtensor/pull/1051>`_.
 - Add global support for negative axes in reducers/accumulators
   allow multiple axes in average
-  `#1010 <https://github.com/QuantStack/xtensor/pull/1010>`_.
+  `#1010 <https://github.com/xtensor-stack/xtensor/pull/1010>`_.
 - Fix reference usage in xio
-  `#1076 <https://github.com/QuantStack/xtensor/pull/1076>`_.
+  `#1076 <https://github.com/xtensor-stack/xtensor/pull/1076>`_.
 - Remove occurences of std::size_t and double
-  `#1073 <https://github.com/QuantStack/xtensor/pull/1073>`_.
+  `#1073 <https://github.com/xtensor-stack/xtensor/pull/1073>`_.
 - Add missing parantheses around min/max for MSVC
-  `#1061 <https://github.com/QuantStack/xtensor/pull/1061>`_.
+  `#1061 <https://github.com/xtensor-stack/xtensor/pull/1061>`_.
 
 0.17.1
 ------
 
 - Add std namespace to size_t everywhere, remove std::copysign for MSVC
-  `#1053 <https://github.com/QuantStack/xtensor/pull/1053>`_.
+  `#1053 <https://github.com/xtensor-stack/xtensor/pull/1053>`_.
 - Fix (wrong) bracket warnings for older clang versions (e.g. clang 5 on OS X)
-  `#1050 <https://github.com/QuantStack/xtensor/pull/1050>`_.
+  `#1050 <https://github.com/xtensor-stack/xtensor/pull/1050>`_.
 - Fix strided view on view by using std::addressof
-  `#1049 <https://github.com/QuantStack/xtensor/pull/1049>`_.
+  `#1049 <https://github.com/xtensor-stack/xtensor/pull/1049>`_.
 - Add more adapt functions and shorthands
-  `#1043 <https://github.com/QuantStack/xtensor/pull/1043>`_.
+  `#1043 <https://github.com/xtensor-stack/xtensor/pull/1043>`_.
 - Improve CRTP base class detection
-  `#1041 <https://github.com/QuantStack/xtensor/pull/1041>`_.
+  `#1041 <https://github.com/xtensor-stack/xtensor/pull/1041>`_.
 - Fix rebind container ambiguous template for C++17 / GCC 8 regression
-  `#1038 <https://github.com/QuantStack/xtensor/pull/1038>`_.
+  `#1038 <https://github.com/xtensor-stack/xtensor/pull/1038>`_.
 - Fix functor return value
-  `#1035 <https://github.com/QuantStack/xtensor/pull/1035>`_.
+  `#1035 <https://github.com/xtensor-stack/xtensor/pull/1035>`_.
 
 0.17.0
 ------
@@ -228,169 +1672,169 @@ Breaking changes
 ~~~~~~~~~~~~~~~~
 
 - Changed strides to ``std::ptrdiff_t``
-  `#925 <https://github.com/QuantStack/xtensor/pull/925>`_.
+  `#925 <https://github.com/xtensor-stack/xtensor/pull/925>`_.
 - Renamed ``count_nonzeros`` in ``count_nonzero``
-  `#974 <https://github.com/QuantStack/xtensor/pull/974>`_.
+  `#974 <https://github.com/xtensor-stack/xtensor/pull/974>`_.
 - homogenize ``xfixed`` constructors
-  `#970 <https://github.com/QuantStack/xtensor/pull/970>`_.
+  `#970 <https://github.com/xtensor-stack/xtensor/pull/970>`_.
 - Improve ``random::choice``
-  `#1011 <https://github.com/QuantStack/xtensor/pull/1011>`_.
+  `#1011 <https://github.com/xtensor-stack/xtensor/pull/1011>`_.
 
 New features
 ~~~~~~~~~~~~
 
 - add ``signed char`` to npy deserialization format
-  `#1017 <https://github.com/QuantStack/xtensor/pull/1017>`_.
+  `#1017 <https://github.com/xtensor-stack/xtensor/pull/1017>`_.
 - simd assignment now requires convertible types instead of same type
-  `#1000 <https://github.com/QuantStack/xtensor/pull/1000>`_.
+  `#1000 <https://github.com/xtensor-stack/xtensor/pull/1000>`_.
 - shared expression and automatic xclosure detection
-  `#992 <https://github.com/QuantStack/xtensor/pull/992>`_.
+  `#992 <https://github.com/xtensor-stack/xtensor/pull/992>`_.
 - average function
-  `#987 <https://github.com/QuantStack/xtensor/pull/987>`_.
+  `#987 <https://github.com/xtensor-stack/xtensor/pull/987>`_.
 - added simd support for complex
-  `#985 <https://github.com/QuantStack/xtensor/pull/985>`_.
+  `#985 <https://github.com/xtensor-stack/xtensor/pull/985>`_.
 - argsort function
-  `#977 <https://github.com/QuantStack/xtensor/pull/977>`_.
+  `#977 <https://github.com/xtensor-stack/xtensor/pull/977>`_.
 - propagate fixed shape
-  `#922 <https://github.com/QuantStack/xtensor/pull/922>`_.
+  `#922 <https://github.com/xtensor-stack/xtensor/pull/922>`_.
 - added xdrop_slice
-  `#972 <https://github.com/QuantStack/xtensor/pull/972>`_.
+  `#972 <https://github.com/xtensor-stack/xtensor/pull/972>`_.
 - added doc for ``xmasked_view``
-  `#971 <https://github.com/QuantStack/xtensor/pull/971>`_.
+  `#971 <https://github.com/xtensor-stack/xtensor/pull/971>`_.
 - added ``xmasked_view``
-  `#969 <https://github.com/QuantStack/xtensor/pull/969>`_.
+  `#969 <https://github.com/xtensor-stack/xtensor/pull/969>`_.
 - added ``dynamic_view``
-  `#966 <https://github.com/QuantStack/xtensor/pull/966>`_.
+  `#966 <https://github.com/xtensor-stack/xtensor/pull/966>`_.
 - added ability to use negative indices in keep slice
-  `#964 <https://github.com/QuantStack/xtensor/pull/964>`_.
+  `#964 <https://github.com/xtensor-stack/xtensor/pull/964>`_.
 - added an easy way to create lambda expressions, square and cube
-  `#961 <https://github.com/QuantStack/xtensor/pull/961>`_.
+  `#961 <https://github.com/xtensor-stack/xtensor/pull/961>`_.
 - noalias on rvalue
-  `#965 <https://github.com/QuantStack/xtensor/pull/965>`_.
+  `#965 <https://github.com/xtensor-stack/xtensor/pull/965>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - ``xshared_expression`` fixed
-  `#1025 <https://github.com/QuantStack/xtensor/pull/1025>`_.
+  `#1025 <https://github.com/xtensor-stack/xtensor/pull/1025>`_.
 - fix ``make_xshared``
-  `#1024 <https://github.com/QuantStack/xtensor/pull/1024>`_.
+  `#1024 <https://github.com/xtensor-stack/xtensor/pull/1024>`_.
 - add tests to evaluate shared expressions
-  `#1019 <https://github.com/QuantStack/xtensor/pull/1019>`_.
+  `#1019 <https://github.com/xtensor-stack/xtensor/pull/1019>`_.
 - fix ``where`` on ``xview``
-  `#1012 <https://github.com/QuantStack/xtensor/pull/1012>`_.
+  `#1012 <https://github.com/xtensor-stack/xtensor/pull/1012>`_.
 - basic usage replaced with getting started
-  `#1004 <https://github.com/QuantStack/xtensor/pull/1004>`_.
+  `#1004 <https://github.com/xtensor-stack/xtensor/pull/1004>`_.
 - avoided installation failure in absence of ``nlohmann_json``
-  `#1001 <https://github.com/QuantStack/xtensor/pull/1001>`_.
+  `#1001 <https://github.com/xtensor-stack/xtensor/pull/1001>`_.
 - code and documentation clean up
-  `#998 <https://github.com/QuantStack/xtensor/pull/998>`_.
+  `#998 <https://github.com/xtensor-stack/xtensor/pull/998>`_.
 - removed g++ "pedantic" compiler warnings
-  `#997 <https://github.com/QuantStack/xtensor/pull/997>`_.
+  `#997 <https://github.com/xtensor-stack/xtensor/pull/997>`_.
 - added missing header in basic_usage.rst
-  `#996 <https://github.com/QuantStack/xtensor/pull/996>`_.
+  `#996 <https://github.com/xtensor-stack/xtensor/pull/996>`_.
 - warning pass
-  `#990 <https://github.com/QuantStack/xtensor/pull/990>`_.
+  `#990 <https://github.com/xtensor-stack/xtensor/pull/990>`_.
 - added missing include in ``xview``
-  `#989 <https://github.com/QuantStack/xtensor/pull/989>`_.
+  `#989 <https://github.com/xtensor-stack/xtensor/pull/989>`_.
 - added missing ``<map>`` include
-  `#983 <https://github.com/QuantStack/xtensor/pull/983>`_.
+  `#983 <https://github.com/xtensor-stack/xtensor/pull/983>`_.
 - xislice refactoring
-  `#962 <https://github.com/QuantStack/xtensor/pull/962>`_.
+  `#962 <https://github.com/xtensor-stack/xtensor/pull/962>`_.
 - added missing operators to noalias
-  `#932 <https://github.com/QuantStack/xtensor/pull/932>`_.
+  `#932 <https://github.com/xtensor-stack/xtensor/pull/932>`_.
 - cmake fix for Intel compiler on Windows
-  `#951 <https://github.com/QuantStack/xtensor/pull/951>`_.
+  `#951 <https://github.com/xtensor-stack/xtensor/pull/951>`_.
 - fixed xsimd abs deduction
-  `#946 <https://github.com/QuantStack/xtensor/pull/946>`_.
+  `#946 <https://github.com/xtensor-stack/xtensor/pull/946>`_.
 - added islice example to view doc
-  `#940 <https://github.com/QuantStack/xtensor/pull/940>`_.
+  `#940 <https://github.com/xtensor-stack/xtensor/pull/940>`_.
 
 0.16.4
 ------
 
 - removed usage of ``std::transfomr`` in assign
-  `#868 <https://github.com/QuantStack/xtensor/pull/868>`_.
+  `#868 <https://github.com/xtensor-stack/xtensor/pull/868>`_.
 - add strided assignment
-  `#901 <https://github.com/QuantStack/xtensor/pull/901>`_.
+  `#901 <https://github.com/xtensor-stack/xtensor/pull/901>`_.
 - simd activated for conditional ternary functor
-  `#903 <https://github.com/QuantStack/xtensor/pull/903>`_.
+  `#903 <https://github.com/xtensor-stack/xtensor/pull/903>`_.
 - ``xstrided_view`` split
-  `#905 <https://github.com/QuantStack/xtensor/pull/905>`_.
+  `#905 <https://github.com/xtensor-stack/xtensor/pull/905>`_.
 - assigning an expression to a view throws if it has more dimensions
-  `#910 <https://github.com/QuantStack/xtensor/pull/910>`_.
+  `#910 <https://github.com/xtensor-stack/xtensor/pull/910>`_.
 - faster random
-  `#913 <https://github.com/QuantStack/xtensor/pull/913>`_.
+  `#913 <https://github.com/xtensor-stack/xtensor/pull/913>`_.
 - ``xoptional_assembly_base`` storage type
-  `#915 <https://github.com/QuantStack/xtensor/pull/915>`_.
+  `#915 <https://github.com/xtensor-stack/xtensor/pull/915>`_.
 - new tests and warning pass
-  `#916 <https://github.com/QuantStack/xtensor/pull/916>`_.
+  `#916 <https://github.com/xtensor-stack/xtensor/pull/916>`_.
 - norm immediate reducer
-  `#924 <https://github.com/QuantStack/xtensor/pull/924>`_.
+  `#924 <https://github.com/xtensor-stack/xtensor/pull/924>`_.
 - add ``reshape_view``
-  `#927 <https://github.com/QuantStack/xtensor/pull/927>`_.
+  `#927 <https://github.com/xtensor-stack/xtensor/pull/927>`_.
 - fix immediate reducers with 0 strides
-  `#935 <https://github.com/QuantStack/xtensor/pull/935>`_.
+  `#935 <https://github.com/xtensor-stack/xtensor/pull/935>`_.
 
 0.16.3
 ------
 
 - simd on mathematical functions fixed
-  `#886 <https://github.com/QuantStack/xtensor/pull/886>`_.
+  `#886 <https://github.com/xtensor-stack/xtensor/pull/886>`_.
 - ``fill`` method added to containers
-  `#887 <https://github.com/QuantStack/xtensor/pull/887>`_.
+  `#887 <https://github.com/xtensor-stack/xtensor/pull/887>`_.
 - access with more arguments than dimensions
-  `#889 <https://github.com/QuantStack/xtensor/pull/889>`_.
+  `#889 <https://github.com/xtensor-stack/xtensor/pull/889>`_.
 - unchecked method implemented
-  `#890 <https://github.com/QuantStack/xtensor/pull/890>`_.
+  `#890 <https://github.com/xtensor-stack/xtensor/pull/890>`_.
 - ``fill`` method implemented in view
-  `#893 <https://github.com/QuantStack/xtensor/pull/893>`_.
+  `#893 <https://github.com/xtensor-stack/xtensor/pull/893>`_.
 - documentation fixed and warnings removed
-  `#894 <https://github.com/QuantStack/xtensor/pull/894>`_.
+  `#894 <https://github.com/xtensor-stack/xtensor/pull/894>`_.
 - negative slices and new range syntax
-  `#895 <https://github.com/QuantStack/xtensor/pull/895>`_.
+  `#895 <https://github.com/xtensor-stack/xtensor/pull/895>`_.
 - ``xview_stepper`` with implicit ``xt::all`` bug fix
-  `#899 <https://github.com/QuantStack/xtensor/pull/899>`_.
+  `#899 <https://github.com/xtensor-stack/xtensor/pull/899>`_.
 
 0.16.2
 ------
 
 - Add include of ``xview.hpp`` in example
-  `#884 <https://github.com/QuantStack/xtensor/pull/884>`_.
+  `#884 <https://github.com/xtensor-stack/xtensor/pull/884>`_.
 - Remove ``FS`` identifier
-  `#885 <https://github.com/QuantStack/xtensor/pull/885>`_.
+  `#885 <https://github.com/xtensor-stack/xtensor/pull/885>`_.
 
 0.16.1
 ------
 
 - Workaround for Visual Studio Bug
-  `#858 <https://github.com/QuantStack/xtensor/pull/858>`_.
+  `#858 <https://github.com/xtensor-stack/xtensor/pull/858>`_.
 - Fixup example notebook
-  `#861 <https://github.com/QuantStack/xtensor/pull/861>`_.
+  `#861 <https://github.com/xtensor-stack/xtensor/pull/861>`_.
 - Prevent expansion of min and max macros on Windows
-  `#863 <https://github.com/QuantStack/xtensor/pull/863>`_.
+  `#863 <https://github.com/xtensor-stack/xtensor/pull/863>`_.
 - Renamed ``m_data`` to ``m_storage``
-  `#864 <https://github.com/QuantStack/xtensor/pull/864>`_.
+  `#864 <https://github.com/xtensor-stack/xtensor/pull/864>`_.
 - Fix regression with respect to random access stepping with views
-  `#865 <https://github.com/QuantStack/xtensor/pull/865>`_.
+  `#865 <https://github.com/xtensor-stack/xtensor/pull/865>`_.
 - Remove use of CS, DS and ES qualifiers for Solaris builds
-  `#866 <https://github.com/QuantStack/xtensor/pull/866>`_.
+  `#866 <https://github.com/xtensor-stack/xtensor/pull/866>`_.
 - Removal of precision type
-  `#870 <https://github.com/QuantStack/xtensor/pull/870>`_.
+  `#870 <https://github.com/xtensor-stack/xtensor/pull/870>`_.
 - Make json tests optional, bump xtl/xsimd versions
-  `#871 <https://github.com/QuantStack/xtensor/pull/871>`_.
+  `#871 <https://github.com/xtensor-stack/xtensor/pull/871>`_.
 - Add more benchmarks
-  `#876 <https://github.com/QuantStack/xtensor/pull/876>`_.
+  `#876 <https://github.com/xtensor-stack/xtensor/pull/876>`_.
 - Forbid simd fixed
-  `#877 <https://github.com/QuantStack/xtensor/pull/877>`_.
+  `#877 <https://github.com/xtensor-stack/xtensor/pull/877>`_.
 - Add more asserts
-  `#879 <https://github.com/QuantStack/xtensor/pull/879>`_.
+  `#879 <https://github.com/xtensor-stack/xtensor/pull/879>`_.
 - Add missing ``batch_bool`` typedef
-  `#881 <https://github.com/QuantStack/xtensor/pull/881>`_.
+  `#881 <https://github.com/xtensor-stack/xtensor/pull/881>`_.
 - ``simd_return_type`` hack removed
-  `#882 <https://github.com/QuantStack/xtensor/pull/882>`_.
+  `#882 <https://github.com/xtensor-stack/xtensor/pull/882>`_.
 - Removed test guard and fixed dimension check in ``xscalar``
-  `#883 <https://github.com/QuantStack/xtensor/pull/883>`_.
+  `#883 <https://github.com/xtensor-stack/xtensor/pull/883>`_.
 
 0.16.0
 ------
@@ -399,265 +1843,265 @@ Breaking changes
 ~~~~~~~~~~~~~~~~
 
 - ``data`` renamed in ``storage``, ``raw_data`` renamed in ``data``
-  `#792 <https://github.com/QuantStack/xtensor/pull/792>`_.
+  `#792 <https://github.com/xtensor-stack/xtensor/pull/792>`_.
 - Added layout template parameter to ``xstrided_view``
-  `#796 <https://github.com/QuantStack/xtensor/pull/796>`_.
+  `#796 <https://github.com/xtensor-stack/xtensor/pull/796>`_.
 - Remove equality operator from stepper
-  `#824 <https://github.com/QuantStack/xtensor/pull/824>`_.
+  `#824 <https://github.com/xtensor-stack/xtensor/pull/824>`_.
 - ``dynamic_view`` renamed in ``strided_view``
-  `#832 <https://github.com/QuantStack/xtensor/pull/832>`_.
+  `#832 <https://github.com/xtensor-stack/xtensor/pull/832>`_.
 - ``xtensorf`` renamed in ``xtensor_fixed``
-  `#846 <https://github.com/QuantStack/xtensor/pull/846>`_.
+  `#846 <https://github.com/xtensor-stack/xtensor/pull/846>`_.
 
 New features
 ~~~~~~~~~~~~
 
 - Added strided view selector
-  `#765 <https://github.com/QuantStack/xtensor/pull/765>`_.
+  `#765 <https://github.com/xtensor-stack/xtensor/pull/765>`_.
 - Added ``count_nonzeros``
-  `#781 <https://github.com/QuantStack/xtensor/pull/781>`_.
+  `#781 <https://github.com/xtensor-stack/xtensor/pull/781>`_.
 - Added implicit conversion to scalar in ``xview``
-  `#788 <https://github.com/QuantStack/xtensor/pull/788>`_.
+  `#788 <https://github.com/xtensor-stack/xtensor/pull/788>`_.
 - Added tracking allocators to ``xutils.hpp``
-  `#789 <https://github.com/QuantStack/xtensor/pull/789>`_.
+  `#789 <https://github.com/xtensor-stack/xtensor/pull/789>`_.
 - ``xindexslice`` and ``shuffle`` function
-  `#804 <https://github.com/QuantStack/xtensor/pull/804>`_.
+  `#804 <https://github.com/xtensor-stack/xtensor/pull/804>`_.
 - Allow ``xadapt`` with dynamic layout
-  `#816 <https://github.com/QuantStack/xtensor/pull/816>`_.
+  `#816 <https://github.com/xtensor-stack/xtensor/pull/816>`_.
 - Added ``xtensorf`` initialization from C array
-  `#819 <https://github.com/QuantStack/xtensor/pull/819>`_.
+  `#819 <https://github.com/xtensor-stack/xtensor/pull/819>`_.
 - Added policy to allocation tracking for throw option
-  `#820 <https://github.com/QuantStack/xtensor/pull/820>`_.
+  `#820 <https://github.com/xtensor-stack/xtensor/pull/820>`_.
 - Free function ``empty`` for construction from shape
-  `#827 <https://github.com/QuantStack/xtensor/pull/827>`_.
+  `#827 <https://github.com/xtensor-stack/xtensor/pull/827>`_.
 - Support for JSON serialization and deserialization of xtensor expressions
-  `#830 <https://github.com/QuantStack/xtensor/pull/830>`_.
+  `#830 <https://github.com/xtensor-stack/xtensor/pull/830>`_.
 - Add ``trapz`` function
-  `#837 <https://github.com/QuantStack/xtensor/pull/837>`_.
+  `#837 <https://github.com/xtensor-stack/xtensor/pull/837>`_.
 - Add ``diff`` and ``trapz(y, x)`` functions
-  `#841 <https://github.com/QuantStack/xtensor/pull/841>`_.
+  `#841 <https://github.com/xtensor-stack/xtensor/pull/841>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - Added fast path for specific assigns
-  `#767 <https://github.com/QuantStack/xtensor/pull/767>`_.
+  `#767 <https://github.com/xtensor-stack/xtensor/pull/767>`_.
 - Renamed internal macros to prevent collisions
-  `#772 <https://github.com/QuantStack/xtensor/pull/772>`_.
+  `#772 <https://github.com/xtensor-stack/xtensor/pull/772>`_.
 - ``dynamic_view`` unwrapping
-  `#775 <https://github.com/QuantStack/xtensor/pull/775>`_.
+  `#775 <https://github.com/xtensor-stack/xtensor/pull/775>`_.
 - ``xreducer_stepper`` copy semantic fixed
-  `#785 <https://github.com/QuantStack/xtensor/pull/785>`_.
+  `#785 <https://github.com/xtensor-stack/xtensor/pull/785>`_.
 - ``xfunction`` copy constructor fixed
-  `#787 <https://github.com/QuantStack/xtensor/pull/787>`_.
+  `#787 <https://github.com/xtensor-stack/xtensor/pull/787>`_.
 - warnings removed
-  `#791 <https://github.com/QuantStack/xtensor/pull/791>`_.
+  `#791 <https://github.com/xtensor-stack/xtensor/pull/791>`_.
 - ``xscalar_stepper`` fixed
-  `#802 <https://github.com/QuantStack/xtensor/pull/802>`_.
+  `#802 <https://github.com/xtensor-stack/xtensor/pull/802>`_.
 - Fixup ``xadapt`` on const pointers
-  `#809 <https://github.com/QuantStack/xtensor/pull/809>`_.
+  `#809 <https://github.com/xtensor-stack/xtensor/pull/809>`_.
 - Fix in owning buffer adaptors
-  `#810 <https://github.com/QuantStack/xtensor/pull/810>`_.
+  `#810 <https://github.com/xtensor-stack/xtensor/pull/810>`_.
 - Macros fixup
-  `#812 <https://github.com/QuantStack/xtensor/pull/812>`_.
+  `#812 <https://github.com/xtensor-stack/xtensor/pull/812>`_.
 - More fixes in ``xadapt``
-  `#813 <https://github.com/QuantStack/xtensor/pull/813>`_.
+  `#813 <https://github.com/xtensor-stack/xtensor/pull/813>`_.
 - Mute unused variable warning
-  `#815 <https://github.com/QuantStack/xtensor/pull/815>`_.
+  `#815 <https://github.com/xtensor-stack/xtensor/pull/815>`_.
 - Remove comparison of steppers in assign loop
-  `#823 <https://github.com/QuantStack/xtensor/pull/823>`_.
+  `#823 <https://github.com/xtensor-stack/xtensor/pull/823>`_.
 - Fix reverse iterators
-  `#825 <https://github.com/QuantStack/xtensor/pull/825>`_.
+  `#825 <https://github.com/xtensor-stack/xtensor/pull/825>`_.
 - gcc-8 fix for template method calls
-  `#833 <https://github.com/QuantStack/xtensor/pull/833>`_.
+  `#833 <https://github.com/xtensor-stack/xtensor/pull/833>`_.
 - refactor benchmarks for upcoming release
-  `#842 <https://github.com/QuantStack/xtensor/pull/842>`_.
+  `#842 <https://github.com/xtensor-stack/xtensor/pull/842>`_.
 - ``flip`` now returns a view
-  `#843 <https://github.com/QuantStack/xtensor/pull/843>`_.
+  `#843 <https://github.com/xtensor-stack/xtensor/pull/843>`_.
 - initial warning pass
-  `#850 <https://github.com/QuantStack/xtensor/pull/850>`_.
+  `#850 <https://github.com/xtensor-stack/xtensor/pull/850>`_.
 - Fix warning on diff function
-  `#851 <https://github.com/QuantStack/xtensor/pull/851>`_.
+  `#851 <https://github.com/xtensor-stack/xtensor/pull/851>`_.
 - xsimd assignment fixed
-  `#852 <https://github.com/QuantStack/xtensor/pull/852>`_.
+  `#852 <https://github.com/xtensor-stack/xtensor/pull/852>`_.
 
 0.15.9
 ------
 
 - missing layout method in xfixed
-  `#777 <https://github.com/QuantStack/xtensor/pull/777>`_.
+  `#777 <https://github.com/xtensor-stack/xtensor/pull/777>`_.
 - fixed uninitialized backstrides
-  `#774 <https://github.com/QuantStack/xtensor/pull/774>`_.
+  `#774 <https://github.com/xtensor-stack/xtensor/pull/774>`_.
 - update xtensor-blas in binder
-  `#773 <https://github.com/QuantStack/xtensor/pull/773>`_.
+  `#773 <https://github.com/xtensor-stack/xtensor/pull/773>`_.
 
 0.15.8
 ------
 
 - comparison operators for slices
-  `#770 <https://github.com/QuantStack/xtensor/pull/770>`_.
+  `#770 <https://github.com/xtensor-stack/xtensor/pull/770>`_.
 - use default-assignable layout for strided views.
-  `#769 <https://github.com/QuantStack/xtensor/pull/769>`_.
+  `#769 <https://github.com/xtensor-stack/xtensor/pull/769>`_.
 
 0.15.7
 ------
 
 - nan related functions
-  `#718 <https://github.com/QuantStack/xtensor/pull/718>`_.
+  `#718 <https://github.com/xtensor-stack/xtensor/pull/718>`_.
 - return types fixed in dynamic view helper
-  `#722 <https://github.com/QuantStack/xtensor/pull/722>`_.
+  `#722 <https://github.com/xtensor-stack/xtensor/pull/722>`_.
 - xview on constant expressions
-  `#723 <https://github.com/QuantStack/xtensor/pull/723>`_.
+  `#723 <https://github.com/xtensor-stack/xtensor/pull/723>`_.
 - added decays to make const ``value_type`` compile
-  `#727 <https://github.com/QuantStack/xtensor/pull/727>`_.
+  `#727 <https://github.com/xtensor-stack/xtensor/pull/727>`_.
 - iterator for constant ``strided_view`` fixed
-  `#729 <https://github.com/QuantStack/xtensor/pull/729>`_.
+  `#729 <https://github.com/xtensor-stack/xtensor/pull/729>`_.
 - ``strided_view`` on ``xfunction`` fixed
-  `#732 <https://github.com/QuantStack/xtensor/pull/732>`_.
+  `#732 <https://github.com/xtensor-stack/xtensor/pull/732>`_.
 - Fixes in ``xstrided_view``
-  `#736 <https://github.com/QuantStack/xtensor/pull/736>`_.
+  `#736 <https://github.com/xtensor-stack/xtensor/pull/736>`_.
 - View semantic (broadcast on assign) fixed
-  `#742 <https://github.com/QuantStack/xtensor/pull/742>`_.
+  `#742 <https://github.com/xtensor-stack/xtensor/pull/742>`_.
 - Compilation prevented when using ellipsis with ``xview``
-  `#743 <https://github.com/QuantStack/xtensor/pull/743>`_.
+  `#743 <https://github.com/xtensor-stack/xtensor/pull/743>`_.
 - Index of ``xiterator`` set to shape when reaching the end
-  `#744 <https://github.com/QuantStack/xtensor/pull/744>`_.
+  `#744 <https://github.com/xtensor-stack/xtensor/pull/744>`_.
 - ``xscalar`` fixed
-  `#748 <https://github.com/QuantStack/xtensor/pull/748>`_.
+  `#748 <https://github.com/xtensor-stack/xtensor/pull/748>`_.
 - Updated README and related projects
-  `#749 <https://github.com/QuantStack/xtensor/pull/749>`_.
+  `#749 <https://github.com/xtensor-stack/xtensor/pull/749>`_.
 - Perfect forwarding in ``xfunction``  and views
-  `#750 <https://github.com/QuantStack/xtensor/pull/750>`_.
+  `#750 <https://github.com/xtensor-stack/xtensor/pull/750>`_.
 - Missing include in ``xassign.hpp``
-  `#752 <https://github.com/QuantStack/xtensor/pull/752>`_.
+  `#752 <https://github.com/xtensor-stack/xtensor/pull/752>`_.
 - More related projects in the README
-  `#754 <https://github.com/QuantStack/xtensor/pull/754>`_.
+  `#754 <https://github.com/xtensor-stack/xtensor/pull/754>`_.
 - Fixed stride computation for ``xtensorf``
-  `#755 <https://github.com/QuantStack/xtensor/pull/755>`_.
+  `#755 <https://github.com/xtensor-stack/xtensor/pull/755>`_.
 - Added tests for backstrides
-  `#758 <https://github.com/QuantStack/xtensor/pull/758>`_.
+  `#758 <https://github.com/xtensor-stack/xtensor/pull/758>`_.
 - Clean up ``has_raw_data`` ins strided view
-  `#759 <https://github.com/QuantStack/xtensor/pull/759>`_.
+  `#759 <https://github.com/xtensor-stack/xtensor/pull/759>`_.
 - Switch to ``ptrdiff_t`` for slices
-  `#760 <https://github.com/QuantStack/xtensor/pull/760>`_.
+  `#760 <https://github.com/xtensor-stack/xtensor/pull/760>`_.
 - Fixed ``xview`` strides computation
-  `#762 <https://github.com/QuantStack/xtensor/pull/762>`_.
+  `#762 <https://github.com/xtensor-stack/xtensor/pull/762>`_.
 - Additional methods in slices, required for ``xframe``
-  `#764 <https://github.com/QuantStack/xtensor/pull/764>`_.
+  `#764 <https://github.com/xtensor-stack/xtensor/pull/764>`_.
 
 0.15.6
 ------
 
 - zeros, ones, full and empty_like functions
-  `#686 <https://github.com/QuantStack/xtensor/pull/686>`_.
+  `#686 <https://github.com/xtensor-stack/xtensor/pull/686>`_.
 - squeeze view
-  `#687 <https://github.com/QuantStack/xtensor/pull/687>`_.
+  `#687 <https://github.com/xtensor-stack/xtensor/pull/687>`_.
 - bitwise shift left and shift right
-  `#688 <https://github.com/QuantStack/xtensor/pull/688>`_.
+  `#688 <https://github.com/xtensor-stack/xtensor/pull/688>`_.
 - ellipsis, unique and trim functions
-  `#689 <https://github.com/QuantStack/xtensor/pull/689>`_.
+  `#689 <https://github.com/xtensor-stack/xtensor/pull/689>`_.
 - xview iterator benchmark
-  `#696 <https://github.com/QuantStack/xtensor/pull/696>`_.
+  `#696 <https://github.com/xtensor-stack/xtensor/pull/696>`_.
 - optimize stepper increment
-  `#697 <https://github.com/QuantStack/xtensor/pull/697>`_.
+  `#697 <https://github.com/xtensor-stack/xtensor/pull/697>`_.
 - minmax reducers
-  `#698 <https://github.com/QuantStack/xtensor/pull/698>`_.
+  `#698 <https://github.com/xtensor-stack/xtensor/pull/698>`_.
 - where fix with SIMD
-  `#704 <https://github.com/QuantStack/xtensor/pull/704>`_.
+  `#704 <https://github.com/xtensor-stack/xtensor/pull/704>`_.
 - additional doc for scalars and views
-  `#705 <https://github.com/QuantStack/xtensor/pull/705>`_.
+  `#705 <https://github.com/xtensor-stack/xtensor/pull/705>`_.
 - mixed arithmetic with SIMD
-  `#713 <https://github.com/QuantStack/xtensor/pull/713>`_.
+  `#713 <https://github.com/xtensor-stack/xtensor/pull/713>`_.
 - broadcast fixed
-  `#717 <https://github.com/QuantStack/xtensor/pull/717>`_.
+  `#717 <https://github.com/xtensor-stack/xtensor/pull/717>`_.
 
 0.15.5
 ------
 
 - assign functions optimized
-  `#650 <https://github.com/QuantStack/xtensor/pull/650>`_.
+  `#650 <https://github.com/xtensor-stack/xtensor/pull/650>`_.
 - transposed view fixed
-  `#652 <https://github.com/QuantStack/xtensor/pull/652>`_.
+  `#652 <https://github.com/xtensor-stack/xtensor/pull/652>`_.
 - exceptions refactoring
-  `#654 <https://github.com/QuantStack/xtensor/pull/654>`_.
+  `#654 <https://github.com/xtensor-stack/xtensor/pull/654>`_.
 - performances improved
-  `#655 <https://github.com/QuantStack/xtensor/pull/655>`_.
+  `#655 <https://github.com/xtensor-stack/xtensor/pull/655>`_.
 - view data accessor fixed
-  `#660 <https://github.com/QuantStack/xtensor/pull/660>`_.
+  `#660 <https://github.com/xtensor-stack/xtensor/pull/660>`_.
 - new dynamic view using variant
-  `#656 <https://github.com/QuantStack/xtensor/pull/656>`_.
+  `#656 <https://github.com/xtensor-stack/xtensor/pull/656>`_.
 - alignment added to fixed xtensor
-  `#659 <https://github.com/QuantStack/xtensor/pull/659>`_.
+  `#659 <https://github.com/xtensor-stack/xtensor/pull/659>`_.
 - code cleanup
-  `#664 <https://github.com/QuantStack/xtensor/pull/664>`_.
+  `#664 <https://github.com/xtensor-stack/xtensor/pull/664>`_.
 - xtensorf and new dynamic view documentation
-  `#667 <https://github.com/QuantStack/xtensor/pull/667>`_.
+  `#667 <https://github.com/xtensor-stack/xtensor/pull/667>`_.
 - qualify namespace for compute_size
-  `#665 <https://github.com/QuantStack/xtensor/pull/665>`_.
+  `#665 <https://github.com/xtensor-stack/xtensor/pull/665>`_.
 - make xio use ``dynamic_view`` instead of ``view``
-  `#662 <https://github.com/QuantStack/xtensor/pull/662>`_.
+  `#662 <https://github.com/xtensor-stack/xtensor/pull/662>`_.
 - transposed view on any expression
-  `#671 <https://github.com/QuantStack/xtensor/pull/671>`_.
+  `#671 <https://github.com/xtensor-stack/xtensor/pull/671>`_.
 - docs typos and grammar plus formatting
-  `#676 <https://github.com/QuantStack/xtensor/pull/676>`_.
+  `#676 <https://github.com/xtensor-stack/xtensor/pull/676>`_.
 - index view test assertion fixed
-  `#680 <https://github.com/QuantStack/xtensor/pull/680>`_.
+  `#680 <https://github.com/xtensor-stack/xtensor/pull/680>`_.
 - flatten view
-  `#678 <https://github.com/QuantStack/xtensor/pull/678>`_.
+  `#678 <https://github.com/xtensor-stack/xtensor/pull/678>`_.
 - handle the case of pointers to const element in ``xadapt``
-  `#679 <https://github.com/QuantStack/xtensor/pull/679>`_.
+  `#679 <https://github.com/xtensor-stack/xtensor/pull/679>`_.
 - use quotes in #include statements for xtl
-  `#681 <https://github.com/QuantStack/xtensor/pull/681>`_.
+  `#681 <https://github.com/xtensor-stack/xtensor/pull/681>`_.
 - additional constructors for ``svector``
-  `#682 <https://github.com/QuantStack/xtensor/pull/682>`_.
+  `#682 <https://github.com/xtensor-stack/xtensor/pull/682>`_.
 - removed ``test_xsemantics.hpp`` from test CMakeLists
-  `#684 <https://github.com/QuantStack/xtensor/pull/684>`_.
+  `#684 <https://github.com/xtensor-stack/xtensor/pull/684>`_.
 
 0.15.4
 ------
 
 - fix gcc-7 error w.r.t. the use of ``assert``
-  `#648 <https://github.com/QuantStack/xtensor/pull/648>`_.
+  `#648 <https://github.com/xtensor-stack/xtensor/pull/648>`_.
 
 0.15.3
 ------
 
 - add missing headers to cmake installation and tests
-  `#647 <https://github.com/QuantStack/xtensor/pull/647>`_.
+  `#647 <https://github.com/xtensor-stack/xtensor/pull/647>`_.
 
 
 0.15.2
 ------
 
 - ``xshape`` implementation
-  `#572 <https://github.com/QuantStack/xtensor/pull/572>`_.
+  `#572 <https://github.com/xtensor-stack/xtensor/pull/572>`_.
 - xfixed container
-  `#586 <https://github.com/QuantStack/xtensor/pull/586>`_.
+  `#586 <https://github.com/xtensor-stack/xtensor/pull/586>`_.
 - protected ``xcontainer::derived_cast``
-  `#627 <https://github.com/QuantStack/xtensor/pull/627>`_.
+  `#627 <https://github.com/xtensor-stack/xtensor/pull/627>`_.
 - const reference fix
-  `#632 <https://github.com/QuantStack/xtensor/pull/632>`_.
+  `#632 <https://github.com/xtensor-stack/xtensor/pull/632>`_.
 - ``xgenerator`` access operators fixed
-  `#643 <https://github.com/QuantStack/xtensor/pull/643>`_.
+  `#643 <https://github.com/xtensor-stack/xtensor/pull/643>`_.
 - contiguous layout optiimzation
-  `#645 <https://github.com/QuantStack/xtensor/pull/645>`_.
+  `#645 <https://github.com/xtensor-stack/xtensor/pull/645>`_.
 
 
 0.15.1
 ------
 
 - ``xarray_adaptor`` fixed
-  `#618 <https://github.com/QuantStack/xtensor/pull/618>`_.
+  `#618 <https://github.com/xtensor-stack/xtensor/pull/618>`_.
 - ``xtensor_adaptor`` fixed
-  `#620 <https://github.com/QuantStack/xtensor/pull/620>`_.
+  `#620 <https://github.com/xtensor-stack/xtensor/pull/620>`_.
 - fix in ``xreducer`` steppers
-  `#622 <https://github.com/QuantStack/xtensor/pull/622>`_.
+  `#622 <https://github.com/xtensor-stack/xtensor/pull/622>`_.
 - documentation improved
-  `#621 <https://github.com/QuantStack/xtensor/pull/621>`_.
-  `#623 <https://github.com/QuantStack/xtensor/pull/623>`_.
-  `#625 <https://github.com/QuantStack/xtensor/pull/625>`_.
+  `#621 <https://github.com/xtensor-stack/xtensor/pull/621>`_.
+  `#623 <https://github.com/xtensor-stack/xtensor/pull/623>`_.
+  `#625 <https://github.com/xtensor-stack/xtensor/pull/625>`_.
 - warnings removed
-  `#624 <https://github.com/QuantStack/xtensor/pull/624>`_.
+  `#624 <https://github.com/xtensor-stack/xtensor/pull/624>`_.
 
 0.15.0
 ------
@@ -666,34 +2110,34 @@ Breaking changes
 ~~~~~~~~~~~~~~~~
 
 - change ``reshape`` to ``resize``, and add throwing ``reshape``
-  `#598 <https://github.com/QuantStack/xtensor/pull/598>`_.
+  `#598 <https://github.com/xtensor-stack/xtensor/pull/598>`_.
 - moved to modern cmake
-  `#611 <https://github.com/QuantStack/xtensor/pull/611>`_.
+  `#611 <https://github.com/xtensor-stack/xtensor/pull/611>`_.
 
 New features
 ~~~~~~~~~~~~
 
 - unravel function
-  `#589 <https://github.com/QuantStack/xtensor/pull/589>`_.
+  `#589 <https://github.com/xtensor-stack/xtensor/pull/589>`_.
 - random access iterators
-  `#596 <https://github.com/QuantStack/xtensor/pull/596>`_.
+  `#596 <https://github.com/xtensor-stack/xtensor/pull/596>`_.
 
 
 Other changes
 ~~~~~~~~~~~~~
 
 - upgraded to google/benchmark version 1.3.0
-  `#583 <https://github.com/QuantStack/xtensor/pull/583>`_.
+  `#583 <https://github.com/xtensor-stack/xtensor/pull/583>`_.
 - ``XTENSOR_ASSERT`` renamed into ``XTENSOR_TRY``, new ``XTENSOR_ASSERT``
-  `#603 <https://github.com/QuantStack/xtensor/pull/603>`_.
+  `#603 <https://github.com/xtensor-stack/xtensor/pull/603>`_.
 - ``adapt`` fixed
-  `#604 <https://github.com/QuantStack/xtensor/pull/604>`_.
+  `#604 <https://github.com/xtensor-stack/xtensor/pull/604>`_.
 - VC14 warnings removed
-  `#608 <https://github.com/QuantStack/xtensor/pull/608>`_.
+  `#608 <https://github.com/xtensor-stack/xtensor/pull/608>`_.
 - ``xfunctor_iterator`` is now a random access iterator
-  `#609 <https://github.com/QuantStack/xtensor/pull/609>`_.
+  `#609 <https://github.com/xtensor-stack/xtensor/pull/609>`_.
 - removed ``old-style-cast`` warnings
-  `#610 <https://github.com/QuantStack/xtensor/pull/610>`_.
+  `#610 <https://github.com/xtensor-stack/xtensor/pull/610>`_.
 
 0.14.1
 ------
@@ -702,27 +2146,27 @@ New features
 ~~~~~~~~~~~~
 
 - sort, argmin and argmax
-  `#549 <https://github.com/QuantStack/xtensor/pull/549>`_.
+  `#549 <https://github.com/xtensor-stack/xtensor/pull/549>`_.
 - ``xscalar_expression_tag``
-  `#582 <https://github.com/QuantStack/xtensor/pull/582>`_.
+  `#582 <https://github.com/xtensor-stack/xtensor/pull/582>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - accumulator improvements
-  `#570 <https://github.com/QuantStack/xtensor/pull/570>`_.
+  `#570 <https://github.com/xtensor-stack/xtensor/pull/570>`_.
 - benchmark cmake fixed
-  `#571 <https://github.com/QuantStack/xtensor/pull/571>`_.
+  `#571 <https://github.com/xtensor-stack/xtensor/pull/571>`_.
 - allocator_type added to container interface
-  `#573 <https://github.com/QuantStack/xtensor/pull/573>`_.
+  `#573 <https://github.com/xtensor-stack/xtensor/pull/573>`_.
 - allow conda-forge as fallback channel
-  `#575 <https://github.com/QuantStack/xtensor/pull/575>`_.
+  `#575 <https://github.com/xtensor-stack/xtensor/pull/575>`_.
 - arithmetic mixing optional assemblies and scalars fixed
-  `#578 <https://github.com/QuantStack/xtensor/pull/578>`_.
+  `#578 <https://github.com/xtensor-stack/xtensor/pull/578>`_.
 - arithmetic mixing optional assemblies and optionals fixed
-  `#579 <https://github.com/QuantStack/xtensor/pull/579>`_.
+  `#579 <https://github.com/xtensor-stack/xtensor/pull/579>`_.
 - ``operator==`` restricted to xtensor and xoptional expressions
-  `#580 <https://github.com/QuantStack/xtensor/pull/580>`_.
+  `#580 <https://github.com/xtensor-stack/xtensor/pull/580>`_.
 
 0.14.0
 ------
@@ -731,68 +2175,68 @@ Breaking changes
 ~~~~~~~~~~~~~~~~
 
 - ``xadapt`` renamed into ``adapt``
-  `#563 <https://github.com/QuantStack/xtensor/pull/563>`_.
+  `#563 <https://github.com/xtensor-stack/xtensor/pull/563>`_.
 - Naming consistency
-  `#565 <https://github.com/QuantStack/xtensor/pull/565>`_.
+  `#565 <https://github.com/xtensor-stack/xtensor/pull/565>`_.
 
 New features
 ~~~~~~~~~~~~
 
 - add ``random::choice``
-  `#547 <https://github.com/QuantStack/xtensor/pull/547>`_.
+  `#547 <https://github.com/xtensor-stack/xtensor/pull/547>`_.
 - evaluation strategy and accumulators.
-  `#550 <https://github.com/QuantStack/xtensor/pull/550>`_.
+  `#550 <https://github.com/xtensor-stack/xtensor/pull/550>`_.
 - modulus operator
-  `#556 <https://github.com/QuantStack/xtensor/pull/556>`_.
+  `#556 <https://github.com/xtensor-stack/xtensor/pull/556>`_.
 - ``adapt``: default overload for 1D arrays
-  `#560 <https://github.com/QuantStack/xtensor/pull/560>`_.
+  `#560 <https://github.com/xtensor-stack/xtensor/pull/560>`_.
 - Move semantic on ``adapt``
-  `#564 <https://github.com/QuantStack/xtensor/pull/564>`_.
+  `#564 <https://github.com/xtensor-stack/xtensor/pull/564>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - optional fixes to avoid ambiguous calls
-  `#541 <https://github.com/QuantStack/xtensor/pull/541>`_.
+  `#541 <https://github.com/xtensor-stack/xtensor/pull/541>`_.
 - narrative documentation about ``xt::adapt``
-  `#544 <https://github.com/QuantStack/xtensor/pull/544>`_.
+  `#544 <https://github.com/xtensor-stack/xtensor/pull/544>`_.
 - ``xfunction`` refactoring
-  `#545 <https://github.com/QuantStack/xtensor/pull/545>`_.
+  `#545 <https://github.com/xtensor-stack/xtensor/pull/545>`_.
 - SIMD acceleration for AVX fixed
-  `#557 <https://github.com/QuantStack/xtensor/pull/557>`_.
+  `#557 <https://github.com/xtensor-stack/xtensor/pull/557>`_.
 - allocator fixes
-  `#558 <https://github.com/QuantStack/xtensor/pull/558>`_.
-  `#559 <https://github.com/QuantStack/xtensor/pull/559>`_.
+  `#558 <https://github.com/xtensor-stack/xtensor/pull/558>`_.
+  `#559 <https://github.com/xtensor-stack/xtensor/pull/559>`_.
 - return type of ``view::strides()`` fixed
-  `#568 <https://github.com/QuantStack/xtensor/pull/568>`_.
+  `#568 <https://github.com/xtensor-stack/xtensor/pull/568>`_.
 
 
 0.13.2
 ------
 
 - Support for complex version of ``isclose``
-  `#512 <https://github.com/QuantStack/xtensor/pull/512>`_.
+  `#512 <https://github.com/xtensor-stack/xtensor/pull/512>`_.
 - Fixup static layout in ``xstrided_view``
-  `#536 <https://github.com/QuantStack/xtensor/pull/536>`_.
+  `#536 <https://github.com/xtensor-stack/xtensor/pull/536>`_.
 - ``xexpression::operator[]`` now take support any type of sequence
-  `#537 <https://github.com/QuantStack/xtensor/pull/537>`_.
+  `#537 <https://github.com/xtensor-stack/xtensor/pull/537>`_.
 - Fixing ``xinfo`` issues for Visual Studio.
-  `#529 <https://github.com/QuantStack/xtensor/pull/529>`_.
+  `#529 <https://github.com/xtensor-stack/xtensor/pull/529>`_.
 - Fix const-correctness in ``xstrided_view``.
-  `#526 <https://github.com/QuantStack/xtensor/pull/526>`_.
+  `#526 <https://github.com/xtensor-stack/xtensor/pull/526>`_.
 
 
 0.13.1
 ------
 
 - More general floating point type
-  `#518 <https://github.com/QuantStack/xtensor/pull/518>`_.
+  `#518 <https://github.com/xtensor-stack/xtensor/pull/518>`_.
 - Do not require functor to be passed via rvalue reference
-  `#519 <https://github.com/QuantStack/xtensor/pull/519>`_.
+  `#519 <https://github.com/xtensor-stack/xtensor/pull/519>`_.
 - Documentation improved
-  `#520 <https://github.com/QuantStack/xtensor/pull/520>`_.
+  `#520 <https://github.com/xtensor-stack/xtensor/pull/520>`_.
 - Fix in xreducer
-  `#521 <https://github.com/QuantStack/xtensor/pull/521>`_.
+  `#521 <https://github.com/xtensor-stack/xtensor/pull/521>`_.
 
 0.13.0
 ------
@@ -801,52 +2245,52 @@ Breaking changes
 ~~~~~~~~~~~~~~~~
 
 - The API for ``xbuffer_adaptor`` has changed. The template parameter is the type of the buffer, not just the value type
-  `#482 <https://github.com/QuantStack/xtensor/pull/482>`_.
-- Change ``edge_items`` print option to ``edgeitems`` for better numpy consistency
-  `#489 <https://github.com/QuantStack/xtensor/pull/489>`_.
-- xtensor now depends on ``xtl`` version `~0.3.3`
-  `#508 <https://github.com/QuantStack/xtensor/pull/508>`_.
+  `#482 <https://github.com/xtensor-stack/xtensor/pull/482>`_.
+- Change ``edge_items`` print option to ``edgeitems`` for better NumPy consistency
+  `#489 <https://github.com/xtensor-stack/xtensor/pull/489>`_.
+- *xtensor* now depends on *xtl* version `~0.3.3`
+  `#508 <https://github.com/xtensor-stack/xtensor/pull/508>`_.
 
 New features
 ~~~~~~~~~~~~
 
 - Support for parsing the ``npy`` file format
-  `#465 <https://github.com/QuantStack/xtensor/pull/465>`_.
+  `#465 <https://github.com/xtensor-stack/xtensor/pull/465>`_.
 - Creation of optional expressions from value and boolean expressions (optional assembly)
-  `#496 <https://github.com/QuantStack/xtensor/pull/496>`_.
+  `#496 <https://github.com/xtensor-stack/xtensor/pull/496>`_.
 - Support for the explicit cast of expressions with different value types
-  `#491 <https://github.com/QuantStack/xtensor/pull/491>`_.
+  `#491 <https://github.com/xtensor-stack/xtensor/pull/491>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - Addition of broadcasting bitwise operators
-  `#459 <https://github.com/QuantStack/xtensor/pull/459>`_.
+  `#459 <https://github.com/xtensor-stack/xtensor/pull/459>`_.
 - More efficient optional expression system
-  `#467 <https://github.com/QuantStack/xtensor/pull/467>`_.
+  `#467 <https://github.com/xtensor-stack/xtensor/pull/467>`_.
 - Migration of benchmarks to the Google benchmark framework
-  `#473 <https://github.com/QuantStack/xtensor/pull/473>`_.
+  `#473 <https://github.com/xtensor-stack/xtensor/pull/473>`_.
 - Container semantic and adaptor semantic merged
-  `#475 <https://github.com/QuantStack/xtensor/pull/475>`_.
+  `#475 <https://github.com/xtensor-stack/xtensor/pull/475>`_.
 - Various fixes and improvements of the strided views
-  `#480 <https://github.com/QuantStack/xtensor/pull/480>`_.
-  `#481 <https://github.com/QuantStack/xtensor/pull/481>`_.
+  `#480 <https://github.com/xtensor-stack/xtensor/pull/480>`_.
+  `#481 <https://github.com/xtensor-stack/xtensor/pull/481>`_.
 - Assignment now performs basic type conversion
-  `#486 <https://github.com/QuantStack/xtensor/pull/486>`_.
+  `#486 <https://github.com/xtensor-stack/xtensor/pull/486>`_.
 - Workaround for a compiler bug in Visual Studio 2017
-  `#490 <https://github.com/QuantStack/xtensor/pull/490>`_.
+  `#490 <https://github.com/xtensor-stack/xtensor/pull/490>`_.
 - MSVC 2017 workaround
-  `#492 <https://github.com/QuantStack/xtensor/pull/492>`_.
+  `#492 <https://github.com/xtensor-stack/xtensor/pull/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 <https://github.com/QuantStack/xtensor/pull/502>`_.
-- The behavior of ``linspace`` with integral types has been made consistent with numpy
-  `#510 <https://github.com/QuantStack/xtensor/pull/510>`_.
+  `#502 <https://github.com/xtensor-stack/xtensor/pull/502>`_.
+- The behavior of ``linspace`` with integral types has been made consistent with NumPy
+  `#510 <https://github.com/xtensor-stack/xtensor/pull/510>`_.
 
 0.12.1
 ------
 
 - Fix issue with slicing when using heterogeneous integral types
-  `#451 <https://github.com/QuantStack/xtensor/pull/451>`_.
+  `#451 <https://github.com/xtensor-stack/xtensor/pull/451>`_.
 
 0.12.0
 ------
@@ -854,60 +2298,60 @@ Other changes
 Breaking changes
 ~~~~~~~~~~~~~~~~
 
-- ``xtensor`` now depends on ``xtl`` version `0.2.x`
-  `#421 <https://github.com/QuantStack/xtensor/pull/421>`_.
+- *xtensor* now depends on *xtl* version `0.2.x`
+  `#421 <https://github.com/xtensor-stack/xtensor/pull/421>`_.
 
 New features
 ~~~~~~~~~~~~
 
-- ``xtensor`` has an optional dependency on ``xsimd`` for enabling simd acceleration
-  `#426 <https://github.com/QuantStack/xtensor/pull/426>`_.
+- *xtensor* has an optional dependency on *xsimd* for enabling simd acceleration
+  `#426 <https://github.com/xtensor-stack/xtensor/pull/426>`_.
 
 - All expressions have an additional safe access function (``at``)
-  `#420 <https://github.com/QuantStack/xtensor/pull/420>`_.
+  `#420 <https://github.com/xtensor-stack/xtensor/pull/420>`_.
 
 - norm functions
-  `#440 <https://github.com/QuantStack/xtensor/pull/440>`_.
+  `#440 <https://github.com/xtensor-stack/xtensor/pull/440>`_.
 
 - ``closure_pointer`` used in iterators returning temporaries so their ``operator->`` can be
   correctly defined
-  `#446 <https://github.com/QuantStack/xtensor/pull/446>`_.
+  `#446 <https://github.com/xtensor-stack/xtensor/pull/446>`_.
 
-- expressions tags added so ``xtensor`` expression system can be extended
-  `#447 <https://github.com/QuantStack/xtensor/pull/447>`_.
+- expressions tags added so *xtensor* expression system can be extended
+  `#447 <https://github.com/xtensor-stack/xtensor/pull/447>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - Preconditions and exceptions
-  `#409 <https://github.com/QuantStack/xtensor/pull/409>`_.
+  `#409 <https://github.com/xtensor-stack/xtensor/pull/409>`_.
 
 - ``isclose`` is now symmetric
-  `#411 <https://github.com/QuantStack/xtensor/pull/411>`_.
+  `#411 <https://github.com/xtensor-stack/xtensor/pull/411>`_.
 
 - concepts added
-  `#414 <https://github.com/QuantStack/xtensor/pull/414>`_.
+  `#414 <https://github.com/xtensor-stack/xtensor/pull/414>`_.
 
 - narrowing cast for mixed arithmetic
-  `#432 <https://github.com/QuantStack/xtensor/pull/432>`_.
+  `#432 <https://github.com/xtensor-stack/xtensor/pull/432>`_.
 
 - ``is_xexpression`` concept fixed
-  `#439 <https://github.com/QuantStack/xtensor/pull/439>`_.
+  `#439 <https://github.com/xtensor-stack/xtensor/pull/439>`_.
 
 - ``void_t`` implementation fixed for compilers affected by C++14 defect CWG 1558
-  `#448 <https://github.com/QuantStack/xtensor/pull/448>`_.
+  `#448 <https://github.com/xtensor-stack/xtensor/pull/448>`_.
 
 0.11.3
 ------
 
 - Fixed bug in length-1 statically dimensioned tensor construction
-  `#431 <https://github.com/QuantStack/xtensor/pull/431>`_.
+  `#431 <https://github.com/xtensor-stack/xtensor/pull/431>`_.
 
 0.11.2
 ------
 
 - Fixup compilation issue with latest clang compiler. (missing `constexpr` keyword)
-  `#407 <https://github.com/QuantStack/xtensor/pull/407>`_.
+  `#407 <https://github.com/xtensor-stack/xtensor/pull/407>`_.
 
 0.11.1
 ------
@@ -923,25 +2367,25 @@ 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 <https://github.com/QuantStack/xtensor/pull/370>`_.
+  `#370 <https://github.com/xtensor-stack/xtensor/pull/370>`_.
 
 - ``xview`` now uses a const stepper when its underlying expression is const.
-  `#385 <https://github.com/QuantStack/xtensor/pull/385>`_.
+  `#385 <https://github.com/xtensor-stack/xtensor/pull/385>`_.
 
 Other changes
 ~~~~~~~~~~~~~
 
 - ``xview`` copy semantic and move semantic fixed.
-  `#377 <https://github.com/QuantStack/xtensor/pull/377>`_.
+  `#377 <https://github.com/xtensor-stack/xtensor/pull/377>`_.
 
 - ``xoptional`` can be implicitly constructed from a scalar.
-  `#382 <https://github.com/QuantStack/xtensor/pull/382>`_.
+  `#382 <https://github.com/xtensor-stack/xtensor/pull/382>`_.
 
 - build with Emscripten fixed.
-  `#388 <https://github.com/QuantStack/xtensor/pull/388>`_.
+  `#388 <https://github.com/xtensor-stack/xtensor/pull/388>`_.
 
 - STL version detection improved.
-  `#396 <https://github.com/QuantStack/xtensor/pull/396>`_.
+  `#396 <https://github.com/xtensor-stack/xtensor/pull/396>`_.
 
 - Implicit conversion between signed and unsigned integers fixed.
-  `#397 <https://github.com/QuantStack/xtensor/pull/397>`_.
+  `#397 <https://github.com/xtensor-stack/xtensor/pull/397>`_.
diff --git a/docs/source/closure-semantics.rst b/docs/source/closure-semantics.rst
index 92d0aaf0d..ad4d11504 100644
--- a/docs/source/closure-semantics.rst
+++ b/docs/source/closure-semantics.rst
@@ -9,17 +9,17 @@
 Closure semantics
 =================
 
-The ``xtensor`` library is a tensor expression library implementing numpy-style broadcasting and universal functions but in a lazy fashion.
+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 ``xt::xtensor`` or
-``xt::xarray``. The same holds for most functions in xtensor, views, broadcasting views, etc.
+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.
+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
 -----------------------------------------
@@ -32,7 +32,7 @@ The two main requirements are the following:
 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.
+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
 
@@ -78,7 +78,7 @@ Using this mechanism, we were able to
 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,
+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.
 
@@ -104,7 +104,7 @@ The logic for this is encoded into xtensor's ``xclosure`` type trait.
     using xclosure_t = typename xclosure<E>::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:
+The ``const_xclosure`` follows the same scheme:
 
 .. code:: cpp
 
@@ -174,7 +174,7 @@ 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``.
+- 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>(e))``. The goal is to have the unevaluated ``s`` expression
@@ -184,7 +184,7 @@ hold a const reference or a value for ``e`` depending on the lvalue-ness of the
 Reusing expressions / sharing expressions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Sometimes it is necessary to use a xexpression in two seperate places in another xexpression. For example, when computing
+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.
@@ -209,7 +209,7 @@ utility to achieve this:
     }
 
 Note: writing a lambda is just sugar for writing a functor.
-Also, using `auto x` as the function argument enables automatic `xsimd` acceleration.
+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
@@ -222,14 +222,36 @@ But under certain circumstances it might be required, e.g. to implement a fully
     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);
+        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; // ==> 3
+        std::cout << shared_weights.use_count() << std::endl; // ==> 4
         return expr;
     }
 
-We can see that, before returning from the function, three copies of ``shared_weights``
-exist: two in the two ``xt::sum`` functions, and one is the temporary. After returning
-from the function, only two copies of the ``xshared_expression`` will exist.
+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 <class E, class W>
+    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/compilers.rst b/docs/source/compilers.rst
index da3adf57f..69673031e 100644
--- a/docs/source/compilers.rst
+++ b/docs/source/compilers.rst
@@ -41,7 +41,23 @@ 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 ovarload.
+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. <https://github.com/xtensor-stack/xtensor/issues/2568>`_
+Upstream issue `here. <https://developercommunity.visualstudio.com/t/Runtime-Crash-msvc--1931-with-optimiz/10134617>`_
 
 GCC-4.9 and Clang < 3.8 and constexpr ``std::min`` and ``std::max``
 -------------------------------------------------------------------
@@ -63,6 +79,14 @@ 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``
 ---------------------------------------------------------
 
@@ -75,7 +99,7 @@ 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 are
+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``.
@@ -96,3 +120,20 @@ As of version 6, GCC detects whether the obsolete functions are present in the
 C header ``<math.h>`` 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<dynamic_view>`` meta-function should return
+false. Instantiating the ``has_strides<dynamic_view>`` 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
index 0755b2f46..643a65320 100644
--- a/docs/source/conda.svg
+++ b/docs/source/conda.svg
@@ -1 +1 @@
-<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 127 127"><style>.st0{fill:#43b02a}</style><path class="st0" d="M13.8 81.2c-2.1 4.2-3.8 8.6-5.2 13.1 4.7 1.3 9.4 2.2 14.2 2.6.1-3.8.4-7.4.9-11-3.4-1.3-6.7-2.9-9.9-4.7zM33 32.8c-2.8 0-5.5.2-8.3.6.4 2.8.8 5.5 1.5 8.3 1.9-3.2 4.2-6.1 6.8-8.7v-.2zM10.5 98.7c3.6 5.5 8.1 10.4 13.2 14.5-.5-4.3-.9-8.4-.9-12.5-4.2-.4-8.3-1.1-12.3-2zM43 3.4c-5 1.7-9.6 4-14 6.8 3.3.6 6.5 1.3 9.7 2.3 1.2-3.1 2.7-6.1 4.3-9.1zM63.6 0c-2.5 0-4.9.2-7.3.4 3.4 2.4 6.6 4.9 9.7 7.7l2.5 2.3-2.5 2.5c-2.1 2-4.1 4.1-6 6.4v.1s-.4.4-1 1.1c1.5-.2 3-.2 4.6-.2 23.9 0 43.3 19.4 43.3 43.3s-19.4 43.3-43.3 43.3c-8.3 0-16.1-2.3-22.7-6.4-3.3.4-6.5.6-9.8.6-1.5 0-3 0-4.6-.1.1 4.9.6 10 1.4 15.3 10.2 6.9 22.4 10.9 35.6 10.9 35.1 0 63.6-28.5 63.6-63.6C127.2 28.5 98.7 0 63.6 0z"/><path class="st0" d="M55.1 15c1.3-1.5 2.6-3 3.9-4.4-3-2.5-6.1-4.9-9.4-6.9-2 3.4-3.8 7-5.3 10.6 2.9 1.1 5.7 2.3 8.4 3.6 1.3-1.6 2.2-2.6 2.4-2.9zM19.4 34.1c-4.7.8-9.3 2.1-13.8 3.7 1.8 4.6 4.1 9.1 6.7 13.3 3-2.1 6.1-4.1 9.3-5.8-1-3.7-1.7-7.4-2.2-11.2zM11.1 58.1c-3.4 2.8-6.6 5.8-9.6 9.2 3.3 2.9 6.8 5.5 10.5 7.9 1.7-3 3.6-6 5.6-8.8-2.2-2.6-4.4-5.4-6.5-8.3zM27.3 87.3c-.4 3.2-.7 6.5-.8 9.9 3.2.2 6.4.2 9.6 0-3.4-2.8-6.4-6.1-8.8-9.9zM36.6 18.1c-4-1.1-8.1-2-12.2-2.5-.4 4.2-.4 8.3-.1 12.4 3.3-.4 6.5-.6 9.8-.6.6-3.2 1.5-6.3 2.5-9.3zM42.3 19.9c-.8 2.4-1.5 4.8-2.1 7.2 2.8-1.8 5.8-3.3 8.9-4.4-2.2-1-4.5-1.9-6.8-2.8zM.5 72.1c.8 6.2 2.5 12.1 5 17.5C6.8 86 8.3 82.4 10 79c-3.3-2.1-6.4-4.4-9.5-6.9zM18.8 18.5c-3.8 3.8-7.1 8-9.9 12.6 3.3-1 6.6-1.8 10-2.4-.2-3.4-.3-6.8-.1-10.2zM15 55.2c1.6 2.3 3.4 4.6 5.3 6.8.2-4 .8-7.8 2-11.5-2.5 1.4-5 3-7.3 4.7zM15.8 77.3c2.7 1.5 5.4 2.9 8.3 4.1-1.7-3.7-2.8-7.6-3.4-11.8-1.8 2.5-3.4 5.1-4.9 7.7zM8.4 54.1c-2-3.2-3.8-6.5-5.4-10C1.2 49.7.1 55.7 0 61.8c2.7-2.8 5.5-5.4 8.4-7.7z"/></svg>
\ No newline at end of file
+<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 127 127"><style>.st0{fill:#43b02a}</style><path class="st0" d="M13.8 81.2c-2.1 4.2-3.8 8.6-5.2 13.1 4.7 1.3 9.4 2.2 14.2 2.6.1-3.8.4-7.4.9-11-3.4-1.3-6.7-2.9-9.9-4.7zM33 32.8c-2.8 0-5.5.2-8.3.6.4 2.8.8 5.5 1.5 8.3 1.9-3.2 4.2-6.1 6.8-8.7v-.2zM10.5 98.7c3.6 5.5 8.1 10.4 13.2 14.5-.5-4.3-.9-8.4-.9-12.5-4.2-.4-8.3-1.1-12.3-2zM43 3.4c-5 1.7-9.6 4-14 6.8 3.3.6 6.5 1.3 9.7 2.3 1.2-3.1 2.7-6.1 4.3-9.1zM63.6 0c-2.5 0-4.9.2-7.3.4 3.4 2.4 6.6 4.9 9.7 7.7l2.5 2.3-2.5 2.5c-2.1 2-4.1 4.1-6 6.4v.1s-.4.4-1 1.1c1.5-.2 3-.2 4.6-.2 23.9 0 43.3 19.4 43.3 43.3s-19.4 43.3-43.3 43.3c-8.3 0-16.1-2.3-22.7-6.4-3.3.4-6.5.6-9.8.6-1.5 0-3 0-4.6-.1.1 4.9.6 10 1.4 15.3 10.2 6.9 22.4 10.9 35.6 10.9 35.1 0 63.6-28.5 63.6-63.6C127.2 28.5 98.7 0 63.6 0z"/><path class="st0" d="M55.1 15c1.3-1.5 2.6-3 3.9-4.4-3-2.5-6.1-4.9-9.4-6.9-2 3.4-3.8 7-5.3 10.6 2.9 1.1 5.7 2.3 8.4 3.6 1.3-1.6 2.2-2.6 2.4-2.9zM19.4 34.1c-4.7.8-9.3 2.1-13.8 3.7 1.8 4.6 4.1 9.1 6.7 13.3 3-2.1 6.1-4.1 9.3-5.8-1-3.7-1.7-7.4-2.2-11.2zM11.1 58.1c-3.4 2.8-6.6 5.8-9.6 9.2 3.3 2.9 6.8 5.5 10.5 7.9 1.7-3 3.6-6 5.6-8.8-2.2-2.6-4.4-5.4-6.5-8.3zM27.3 87.3c-.4 3.2-.7 6.5-.8 9.9 3.2.2 6.4.2 9.6 0-3.4-2.8-6.4-6.1-8.8-9.9zM36.6 18.1c-4-1.1-8.1-2-12.2-2.5-.4 4.2-.4 8.3-.1 12.4 3.3-.4 6.5-.6 9.8-.6.6-3.2 1.5-6.3 2.5-9.3zM42.3 19.9c-.8 2.4-1.5 4.8-2.1 7.2 2.8-1.8 5.8-3.3 8.9-4.4-2.2-1-4.5-1.9-6.8-2.8zM.5 72.1c.8 6.2 2.5 12.1 5 17.5C6.8 86 8.3 82.4 10 79c-3.3-2.1-6.4-4.4-9.5-6.9zM18.8 18.5c-3.8 3.8-7.1 8-9.9 12.6 3.3-1 6.6-1.8 10-2.4-.2-3.4-.3-6.8-.1-10.2zM15 55.2c1.6 2.3 3.4 4.6 5.3 6.8.2-4 .8-7.8 2-11.5-2.5 1.4-5 3-7.3 4.7zM15.8 77.3c2.7 1.5 5.4 2.9 8.3 4.1-1.7-3.7-2.8-7.6-3.4-11.8-1.8 2.5-3.4 5.1-4.9 7.7zM8.4 54.1c-2-3.2-3.8-6.5-5.4-10C1.2 49.7.1 55.7 0 61.8c2.7-2.8 5.5-5.4 8.4-7.7z"/></svg>
diff --git a/docs/source/conf.py b/docs/source/conf.py
index e49808853..4f5fffb67 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -16,10 +16,11 @@
 html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
 
 def setup(app):
-    app.add_stylesheet("main_stylesheet.css")
+    app.add_css_file("main_stylesheet.css")
 
-extensions = ['breathe']
+extensions = ['breathe', 'sphinx_rtd_theme']
 breathe_projects = { 'xtensor': '../xml' }
+breathe_default_project = "xtensor"
 templates_path = ['_templates']
 html_static_path = ['_static']
 source_suffix = '.rst'
@@ -36,3 +37,15 @@ def setup(app):
 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
index 9bf257783..74367b7a8 100644
--- a/docs/source/container.rst
+++ b/docs/source/container.rst
@@ -10,119 +10,181 @@ 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
+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 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 ``layout_type`` enum that helps to specify the layout used by multi-dimensional arrays. This enum can be used in two ways:
-
-- at compile time, as a template argument. The value ``layout_type::dynamic`` allows specifying any strided index scheme at runtime (including row-major and column-major schemes), while ``layout_type::row_major`` and ``layout_type::column_major`` fixes the strided index scheme and disable ``resize`` and constructor overloads taking a set of strides or a layout value as parameter. The default value of the template parameter is ``XTENSOR_DEFAULT_LAYOUT``.
-- at runtime if the previous template parameter was set to ``layout_type::dynamic``. In that case, ``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 ``XTENSOR_DEFAULT_LAYOUT`` are used.
+*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() <xt::xstrided_container::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() <xt::xstrided_container::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 <vector>
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     std::vector<size_t> shape = { 3, 2, 4 };
     std::vector<size_t> strides = { 8, 4, 1 };
     xt::xarray<double, xt::layout_type::dynamic> 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:
+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 <vector>
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     std::vector<size_t> shape = { 3, 2, 4 };
-    xt::xarray<double, xt::layout_type::dynamic> a(shape, xt::layout::row_major);
+    xt::xarray<double, xt::layout_type::dynamic> 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 <vector>
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     std::vector<size_t> shape = { 3, 2, 4 };
     xt::xarray<double, xt::layout_type::row_major> a(shape);
     // this shortcut is equivalent:
     // xt::xarray<double> a(shape);
 
-However, in the latter case, the layout of the array is forced to ``row_major`` at compile time, and therefore cannot be changed at runtime.
+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 multi-dimensional arrays are provided: ``xarray`` and ``xtensor`` and ``xtensor_fixed``.
+Three container classes implementing multidimensional arrays are provided: :cpp:type:`xt::xarray` and
+:cpp:type:`xt::xtensor` and :cpp:type:`xt::xtensor_fixed`.
 
-- ``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.
-- ``xtensor_fixed`` has a shape fixed at compile time. This allows even more optimizations, such as allocating the storage for the container
+- :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 ``xtensor`` instead of ``xarray`` in the previous example:
+Let's use :cpp:type:`xt::xtensor` instead of :cpp:type:`xt::xarray` in the previous example:
 
 .. code::
 
     #include <array>
-    #include "xtensor/xtensor.hpp"
+    #include <xtensor/containers/xtensor.hpp>
 
     std::array<size_t, 3> shape = { 3, 2, 4 };
     xt::xtensor<double, 3> a(shape);
-    // whis is equivalent to
+    // this is equivalent to
     // xt::xtensor<double, 3, xt::layout_type::row_major> a(shape);
 
-Or when using ``xtensor_fixed``:
+Or when using :cpp:type:`xt::xtensor_fixed`:
 
 .. code::
 
-    #include "xtensor/xfixed.hpp"
+    #include <xtensor/containers/xfixed.hpp>
 
     xt::xtensor_fixed<double, xt::xshape<3, 2, 4>> a();
     // or xt::xtensor_fixed<double, xt::xshape<3, 2, 4>, xt::layout_type::row_major>()
 
-``xarray``, ``xtensor`` and ``xtensor_fixed`` containers are all ``xexpression`` s and can be involved and mixed in mathematical expressions, assigned to each
-other etc... They provide an augmented interface compared to other ``xexpression`` types:
+: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() <xt::xstrided_container::reshape>` reshapes the container in place, and the global size of the container has to stay the same.
+- :cpp:func:`resize() <xt::xstrided_container::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() <xt::xcontainer::strides>` returns the strides of the container, used to compute the position of an element in the underlying buffer.
+
+Reshape
+-------
+
+The :cpp:func:`reshape() <xt::xstrided_container::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 <xtensor/containers/xarray.hpp>
+
+    xt::xarray<int> a = { 1, 2, 3, 4, 5, 6, 7, 8};
+    // The following two lines ...
+    std::array<std::size_t, 2> sh1 = {2, 4};
+    a.reshape(sh1);
+    // ... are equivalent to the following two lines ...
+    xt::xarray<int>::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::
 
-- Each method exposed in ``xexpression`` interface has its non-const counterpart exposed by ``xarray``, ``xtensor`` and ``xtensor_fixed``.
-- ``reshape()`` reshapes the container in place, and the global size of the container has to stay the same.
-- ``resize()`` resizes the container in place, that is, if the global size of the container doesn't change, no memory allocation occurs.
-- ``strides()`` returns the strides of the container, used to compute the position of an element in the underlying buffer.
+    #include <xtensor/containers/xarray.hpp>
+    xt::xarray<int> a = { 1, 2, 3, 4, 5, 6, 7, 8};
+    a.reshape({2, -1});
+    // a.shape() return {2, 4}
 
 Performance
 -----------
 
-The dynamic dimensionality of ``xarray`` comes at a cost. Since the dimension is unknown at build time, the sequences holding shape and strides of ``xarray`` instances are heap-allocated, which makes it significantly more expansive than ``xtensor``. Shape and strides of ``xtensor`` are stack-allocated which makes them more efficient.
+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 ``xarray``), it bubbles up to the entire broadcasting expression which will have a heap-allocated shape. The same hold for views, broadcast expressions, etc...
+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. This occurs when the destination container is involved in the expression and has to be resized. This phenomenon is
-known as *aliasing*.
+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 ``xarray``, this results in an extra dynamic memory
-allocation and copy.
+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:
+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 "xtensor/xarray.hpp"
-    #include "xtensor/xnoalias.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/core/xnoalias.hpp>
 
     // a, b, and c are xt::xarrays previously initialized
     xt::noalias(b) = a + c;
@@ -137,7 +199,7 @@ The aliasing phenomenon is illustrated in the following example:
 .. code::
 
     #include <vector>
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     std::vector<size_t> a_shape = {3, 2, 4};
     xt::xarray<double> a(a_shape);
@@ -148,8 +210,11 @@ The aliasing phenomenon is illustrated in the following example:
     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.
+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.
+``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
index 50dcb70c8..923265199 100644
--- a/docs/source/debian.svg
+++ b/docs/source/debian.svg
@@ -1,86 +1,86 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 10.0, SVG Export Plug-In . SVG Version: 3.0.0 Build 77)  -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN"    "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd" [
-	<!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/">
-	<!ENTITY ns_extend "http://ns.adobe.com/Extensibility/1.0/">
-	<!ENTITY ns_ai "http://ns.adobe.com/AdobeIllustrator/10.0/">
-	<!ENTITY ns_graphs "http://ns.adobe.com/Graphs/1.0/">
-	<!ENTITY ns_vars "http://ns.adobe.com/Variables/1.0/">
-	<!ENTITY ns_imrep "http://ns.adobe.com/ImageReplacement/1.0/">
-	<!ENTITY ns_sfw "http://ns.adobe.com/SaveForWeb/1.0/">
-	<!ENTITY ns_custom "http://ns.adobe.com/GenericCustomNamespace/1.0/">
-	<!ENTITY ns_adobe_xpath "http://ns.adobe.com/XPath/1.0/">
-	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
-	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
-]>
-<svg 
-	 xmlns:x="&ns_extend;" xmlns:i="&ns_ai;" xmlns:graph="&ns_graphs;" i:viewOrigin="262 450" i:rulerOrigin="0 0" i:pageBounds="0 792 612 0"
-	 xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
-	 width="87.041" height="108.445" viewBox="0 0 87.041 108.445" overflow="visible" enable-background="new 0 0 87.041 108.445"
-	 xml:space="preserve">
-	<metadata>
-		<variableSets  xmlns="&ns_vars;">
-			<variableSet  varSetName="binding1" locked="none">
-				<variables></variables>
-				<v:sampleDataSets  xmlns="&ns_custom;" xmlns:v="&ns_vars;"></v:sampleDataSets>
-			</variableSet>
-		</variableSets>
-		<sfw  xmlns="&ns_sfw;">
-			<slices></slices>
-			<sliceSourceBounds  y="341.555" x="262" width="87.041" height="108.445" bottomLeftOrigin="true"></sliceSourceBounds>
-		</sfw>
-	</metadata>
-	<g id="Layer_1" i:layer="yes" i:dimmedPercent="50" i:rgbTrio="#4F008000FFFF">
-		<g>
-			<path i:knockout="Off" fill="#A80030" d="M51.986,57.297c-1.797,0.025,0.34,0.926,2.686,1.287
-				c0.648-0.506,1.236-1.018,1.76-1.516C54.971,57.426,53.484,57.434,51.986,57.297"/>
-			<path i:knockout="Off" fill="#A80030" d="M61.631,54.893c1.07-1.477,1.85-3.094,2.125-4.766c-0.24,1.192-0.887,2.221-1.496,3.307
-				c-3.359,2.115-0.316-1.256-0.002-2.537C58.646,55.443,61.762,53.623,61.631,54.893"/>
-			<path i:knockout="Off" fill="#A80030" d="M65.191,45.629c0.217-3.236-0.637-2.213-0.924-0.978
-				C64.602,44.825,64.867,46.932,65.191,45.629"/>
-			<path i:knockout="Off" fill="#A80030" d="M45.172,1.399c0.959,0.172,2.072,0.304,1.916,0.533
-				C48.137,1.702,48.375,1.49,45.172,1.399"/>
-			<path i:knockout="Off" fill="#A80030" d="M47.088,1.932l-0.678,0.14l0.631-0.056L47.088,1.932"/>
-			<path i:knockout="Off" fill="#A80030" d="M76.992,46.856c0.107,2.906-0.85,4.316-1.713,6.812l-1.553,0.776
-				c-1.271,2.468,0.123,1.567-0.787,3.53c-1.984,1.764-6.021,5.52-7.313,5.863c-0.943-0.021,0.639-1.113,0.846-1.541
-				c-2.656,1.824-2.131,2.738-6.193,3.846l-0.119-0.264c-10.018,4.713-23.934-4.627-23.751-17.371
-				c-0.107,0.809-0.304,0.607-0.526,0.934c-0.517-6.557,3.028-13.143,9.007-15.832c5.848-2.895,12.704-1.707,16.893,2.197
-				c-2.301-3.014-6.881-6.209-12.309-5.91c-5.317,0.084-10.291,3.463-11.951,7.131c-2.724,1.715-3.04,6.611-4.227,7.507
-				C31.699,56.271,36.3,61.342,44.083,67.307c1.225,0.826,0.345,0.951,0.511,1.58c-2.586-1.211-4.954-3.039-6.901-5.277
-				c1.033,1.512,2.148,2.982,3.589,4.137c-2.438-0.826-5.695-5.908-6.646-6.115c4.203,7.525,17.052,13.197,23.78,10.383
-				c-3.113,0.115-7.068,0.064-10.566-1.229c-1.469-0.756-3.467-2.322-3.11-2.615c9.182,3.43,18.667,2.598,26.612-3.771
-				c2.021-1.574,4.229-4.252,4.867-4.289c-0.961,1.445,0.164,0.695-0.574,1.971c2.014-3.248-0.875-1.322,2.082-5.609l1.092,1.504
-				c-0.406-2.696,3.348-5.97,2.967-10.234c0.861-1.304,0.961,1.403,0.047,4.403c1.268-3.328,0.334-3.863,0.66-6.609
-				c0.352,0.923,0.814,1.904,1.051,2.878c-0.826-3.216,0.848-5.416,1.262-7.285c-0.408-0.181-1.275,1.422-1.473-2.377
-				c0.029-1.65,0.459-0.865,0.625-1.271c-0.324-0.186-1.174-1.451-1.691-3.877c0.375-0.57,1.002,1.478,1.512,1.562
-				c-0.328-1.929-0.893-3.4-0.916-4.88c-1.49-3.114-0.527,0.415-1.736-1.337c-1.586-4.947,1.316-1.148,1.512-3.396
-				c2.404,3.483,3.775,8.881,4.404,11.117c-0.48-2.726-1.256-5.367-2.203-7.922c0.73,0.307-1.176-5.609,0.949-1.691
-				c-2.27-8.352-9.715-16.156-16.564-19.818c0.838,0.767,1.896,1.73,1.516,1.881c-3.406-2.028-2.807-2.186-3.295-3.043
-				c-2.775-1.129-2.957,0.091-4.795,0.002c-5.23-2.774-6.238-2.479-11.051-4.217l0.219,1.023c-3.465-1.154-4.037,0.438-7.782,0.004
-				c-0.228-0.178,1.2-0.644,2.375-0.815c-3.35,0.442-3.193-0.66-6.471,0.122c0.808-0.567,1.662-0.942,2.524-1.424
-				c-2.732,0.166-6.522,1.59-5.352,0.295c-4.456,1.988-12.37,4.779-16.811,8.943l-0.14-0.933c-2.035,2.443-8.874,7.296-9.419,10.46
-				l-0.544,0.127c-1.059,1.793-1.744,3.825-2.584,5.67c-1.385,2.36-2.03,0.908-1.833,1.278c-2.724,5.523-4.077,10.164-5.246,13.97
-				c0.833,1.245,0.02,7.495,0.335,12.497c-1.368,24.704,17.338,48.69,37.785,54.228c2.997,1.072,7.454,1.031,11.245,1.141
-				c-4.473-1.279-5.051-0.678-9.408-2.197c-3.143-1.48-3.832-3.17-6.058-5.102l0.881,1.557c-4.366-1.545-2.539-1.912-6.091-3.037
-				l0.941-1.229c-1.415-0.107-3.748-2.385-4.386-3.646l-1.548,0.061c-1.86-2.295-2.851-3.949-2.779-5.23l-0.5,0.891
-				c-0.567-0.973-6.843-8.607-3.587-6.83c-0.605-0.553-1.409-0.9-2.281-2.484l0.663-0.758c-1.567-2.016-2.884-4.6-2.784-5.461
-				c0.836,1.129,1.416,1.34,1.99,1.533c-3.957-9.818-4.179-0.541-7.176-9.994l0.634-0.051c-0.486-0.732-0.781-1.527-1.172-2.307
-				l0.276-2.75C4.667,58.121,6.719,47.409,7.13,41.534c0.285-2.389,2.378-4.932,3.97-8.92l-0.97-0.167
-				c1.854-3.234,10.586-12.988,14.63-12.486c1.959-2.461-0.389-0.009-0.772-0.629c4.303-4.453,5.656-3.146,8.56-3.947
-				c3.132-1.859-2.688,0.725-1.203-0.709c5.414-1.383,3.837-3.144,10.9-3.846c0.745,0.424-1.729,0.655-2.35,1.205
-				c4.511-2.207,14.275-1.705,20.617,1.225c7.359,3.439,15.627,13.605,15.953,23.17l0.371,0.1
-				c-0.188,3.802,0.582,8.199-0.752,12.238L76.992,46.856"/>
-			<path i:knockout="Off" fill="#A80030" d="M32.372,59.764l-0.252,1.26c1.181,1.604,2.118,3.342,3.626,4.596
-				C34.661,63.502,33.855,62.627,32.372,59.764"/>
-			<path i:knockout="Off" fill="#A80030" d="M35.164,59.654c-0.625-0.691-0.995-1.523-1.409-2.352
-				c0.396,1.457,1.207,2.709,1.962,3.982L35.164,59.654"/>
-			<path i:knockout="Off" fill="#A80030" d="M84.568,48.916l-0.264,0.662c-0.484,3.438-1.529,6.84-3.131,9.994
-				C82.943,56.244,84.088,52.604,84.568,48.916"/>
-			<path i:knockout="Off" fill="#A80030" d="M45.527,0.537C46.742,0.092,48.514,0.293,49.803,0c-1.68,0.141-3.352,0.225-5.003,0.438
-				L45.527,0.537"/>
-			<path i:knockout="Off" fill="#A80030" d="M2.872,23.219c0.28,2.592-1.95,3.598,0.494,1.889
-				C4.676,22.157,2.854,24.293,2.872,23.219"/>
-			<path i:knockout="Off" fill="#A80030" d="M0,35.215c0.563-1.728,0.665-2.766,0.88-3.766C-0.676,33.438,0.164,33.862,0,35.215"/>
-		</g>
-	</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 10.0, SVG Export Plug-In . SVG Version: 3.0.0 Build 77)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN"    "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd" [
+    <!ENTITY ns_flows "http://ns.adobe.com/Flows/1.0/">
+    <!ENTITY ns_extend "http://ns.adobe.com/Extensibility/1.0/">
+    <!ENTITY ns_ai "http://ns.adobe.com/AdobeIllustrator/10.0/">
+    <!ENTITY ns_graphs "http://ns.adobe.com/Graphs/1.0/">
+    <!ENTITY ns_vars "http://ns.adobe.com/Variables/1.0/">
+    <!ENTITY ns_imrep "http://ns.adobe.com/ImageReplacement/1.0/">
+    <!ENTITY ns_sfw "http://ns.adobe.com/SaveForWeb/1.0/">
+    <!ENTITY ns_custom "http://ns.adobe.com/GenericCustomNamespace/1.0/">
+    <!ENTITY ns_adobe_xpath "http://ns.adobe.com/XPath/1.0/">
+    <!ENTITY ns_svg "http://www.w3.org/2000/svg">
+    <!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg
+     xmlns:x="&ns_extend;" xmlns:i="&ns_ai;" xmlns:graph="&ns_graphs;" i:viewOrigin="262 450" i:rulerOrigin="0 0" i:pageBounds="0 792 612 0"
+     xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
+     width="87.041" height="108.445" viewBox="0 0 87.041 108.445" overflow="visible" enable-background="new 0 0 87.041 108.445"
+     xml:space="preserve">
+    <metadata>
+        <variableSets  xmlns="&ns_vars;">
+            <variableSet  varSetName="binding1" locked="none">
+                <variables></variables>
+                <v:sampleDataSets  xmlns="&ns_custom;" xmlns:v="&ns_vars;"></v:sampleDataSets>
+            </variableSet>
+        </variableSets>
+        <sfw  xmlns="&ns_sfw;">
+            <slices></slices>
+            <sliceSourceBounds  y="341.555" x="262" width="87.041" height="108.445" bottomLeftOrigin="true"></sliceSourceBounds>
+        </sfw>
+    </metadata>
+    <g id="Layer_1" i:layer="yes" i:dimmedPercent="50" i:rgbTrio="#4F008000FFFF">
+        <g>
+            <path i:knockout="Off" fill="#A80030" d="M51.986,57.297c-1.797,0.025,0.34,0.926,2.686,1.287
+                c0.648-0.506,1.236-1.018,1.76-1.516C54.971,57.426,53.484,57.434,51.986,57.297"/>
+            <path i:knockout="Off" fill="#A80030" d="M61.631,54.893c1.07-1.477,1.85-3.094,2.125-4.766c-0.24,1.192-0.887,2.221-1.496,3.307
+                c-3.359,2.115-0.316-1.256-0.002-2.537C58.646,55.443,61.762,53.623,61.631,54.893"/>
+            <path i:knockout="Off" fill="#A80030" d="M65.191,45.629c0.217-3.236-0.637-2.213-0.924-0.978
+                C64.602,44.825,64.867,46.932,65.191,45.629"/>
+            <path i:knockout="Off" fill="#A80030" d="M45.172,1.399c0.959,0.172,2.072,0.304,1.916,0.533
+                C48.137,1.702,48.375,1.49,45.172,1.399"/>
+            <path i:knockout="Off" fill="#A80030" d="M47.088,1.932l-0.678,0.14l0.631-0.056L47.088,1.932"/>
+            <path i:knockout="Off" fill="#A80030" d="M76.992,46.856c0.107,2.906-0.85,4.316-1.713,6.812l-1.553,0.776
+                c-1.271,2.468,0.123,1.567-0.787,3.53c-1.984,1.764-6.021,5.52-7.313,5.863c-0.943-0.021,0.639-1.113,0.846-1.541
+                c-2.656,1.824-2.131,2.738-6.193,3.846l-0.119-0.264c-10.018,4.713-23.934-4.627-23.751-17.371
+                c-0.107,0.809-0.304,0.607-0.526,0.934c-0.517-6.557,3.028-13.143,9.007-15.832c5.848-2.895,12.704-1.707,16.893,2.197
+                c-2.301-3.014-6.881-6.209-12.309-5.91c-5.317,0.084-10.291,3.463-11.951,7.131c-2.724,1.715-3.04,6.611-4.227,7.507
+                C31.699,56.271,36.3,61.342,44.083,67.307c1.225,0.826,0.345,0.951,0.511,1.58c-2.586-1.211-4.954-3.039-6.901-5.277
+                c1.033,1.512,2.148,2.982,3.589,4.137c-2.438-0.826-5.695-5.908-6.646-6.115c4.203,7.525,17.052,13.197,23.78,10.383
+                c-3.113,0.115-7.068,0.064-10.566-1.229c-1.469-0.756-3.467-2.322-3.11-2.615c9.182,3.43,18.667,2.598,26.612-3.771
+                c2.021-1.574,4.229-4.252,4.867-4.289c-0.961,1.445,0.164,0.695-0.574,1.971c2.014-3.248-0.875-1.322,2.082-5.609l1.092,1.504
+                c-0.406-2.696,3.348-5.97,2.967-10.234c0.861-1.304,0.961,1.403,0.047,4.403c1.268-3.328,0.334-3.863,0.66-6.609
+                c0.352,0.923,0.814,1.904,1.051,2.878c-0.826-3.216,0.848-5.416,1.262-7.285c-0.408-0.181-1.275,1.422-1.473-2.377
+                c0.029-1.65,0.459-0.865,0.625-1.271c-0.324-0.186-1.174-1.451-1.691-3.877c0.375-0.57,1.002,1.478,1.512,1.562
+                c-0.328-1.929-0.893-3.4-0.916-4.88c-1.49-3.114-0.527,0.415-1.736-1.337c-1.586-4.947,1.316-1.148,1.512-3.396
+                c2.404,3.483,3.775,8.881,4.404,11.117c-0.48-2.726-1.256-5.367-2.203-7.922c0.73,0.307-1.176-5.609,0.949-1.691
+                c-2.27-8.352-9.715-16.156-16.564-19.818c0.838,0.767,1.896,1.73,1.516,1.881c-3.406-2.028-2.807-2.186-3.295-3.043
+                c-2.775-1.129-2.957,0.091-4.795,0.002c-5.23-2.774-6.238-2.479-11.051-4.217l0.219,1.023c-3.465-1.154-4.037,0.438-7.782,0.004
+                c-0.228-0.178,1.2-0.644,2.375-0.815c-3.35,0.442-3.193-0.66-6.471,0.122c0.808-0.567,1.662-0.942,2.524-1.424
+                c-2.732,0.166-6.522,1.59-5.352,0.295c-4.456,1.988-12.37,4.779-16.811,8.943l-0.14-0.933c-2.035,2.443-8.874,7.296-9.419,10.46
+                l-0.544,0.127c-1.059,1.793-1.744,3.825-2.584,5.67c-1.385,2.36-2.03,0.908-1.833,1.278c-2.724,5.523-4.077,10.164-5.246,13.97
+                c0.833,1.245,0.02,7.495,0.335,12.497c-1.368,24.704,17.338,48.69,37.785,54.228c2.997,1.072,7.454,1.031,11.245,1.141
+                c-4.473-1.279-5.051-0.678-9.408-2.197c-3.143-1.48-3.832-3.17-6.058-5.102l0.881,1.557c-4.366-1.545-2.539-1.912-6.091-3.037
+                l0.941-1.229c-1.415-0.107-3.748-2.385-4.386-3.646l-1.548,0.061c-1.86-2.295-2.851-3.949-2.779-5.23l-0.5,0.891
+                c-0.567-0.973-6.843-8.607-3.587-6.83c-0.605-0.553-1.409-0.9-2.281-2.484l0.663-0.758c-1.567-2.016-2.884-4.6-2.784-5.461
+                c0.836,1.129,1.416,1.34,1.99,1.533c-3.957-9.818-4.179-0.541-7.176-9.994l0.634-0.051c-0.486-0.732-0.781-1.527-1.172-2.307
+                l0.276-2.75C4.667,58.121,6.719,47.409,7.13,41.534c0.285-2.389,2.378-4.932,3.97-8.92l-0.97-0.167
+                c1.854-3.234,10.586-12.988,14.63-12.486c1.959-2.461-0.389-0.009-0.772-0.629c4.303-4.453,5.656-3.146,8.56-3.947
+                c3.132-1.859-2.688,0.725-1.203-0.709c5.414-1.383,3.837-3.144,10.9-3.846c0.745,0.424-1.729,0.655-2.35,1.205
+                c4.511-2.207,14.275-1.705,20.617,1.225c7.359,3.439,15.627,13.605,15.953,23.17l0.371,0.1
+                c-0.188,3.802,0.582,8.199-0.752,12.238L76.992,46.856"/>
+            <path i:knockout="Off" fill="#A80030" d="M32.372,59.764l-0.252,1.26c1.181,1.604,2.118,3.342,3.626,4.596
+                C34.661,63.502,33.855,62.627,32.372,59.764"/>
+            <path i:knockout="Off" fill="#A80030" d="M35.164,59.654c-0.625-0.691-0.995-1.523-1.409-2.352
+                c0.396,1.457,1.207,2.709,1.962,3.982L35.164,59.654"/>
+            <path i:knockout="Off" fill="#A80030" d="M84.568,48.916l-0.264,0.662c-0.484,3.438-1.529,6.84-3.131,9.994
+                C82.943,56.244,84.088,52.604,84.568,48.916"/>
+            <path i:knockout="Off" fill="#A80030" d="M45.527,0.537C46.742,0.092,48.514,0.293,49.803,0c-1.68,0.141-3.352,0.225-5.003,0.438
+                L45.527,0.537"/>
+            <path i:knockout="Off" fill="#A80030" d="M2.872,23.219c0.28,2.592-1.95,3.598,0.494,1.889
+                C4.676,22.157,2.854,24.293,2.872,23.219"/>
+            <path i:knockout="Off" fill="#A80030" d="M0,35.215c0.563-1.728,0.665-2.766,0.88-3.766C-0.676,33.438,0.164,33.862,0,35.215"/>
+        </g>
+    </g>
+</svg>
diff --git a/docs/source/dev-build-options.rst b/docs/source/dev-build-options.rst
new file mode 100644
index 000000000..c4b12a8fe
--- /dev/null
+++ b/docs/source/dev-build-options.rst
@@ -0,0 +1,103 @@
+.. 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
index 25319cbeb..0617796c0 100644
--- a/docs/source/developer/assign_xexpression.svg
+++ b/docs/source/developer/assign_xexpression.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="641px" height="401px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7Vtbb5swFP41SNvDJoyhoY9t1m4vkyb1Yd3T5IIbrAKOjJOQ/foZsEOwnQa1IW0a8lJ8fMPfuXyHA3XgNCu/MzRPftIYp47nxqUDvzmeB1zfE38qybqRBIHfCGaMxHJQK7gj/7CaKaULEuOiM5BTmnIy7wojmuc44h0ZYoyuusMeadrddY5m2BDcRSg1pb9JzJNGGgZuK/+BySxROwNX9jyg6GnG6CKX+zkefKx/TXeG1FpyfJGgmK62RPDGgVNGKW+usnKK0wpbBVsz73ZH7+a+Gc55nwlST0uULrC64/q++FphUZ8GV+NdB16vEsLx3RxFVe9KaF/IEp6logXEZcEZfcJTmlJWz4Zu/RM9jyRNt+S39a+S05xLAwC+bNvmyxvFjONy52HBBkJhmphmmLO1GCInBBcSdWmVnmqvWh0DJUu29OtLGZJmNdss3UIrLiS6dqThOSG98Ye1AvCISPvnhHSoA23g7LkD4RwYOKOiILP8b4nLOcPimuaf0qRwPLGUy5Lis6EHcW7+HNg5zbGGsxShVOwkmpHACQv5dYUiERH8SnZkJI6rbaza7er/7dQVWNziMjDV5R1AXRfn5BbwYq9fDBZ/JgbQwhnEsUdf0HQUBnudAVh0dAhnCPc7A87jqyqVrIBNq8gW9bb/nhgKnNj6XgJfN/5Uja9B1SwJv5c7VddtT3OjONYy2IIuWIQ7DMgRm2He8f4e2tmCP7Cgr2QMp4iTZfcmbCqRO/yiRGy8KxCCQFNqcxw5aTuB1dYBUFvI1RZqQDAWqg1kc+peNnNp2IyC/oyduFcCMowPq9hwHoymO4zl2WWwTA8AA2mZ6sWIow6vNReckSVB6UhyXgi7apvYMr6hHKTH0/0xWa4htg3PbbFcy3l/5L4vYzkVEt4NzQGv67be5KU8N9EW0g3kcDwHzFKFaTdn58hAC8DhEYmuT0UjodnDojhxkgO+ZuWWdCK0oBweAmWznvGRoqUKjZ1w6b+zcKn5GLx8abTUngqgngUdMFqadRWZ/TjwdgybQK+5WxIgf6i4aVZiPmjc9N03jJtmLaUsSBaP5l8pZlf+dwzzNwsWb0FoOwtZz5W/+hCaLf+fjIT2WkJTpnceZRWoZZy2N5WD1VU8s66yxBGnTJw9rsYJkMsvD6ioWyml8zGiQr/71sAHpsIGq6goV9hSWMHxfI7ZqCXtA4Bwv5aGIr4+31qc8pOchfjg++a9AByI9/yL4XivR5XllK1mYlqNcrbRbF5hNmbZSMRhhgSLj5zQ/fxO067tWQgMVUPt8/nLCb/xt3r36Nyvdm6zgrTGxejKnl7WsLyNHiy7M+tNo04cswYIvSPqxCw15XRUia8z3hHdRAXJUSXPvmEc0EtEs/1HjoZ82v+WgTf/AQ==&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="480" y="220" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="20" y="360" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="0" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(8.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="178" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 179px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_xexpression(lhs, rhs)</div></div></foreignObject><text x="89" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_xexpression(lhs, rhs)</text></switch></g><rect x="280" y="0" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(313.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="92" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 92px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">resize(lhs, rhs)</div></div></foreignObject><text x="46" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">resize(lhs, rhs)</text></switch></g><path d="M 200 20 L 273.63 20" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 278.88 20 L 271.88 23.5 L 273.63 20 L 271.88 16.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(205.5,2.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><rect x="0" y="120" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(12.5,132.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="170" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 171px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_data(lhs, rhs, trivial)</div></div></foreignObject><text x="85" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_data(lhs, rhs, trivial)</text></switch></g><path d="M 100 40 L 100 113.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 118.88 L 96.5 111.88 L 100 113.63 L 103.5 111.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(105.5,42.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g><path d="M 100 200 L 140 240 L 100 280 L 60 240 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 160 L 100 193.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 198.88 L 96.5 191.88 L 100 193.63 L 103.5 191.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(79.5,232.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="41" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 42px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">trivial?</div></div></foreignObject><text x="21" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">trivial?</text></switch></g><path d="M 360 200 L 400 240 L 360 280 L 320 240 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(337.5,232.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="45" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 45px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsimd?</div></div></foreignObject><text x="23" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xsimd?</text></switch></g><path d="M 140 240 L 313.63 240" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 318.88 240 L 311.88 243.5 L 313.63 240 L 311.88 236.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="260" y="360" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(272.5,372.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="174" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 175px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">vectorized index-based loop</div></div></foreignObject><text x="87" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">vectorized index-based loop</text></switch></g><g transform="translate(37.5,372.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="120" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 121px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">stepper-based loop</div></div></foreignObject><text x="60" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">stepper-based loop</text></switch></g><path d="M 100 280 L 100 353.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 358.88 L 96.5 351.88 L 100 353.63 L 103.5 351.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 360 280 L 360 353.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 360 358.88 L 356.5 351.88 L 360 353.63 L 363.5 351.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(501.5,232.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="117" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 118px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">iterator-based loop</div></div></foreignObject><text x="59" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">iterator-based loop</text></switch></g><path d="M 400 240 L 473.63 240" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 478.88 240 L 471.88 243.5 L 473.63 240 L 471.88 236.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(148.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="22" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 23px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">yes</div></div></foreignObject><text x="11" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">yes</text></switch></g><g transform="translate(328.5,282.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="22" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 23px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">yes</div></div></foreignObject><text x="11" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">yes</text></switch></g><g transform="translate(412.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="15" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 17px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">no</div></div></foreignObject><text x="8" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">no</text></switch></g><g transform="translate(72.5,282.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="15" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 17px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">no</div></div></foreignObject><text x="8" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">no</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="641px" height="401px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7Vtbb5swFP41SNvDJoyhoY9t1m4vkyb1Yd3T5IIbrAKOjJOQ/foZsEOwnQa1IW0a8lJ8fMPfuXyHA3XgNCu/MzRPftIYp47nxqUDvzmeB1zfE38qybqRBIHfCGaMxHJQK7gj/7CaKaULEuOiM5BTmnIy7wojmuc44h0ZYoyuusMeadrddY5m2BDcRSg1pb9JzJNGGgZuK/+BySxROwNX9jyg6GnG6CKX+zkefKx/TXeG1FpyfJGgmK62RPDGgVNGKW+usnKK0wpbBVsz73ZH7+a+Gc55nwlST0uULrC64/q++FphUZ8GV+NdB16vEsLx3RxFVe9KaF/IEp6logXEZcEZfcJTmlJWz4Zu/RM9jyRNt+S39a+S05xLAwC+bNvmyxvFjONy52HBBkJhmphmmLO1GCInBBcSdWmVnmqvWh0DJUu29OtLGZJmNdss3UIrLiS6dqThOSG98Ye1AvCISPvnhHSoA23g7LkD4RwYOKOiILP8b4nLOcPimuaf0qRwPLGUy5Lis6EHcW7+HNg5zbGGsxShVOwkmpHACQv5dYUiERH8SnZkJI6rbaza7er/7dQVWNziMjDV5R1AXRfn5BbwYq9fDBZ/JgbQwhnEsUdf0HQUBnudAVh0dAhnCPc7A87jqyqVrIBNq8gW9bb/nhgKnNj6XgJfN/5Uja9B1SwJv5c7VddtT3OjONYy2IIuWIQ7DMgRm2He8f4e2tmCP7Cgr2QMp4iTZfcmbCqRO/yiRGy8KxCCQFNqcxw5aTuB1dYBUFvI1RZqQDAWqg1kc+peNnNp2IyC/oyduFcCMowPq9hwHoymO4zl2WWwTA8AA2mZ6sWIow6vNReckSVB6UhyXgi7apvYMr6hHKTH0/0xWa4htg3PbbFcy3l/5L4vYzkVEt4NzQGv67be5KU8N9EW0g3kcDwHzFKFaTdn58hAC8DhEYmuT0UjodnDojhxkgO+ZuWWdCK0oBweAmWznvGRoqUKjZ1w6b+zcKn5GLx8abTUngqgngUdMFqadRWZ/TjwdgybQK+5WxIgf6i4aVZiPmjc9N03jJtmLaUsSBaP5l8pZlf+dwzzNwsWb0FoOwtZz5W/+hCaLf+fjIT2WkJTpnceZRWoZZy2N5WD1VU8s66yxBGnTJw9rsYJkMsvD6ioWyml8zGiQr/71sAHpsIGq6goV9hSWMHxfI7ZqCXtA4Bwv5aGIr4+31qc8pOchfjg++a9AByI9/yL4XivR5XllK1mYlqNcrbRbF5hNmbZSMRhhgSLj5zQ/fxO067tWQgMVUPt8/nLCb/xt3r36Nyvdm6zgrTGxejKnl7WsLyNHiy7M+tNo04cswYIvSPqxCw15XRUia8z3hHdRAXJUSXPvmEc0EtEs/1HjoZ82v+WgTf/AQ==&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="480" y="220" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="20" y="360" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="0" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(8.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="178" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 179px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_xexpression(lhs, rhs)</div></div></foreignObject><text x="89" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_xexpression(lhs, rhs)</text></switch></g><rect x="280" y="0" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(313.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="92" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 92px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">resize(lhs, rhs)</div></div></foreignObject><text x="46" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">resize(lhs, rhs)</text></switch></g><path d="M 200 20 L 273.63 20" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 278.88 20 L 271.88 23.5 L 273.63 20 L 271.88 16.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(205.5,2.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><rect x="0" y="120" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(12.5,132.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="170" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 171px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_data(lhs, rhs, trivial)</div></div></foreignObject><text x="85" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_data(lhs, rhs, trivial)</text></switch></g><path d="M 100 40 L 100 113.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 118.88 L 96.5 111.88 L 100 113.63 L 103.5 111.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(105.5,42.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g><path d="M 100 200 L 140 240 L 100 280 L 60 240 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 160 L 100 193.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 198.88 L 96.5 191.88 L 100 193.63 L 103.5 191.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(79.5,232.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="41" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 42px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">trivial?</div></div></foreignObject><text x="21" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">trivial?</text></switch></g><path d="M 360 200 L 400 240 L 360 280 L 320 240 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(337.5,232.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="45" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 45px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsimd?</div></div></foreignObject><text x="23" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xsimd?</text></switch></g><path d="M 140 240 L 313.63 240" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 318.88 240 L 311.88 243.5 L 313.63 240 L 311.88 236.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="260" y="360" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(272.5,372.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="174" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 175px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">vectorized index-based loop</div></div></foreignObject><text x="87" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">vectorized index-based loop</text></switch></g><g transform="translate(37.5,372.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="120" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 121px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">stepper-based loop</div></div></foreignObject><text x="60" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">stepper-based loop</text></switch></g><path d="M 100 280 L 100 353.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 358.88 L 96.5 351.88 L 100 353.63 L 103.5 351.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 360 280 L 360 353.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 360 358.88 L 356.5 351.88 L 360 353.63 L 363.5 351.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(501.5,232.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="117" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 118px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">iterator-based loop</div></div></foreignObject><text x="59" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">iterator-based loop</text></switch></g><path d="M 400 240 L 473.63 240" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 478.88 240 L 471.88 243.5 L 473.63 240 L 471.88 236.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(148.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="22" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 23px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">yes</div></div></foreignObject><text x="11" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">yes</text></switch></g><g transform="translate(328.5,282.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="22" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 23px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">yes</div></div></foreignObject><text x="11" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">yes</text></switch></g><g transform="translate(412.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="15" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 17px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">no</div></div></foreignObject><text x="8" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">no</text></switch></g><g transform="translate(72.5,282.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="15" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 17px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">no</div></div></foreignObject><text x="8" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">no</text></switch></g></g></svg>
diff --git a/docs/source/developer/assignment.rst b/docs/source/developer/assignment.rst
index 3b17aead6..2d51d7e3e 100644
--- a/docs/source/developer/assignment.rst
+++ b/docs/source/developer/assignment.rst
@@ -9,14 +9,14 @@
 Assignment
 ==========
 
-In this section, we consider the class ``xarray`` and its semantic bases (``xcontainer_semantic`` and
-``xsemantic_base``) to illustrate how the assignment works. `xtensor` provides different mechanics of
+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
 ~~~~~~~~~~~~~~~~~~~~~~
 
-``xarray`` provides an extended copy constructor and an extended assignment operator:
+:cpp:type:`xt::xarray` provides an extended copy constructor and an extended assignment operator:
 
 .. code::
 
@@ -37,8 +37,8 @@ The assignment operator forwards to ``xsemantic_base::operator=`` whose implemen
         return this->derived_cast().assign_temporary(std::move(tmp));
     }
 
-Here ``temporary_type`` is ``xarray``, the assignment operator computes the result of the expression in
-a temporary variable and then assigns it to the ``xarray`` instance. This temporary variable avoids aliasing
+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::
@@ -132,7 +132,7 @@ The three main functions for assigning expressions (``assign_xexpression``, ``co
 tag:
 
 .. code::
-    
+
     template <class E1, class E2>
     inline void assign_xexpression(xexpression<E1>& e1, const xexpression<E2>& e2)
     {
@@ -159,7 +159,7 @@ tag:
         // ...
     };
 
-`xtensor` provides specializations for ``xtensor_expression_tag`` and ``xoptional_expression_tag``.
+*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.
 
@@ -172,10 +172,10 @@ during the resize phase, is the nature of the assignment: trivial or not. The as
 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
+- 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
+  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.
@@ -213,4 +213,3 @@ operation on each value:
         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
index 4a31ff162..518784652 100644
--- a/docs/source/developer/computed_assign.svg
+++ b/docs/source/developer/computed_assign.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="461px" height="361px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VpNb5swGP41SNulwhia5Nhm7XaZNKmHtafKBResAkbGaZL9+hmwAWNYURSyVCGX4NefPM/76cSC62T3naEs+kkDHFuOHews+M1yHGC7jvgqJPtK4nluJQgZCeSgRvBA/mA1U0o3JMC5NpBTGnOS6UKfpin2uSZDjNGtPuyVxvquGQqxIXjwUWxKf5OAR5V06dmN/AcmYaR2BrbseUH+W8joJpX7WQ58LT9Vd4LUWnJ8HqGAblsieGfBNaOUV0/Jbo3jAlsFWzXvfqC3PjfDKR8zQfL0juINVicuz8X3CovybXAx3rbg7TYiHD9kyC96t4J9IYt4EosWEI85Z/QNr2lMWTkb2uVH9LySOG7J78tPIacplwoAXNnumy8PihnHu8GXBTWEQjUxTTBnezFEToBKLaVWwmvJwrbhGKwWlSxq8evKcUiqVVgv3UArHiS6/UjDy0La1pB2libSjrKZYyPtXhLSSx1o94Q4ewbOPk2yDcfBM8pzEqZf4ii3HLGOzaL8q0GCeGn+L6RTmuIOyFKEYrG6aPoCJCzktwWERLjvG9mRkCAotumlVif//3Hl9Xkfz+TKOQJX15dkE7VfHzYKcD2RUSwMoBnOxWvPttDhaOl9aAygh6NjGMPyY2PAaXBT5JEFsHHhzfzR+j8SQ4ET2z9K4MvGU9G48ormjvBHuVPx3PRUB8VBJ33N6Yb5WAt/HLEQc836R7DTgt/rQV/JGI4RJ+/6IfookTv8okRsPOQIgdchtXodOamdvXbWAbCzkN1ZqALBWKhUkPqtR+nMytAZBf0FG/Go7GMaG1a+4UIiWiefBqsT5nkAGFBX+d1zgDjSAlv1wBl5Jyieo5zgDWq81RxpOd9UJmIW96aNXBwloOOzeivTiQgZcwcQ0eRlk39yfwVUvFT+qu+mxXZMmI0IfhDO5g3AC6Mo8FHOSRpa8H42A9Cpkfo8kzuVHZg3BwYhp0zAq5y7TsFbCXiTjj/Jfa2DEnBl+eeagbvwSBk4XE6WgYMRdxifuGxTKqKpTf17w3mqDTyW2jgTqo15I5PS2f87EOgRuqeiAKuJ/L95AdMuKHiSzQXF2IKil7ap4rZ5CSKKvyvJHcdJRhli+4LAmSqjZoeLkTX7MahSa5x/sDwoxeoNlqvzDpbu4kjB0u0qyECwFOSifWtYVgzIh8/brYxVLteoXLXioZHYMe+RzkwnBzSvrWXnlsgbpHUL6Km17BBFMC+m9jifIwbwlnpw77k1mepuquf/KfMPHMPWdQpGzFss01/OjExnI6LZ/BGvcnPNvx3h3V8=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="262" y="320" width="197" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="260" y="240" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="0" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(15.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="164" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 166px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">computed_assign(lhs, rhs)</div></div></foreignObject><text x="82" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">computed_assign(lhs, rhs)</text></switch></g><rect x="280" y="0" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(313.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="92" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 92px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">resize(lhs, rhs)</div></div></foreignObject><text x="46" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">resize(lhs, rhs)</text></switch></g><path d="M 200 20 L 273.63 20" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 278.88 20 L 271.88 23.5 L 273.63 20 L 271.88 16.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(205.5,2.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><rect x="260" y="150" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(272.5,162.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="170" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 171px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_data(lhs, rhs, trivial)</div></div></foreignObject><text x="85" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_data(lhs, rhs, trivial)</text></switch></g><g transform="translate(105.5,42.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g><path d="M 100 120 L 151 170 L 100 220 L 49 170 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(55.5,162.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="88" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 89px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">broadcasting?</div></div></foreignObject><text x="44" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">broadcasting?</text></switch></g><path d="M 100 40 L 100 113.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 118.88 L 96.5 111.88 L 100 113.63 L 103.5 111.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 151 170 L 253.63 170" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 258.88 170 L 251.88 173.5 L 253.63 170 L 251.88 166.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(152.5,152.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="15" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 17px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">no</div></div></foreignObject><text x="8" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">no</text></switch></g><g transform="translate(269.5,252.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="176" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 177px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_data(tmp, rhs, trivial)</div></div></foreignObject><text x="88" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_data(tmp, rhs, trivial)</text></switch></g><g transform="translate(276.5,332.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="166" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 167px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">lhs.assign_temporary(tmp)</div></div></foreignObject><text x="83" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">lhs.assign_temporary(tmp)</text></switch></g><path d="M 100 220 L 100 330 Q 100 340 110 340 L 253.63 340" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 258.88 340 L 251.88 343.5 L 253.63 340 L 251.88 336.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 260 L 253.63 260" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 258.88 260 L 251.88 263.5 L 253.63 260 L 251.88 256.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(76.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="22" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 23px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">yes</div></div></foreignObject><text x="11" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">yes</text></switch></g><g transform="translate(105.5,262.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><g transform="translate(105.5,322.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="461px" height="361px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VpNb5swGP41SNulwhia5Nhm7XaZNKmHtafKBResAkbGaZL9+hmwAWNYURSyVCGX4NefPM/76cSC62T3naEs+kkDHFuOHews+M1yHGC7jvgqJPtK4nluJQgZCeSgRvBA/mA1U0o3JMC5NpBTGnOS6UKfpin2uSZDjNGtPuyVxvquGQqxIXjwUWxKf5OAR5V06dmN/AcmYaR2BrbseUH+W8joJpX7WQ58LT9Vd4LUWnJ8HqGAblsieGfBNaOUV0/Jbo3jAlsFWzXvfqC3PjfDKR8zQfL0juINVicuz8X3CovybXAx3rbg7TYiHD9kyC96t4J9IYt4EosWEI85Z/QNr2lMWTkb2uVH9LySOG7J78tPIacplwoAXNnumy8PihnHu8GXBTWEQjUxTTBnezFEToBKLaVWwmvJwrbhGKwWlSxq8evKcUiqVVgv3UArHiS6/UjDy0La1pB2libSjrKZYyPtXhLSSx1o94Q4ewbOPk2yDcfBM8pzEqZf4ii3HLGOzaL8q0GCeGn+L6RTmuIOyFKEYrG6aPoCJCzktwWERLjvG9mRkCAotumlVif//3Hl9Xkfz+TKOQJX15dkE7VfHzYKcD2RUSwMoBnOxWvPttDhaOl9aAygh6NjGMPyY2PAaXBT5JEFsHHhzfzR+j8SQ4ET2z9K4MvGU9G48ormjvBHuVPx3PRUB8VBJ33N6Yb5WAt/HLEQc836R7DTgt/rQV/JGI4RJ+/6IfookTv8okRsPOQIgdchtXodOamdvXbWAbCzkN1ZqALBWKhUkPqtR+nMytAZBf0FG/Go7GMaG1a+4UIiWiefBqsT5nkAGFBX+d1zgDjSAlv1wBl5Jyieo5zgDWq81RxpOd9UJmIW96aNXBwloOOzeivTiQgZcwcQ0eRlk39yfwVUvFT+qu+mxXZMmI0IfhDO5g3AC6Mo8FHOSRpa8H42A9Cpkfo8kzuVHZg3BwYhp0zAq5y7TsFbCXiTjj/Jfa2DEnBl+eeagbvwSBk4XE6WgYMRdxifuGxTKqKpTf17w3mqDTyW2jgTqo15I5PS2f87EOgRuqeiAKuJ/L95AdMuKHiSzQXF2IKil7ap4rZ5CSKKvyvJHcdJRhli+4LAmSqjZoeLkTX7MahSa5x/sDwoxeoNlqvzDpbu4kjB0u0qyECwFOSifWtYVgzIh8/brYxVLteoXLXioZHYMe+RzkwnBzSvrWXnlsgbpHUL6Km17BBFMC+m9jifIwbwlnpw77k1mepuquf/KfMPHMPWdQpGzFss01/OjExnI6LZ/BGvcnPNvx3h3V8=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="262" y="320" width="197" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="260" y="240" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="0" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(15.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="164" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 166px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">computed_assign(lhs, rhs)</div></div></foreignObject><text x="82" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">computed_assign(lhs, rhs)</text></switch></g><rect x="280" y="0" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(313.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="92" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 92px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">resize(lhs, rhs)</div></div></foreignObject><text x="46" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">resize(lhs, rhs)</text></switch></g><path d="M 200 20 L 273.63 20" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 278.88 20 L 271.88 23.5 L 273.63 20 L 271.88 16.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(205.5,2.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><rect x="260" y="150" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(272.5,162.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="170" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 171px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_data(lhs, rhs, trivial)</div></div></foreignObject><text x="85" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_data(lhs, rhs, trivial)</text></switch></g><g transform="translate(105.5,42.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g><path d="M 100 120 L 151 170 L 100 220 L 49 170 Z" fill="#ffffff" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(55.5,162.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="88" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 89px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">broadcasting?</div></div></foreignObject><text x="44" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">broadcasting?</text></switch></g><path d="M 100 40 L 100 113.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 118.88 L 96.5 111.88 L 100 113.63 L 103.5 111.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 151 170 L 253.63 170" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 258.88 170 L 251.88 173.5 L 253.63 170 L 251.88 166.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(152.5,152.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="15" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 17px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">no</div></div></foreignObject><text x="8" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">no</text></switch></g><g transform="translate(269.5,252.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="176" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 177px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">assign_data(tmp, rhs, trivial)</div></div></foreignObject><text x="88" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">assign_data(tmp, rhs, trivial)</text></switch></g><g transform="translate(276.5,332.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="166" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 167px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">lhs.assign_temporary(tmp)</div></div></foreignObject><text x="83" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">lhs.assign_temporary(tmp)</text></switch></g><path d="M 100 220 L 100 330 Q 100 340 110 340 L 253.63 340" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 258.88 340 L 251.88 343.5 L 253.63 340 L 251.88 336.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 100 260 L 253.63 260" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 258.88 260 L 251.88 263.5 L 253.63 260 L 251.88 256.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(76.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="22" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 23px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">yes</div></div></foreignObject><text x="11" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">yes</text></switch></g><g transform="translate(105.5,262.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><g transform="translate(105.5,322.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="8" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 8px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g></g></svg>
diff --git a/docs/source/developer/concepts.rst b/docs/source/developer/concepts.rst
index 3ea368db3..06de0ffd2 100644
--- a/docs/source/developer/concepts.rst
+++ b/docs/source/developer/concepts.rst
@@ -9,22 +9,24 @@
 Concepts
 ========
 
-`xtensor`'s core is built upon key concepts captured in interfaces that are put together in
-derived classes through CRTP and multiple inheritance. Interfaces and classes that model
-expressions implement *value semantic*. CRTP and value semantic achieve static polymorphism and
-avoids performance overhead of virtual methods and dynamic dispatching.
+*xtensor*'s core is built upon key concepts captured in interfaces that are put together in derived
+classes through CRTP (`Curiously Recurring Template Pattern
+<https://en.wikipedia.org/wiki/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
 ~~~~~~~~~~~
 
-``xexpression`` is the base class for all expression classes. It is a CRTP base whose template
+: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 ``xexpression``, then ``B`` should be a template
-class whose template parameter is ``A`` and should forward this parameter to ``xexpression``:
+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 "xtensor/xexpression.hpp"
+    #include <xtensor/core/xexpression.hpp>
 
     template <class T>
     class B : public xexpression<T>
@@ -37,14 +39,14 @@ class whose template parameter is ``A`` and should forward this parameter to ``x
         // ...
     };
 
-``xexpression`` only provides three overloads of a same function, that cast an ``xexpression``
-object to the most inheriting type, depending on the nature of the object (lvalue,
-const lvalue or rvalue):
+: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() & noexcept;
+    const derived_type& derived_cast() const & noexcept;
     derived_type derived_cast() && noexcept;
 
 .. _xiterable-concept-label:
@@ -53,12 +55,18 @@ xiterable
 ~~~~~~~~~
 
 The iterable concept is modeled by two classes, ``xconst_iterable`` and ``xiterable``, defined
-in ``xtensor/xiterable.hpp``. ``xconst_iterable`` provides types and methods for iterating on
+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.
-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.
+
+.. 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::
 
@@ -80,20 +88,18 @@ Column-major layout means that elements that only differ by their first index ar
     template <class L>
     const_reverse_iterator crend() const noexcept;
 
-.. image:: iteration.svg
-
-This template parameter is defaulted to ``XTENSOR_DEFAULT_LAYOUT`` (see :ref:`configuration-label`), so
-that `xtensor` expressions can be used in generic code such as:
+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)
+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 ``xexpression``, both are CRTP classes whose template
+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
@@ -105,7 +111,7 @@ given shape:
     #include <algorithm>
     #include <iterator>
     #include <iostream>
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     int main(int argc, char* argv[])
     {
@@ -140,8 +146,8 @@ The first overload is meant for computed assignment involving a scalar; it allow
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xio.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
 
     int main(int argc, char* argv)
     {
@@ -154,7 +160,7 @@ The first overload is meant for computed assignment involving a scalar; it allow
 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 method taking a general ``xexpression`` parameter don't perform a direct assignment. Instead,
+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
 
@@ -185,9 +191,9 @@ Temporaries can be avoided with the assign-based methods:
     derived_type& modulus_assign(const xexpression<E>&);
 
 ``xsemantic_base`` is a CRTP class whose parameter must be the most derived type in the hierarchy. It inherits
-from ``xexpression`` and forwards its template parameter to this latter one.
+from :cpp:type:`xt::xexpression` and forwards its template parameter to this latter one.
 
-``xsemantic_base`` also provides a assignment operator that takes an ``xexpression`` in its protected section:
+``xsemantic_base`` also provides a assignment operator that takes an :cpp:type:`xt::xexpression` in its protected section:
 
 .. code::
 
@@ -241,7 +247,7 @@ methods:
     disable_integral_t<S, const_reference> operator[](const S& index) const;
 
     template <class I>
-    const_reference operator[](std::initialize_list<I> index) const;
+    const_reference operator[](std::initializer_list<I> index) const;
 
     template <class It>
     const_reference element(It first, It last) const;
@@ -257,9 +263,6 @@ methods:
     template <class S>
     bool broadcast_shape(const S& shape) const;
 
-    template <class S>
-    bool is_trivial_broadcast(const S& strides) const;
-
 Lower-level methods are also provided, meant for optimized assignment and BLAS bindings.
 They are covered in the :ref:`xtensor-assign-label` section.
 
@@ -267,8 +270,8 @@ If you read the entire code of ``xcontainer``, you'll notice that two types are
 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.
+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:
diff --git a/docs/source/developer/expression_tree.rst b/docs/source/developer/expression_tree.rst
index a5e6c2eb9..b33907e05 100644
--- a/docs/source/developer/expression_tree.rst
+++ b/docs/source/developer/expression_tree.rst
@@ -7,14 +7,14 @@
 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
+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
+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:
 
@@ -105,7 +105,7 @@ This latter is responsible for setting the remaining template parameters of ``xf
     }
 
 The first line computes the ``expression_tag`` of the expression. This tag is used for selecting the right class
-class modeling a function. In `xtensor`, two tags are provided, with the following mapping:
+class modeling a function. In *xtensor*, two tags are provided, with the following mapping:
 
 - ``xtensor_expression_tag`` -> ``xfunction``
 - ``xoptional_expression_tag`` -> ``xfunction``
@@ -114,7 +114,7 @@ In the case of ``xfunction``, the tag is also used to select a mixin base class
 
 Any expression may define a tag as its ``expression_tag`` inner type. If not, ``xtensor_expression_tag`` is used by default.
 Tags have different priorities so that a resulting tag can be computed for expressions involving different tag types. As we
-will see in the next section, this system of tags and mapping make it easy to plug new functions types in `xtensor` and have
+will see in the next section, this system of tags and mapping make it easy to plug new functions types in *xtensor* and have
 them working with all the mathematical functions already implemented.
 
 The function class mapped to the expression tag is retrieved in the third line of ``make_xfunction``, that is:
@@ -135,7 +135,7 @@ Once all the types are known, ``make_xfunction`` can instantiate the right funct
 Plugging new function types
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-As mentioned in the section above, one can define a new function class and have it used by `xtensor`'s expression system. Let's
+As mentioned in the section above, one can define a new function class and have it used by *xtensor*'s expression system. Let's
 illustrate this with an hypothetical  ``xmapped_function`` class, which provides additional mapping access operators.
 The first thing to do is to define a new tag:
 
@@ -170,7 +170,7 @@ This is done by specializing the ``expression_tag_and`` metafunction available i
 
 The second specialization simply forwards to the first one so we don't duplicate code. Note that when plugging your own
 function class, these specializations can be skipped if the new function class (and its corresponding tag) is not compatible,
-and thus not supposed to be mixed, with the function classes provided by `xtensor`.
+and thus not supposed to be mixed, with the function classes provided by *xtensor*.
 
 The last requirement is to specialize the ``select_xfunction_expression`` metafunction, as it is shown below:
 
@@ -191,4 +191,3 @@ The last requirement is to specialize the ``select_xfunction_expression`` metafu
 In this example, ``xmapped_function`` may provide the same API as ``xfunction`` and define some additional methods unrelated to the
 assignment mechanics. However it is possible to define a function class with an API totally different from the one of ``xfunction``.
 In that case, the assignment mechanics need to be customized too, this is detailed in :ref:`xtensor-assign-label`.
-
diff --git a/docs/source/developer/extended_copy_semantic.svg b/docs/source/developer/extended_copy_semantic.svg
index f2cfc6503..25360df81 100644
--- a/docs/source/developer/extended_copy_semantic.svg
+++ b/docs/source/developer/extended_copy_semantic.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="769px" height="371px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VtLc5swEP41PqaDxCP46LpNe+lMZ3Joc8ooRrGZYkSFXOP++kog8RCyQ2NwaA0Xw2r1YPf7pNUiz+zlNvtEUbL5QgIczaAVZDP7wwxCYDmQ/wjJoZC4rlMI1jQMpFIluA9/Y1VTSndhgNOGIiMkYmHSFK5IHOMVa8gQpWTfVHsmUbPXBK1xS3C/QlFb+i0M2KaQ+q5VyT/jcL1RPQNLljyh1Y81JbtY9jeD9nN+FcVbpNqS+ukGBWRfE9kfZ/aSEsKKu222xJGwrTJbUe/uSGk5bopj1qWC9NMvFO2wGnE+LnZQtsjfBgt9a2a/329Chu8TtBKle+59LtuwbcSfAL9NGSU/8JJEhOa1bSu/eMlzGEU1+V1+CTmJmQQA8ORzTU9cuZ4cKKYMZ0dfFpQm5NDEZIsZPXAVWcGXRpegtJUT9pWLgSdlm5p7HSlDElXrsuXKsvxGGtdsaNtgaC9i8oUbFvd+7ogquElz0yy4AnCSrCrkd2vxm3G4o4PQsBckwRQxabmicT6sov1Cu+Vcbkx2yoMxibHmPClCUbiO+eOKGx9z+XvhmpBTaCELtmEQiG6MkGmC6gUMlBjqAQMlUxUIbAMIoAEEsAcQONfENqdpaGi1DV3q9M02dyi28QWHoTDG9DHFWxRzwE/U6woIVwMEMABiKOZ5Y2den4bWmOdfkHi3QxFP0e3xCaV44lxXKHhuAwpzw2I3H4hy/lVR7i1jy/kFYkt5P/HsiP/nTaIZw0p7IKaphfQ6qWZa3qyBmAZAy9KmlQmlqQDr+FnhXJYVpuXHNCn2QopxpTaGtrQW8wETK/yhWNFObhzdKBXUeMxwllDM78lEE+68Jk2AgSdwMJ50SErgOFiIrKowbSQ8uOpMjY5W5Jaih+/C9O9c9fggW8dZyGpF/OlB+qgYKA60ZG5KdnQlRfJlGKJrrCDf2T81+7sG8ysZxRFi4a/mIEw+kT18JWEelpm3a46tebV4HVkJ1nK5WjtzLQT1tXYKG7TayQFSvnQ3zJjyK/8PZpw2ZrwJM+dipkMK5oKYAXXEVCj5XsNPVdIBM34bMyosHw1obvpCDXgdahbFFrJUS4RCeny8t57Wj2OdHJaur3L9FWiLEbwawqbs1mimPevotAe6QVh5tYFhOGH47JlvXJmwC+9EoCETNtxOpJ0Ke2knwvA2IRTJfqZ9SN11hiTWYPsQ1cYbT67GGODWbcy77dChw+zqtSdXf2Rz6xsHlX8bHpQ5drXcg9Phga6vhRNnhwewnRx80/Cga4QLX49gMEH4LAg72mmU+WkE6+qwbwTDFoIVDq54WdTPjQFDRGP6nt7LqthOrbYnlav3yO0FHTKuM1wXNnQ5AV3iY5vhFJfA+fQVwewrW1scHMP5qsG+tnU5YPUPZ/dUGqQe+4z9O4IL+ol9HG+Y2MfXgxnrdPCj6zvwrOCHP1bH7Av16r8M9sc/&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="40" y="250" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(66.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="106" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 108px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xarray::operator=</font></div></div></foreignObject><text x="53" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="0" y="130" width="240" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(21.5,141.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="197" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 197px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xcontainer_semantic::operator=</font></div></div></foreignObject><text x="99" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="0" y="10" width="240" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(34.5,21.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="170" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 171px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xsemantic_base::operator=</font></div></div></foreignObject><text x="85" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="440" y="250" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(476.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="86" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 87px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xarray::xarray</font></div></div></foreignObject><text x="43" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="440" y="10" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(459.5,22.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="150" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 151px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsemantic_base::assign</div></div></foreignObject><text x="75" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xsemantic_base::assign</text></switch></g><rect x="400" y="110" width="280" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(405.5,122.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="258" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 260px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic::assign_xexpression</div></div></foreignObject><text x="129" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xcontainer_semantic::assign_xexpression</text></switch></g><path d="M 120 250 L 120 176.37" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 171.12 L 123.5 178.12 L 120 176.37 L 116.5 178.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 130 L 120 56.37" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 51.12 L 123.5 58.12 L 120 56.37 L 116.5 58.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 600 270 L 710 270 Q 720 270 720 260 L 720 40 Q 720 30 710 30 L 646.37 30" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 641.12 30 L 648.12 26.5 L 646.37 30 L 648.12 33.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 540 50 L 540 103.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 540 108.88 L 536.5 101.88 L 540 103.63 L 543.5 101.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="400" y="150" width="280" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(410.5,162.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="248" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 248px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic::assign_temporary</div></div></foreignObject><text x="124" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xcontainer_semantic::assign_temporary</text></switch></g><path d="M 240 40 L 270 40 Q 280 40 280 50 L 280 260 Q 280 270 290 270 L 433.63 270" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 438.88 270 L 431.88 273.5 L 433.63 270 L 431.88 266.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 240 20 L 350 20 Q 360 20 360 30 L 360 160 Q 360 170 370 170 L 393.63 170" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 398.88 170 L 391.88 173.5 L 393.63 170 L 391.88 166.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(256.5,52.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 9px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><g transform="translate(256.5,2.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 9px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g><rect x="240" y="330" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(268.5,342.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="142" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 143px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xt::assign_xexpression</div></div></foreignObject><text x="71" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xt::assign_xexpression</text></switch></g><path d="M 680 130 L 750 130 Q 760 130 760 140 L 760 340 Q 760 350 750 350 L 446.37 350" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 441.12 350 L 448.12 346.5 L 446.37 350 L 448.12 353.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="769px" height="371px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VtLc5swEP41PqaDxCP46LpNe+lMZ3Joc8ooRrGZYkSFXOP++kog8RCyQ2NwaA0Xw2r1YPf7pNUiz+zlNvtEUbL5QgIczaAVZDP7wwxCYDmQ/wjJoZC4rlMI1jQMpFIluA9/Y1VTSndhgNOGIiMkYmHSFK5IHOMVa8gQpWTfVHsmUbPXBK1xS3C/QlFb+i0M2KaQ+q5VyT/jcL1RPQNLljyh1Y81JbtY9jeD9nN+FcVbpNqS+ukGBWRfE9kfZ/aSEsKKu222xJGwrTJbUe/uSGk5bopj1qWC9NMvFO2wGnE+LnZQtsjfBgt9a2a/329Chu8TtBKle+59LtuwbcSfAL9NGSU/8JJEhOa1bSu/eMlzGEU1+V1+CTmJmQQA8ORzTU9cuZ4cKKYMZ0dfFpQm5NDEZIsZPXAVWcGXRpegtJUT9pWLgSdlm5p7HSlDElXrsuXKsvxGGtdsaNtgaC9i8oUbFvd+7ogquElz0yy4AnCSrCrkd2vxm3G4o4PQsBckwRQxabmicT6sov1Cu+Vcbkx2yoMxibHmPClCUbiO+eOKGx9z+XvhmpBTaCELtmEQiG6MkGmC6gUMlBjqAQMlUxUIbAMIoAEEsAcQONfENqdpaGi1DV3q9M02dyi28QWHoTDG9DHFWxRzwE/U6woIVwMEMABiKOZ5Y2den4bWmOdfkHi3QxFP0e3xCaV44lxXKHhuAwpzw2I3H4hy/lVR7i1jy/kFYkt5P/HsiP/nTaIZw0p7IKaphfQ6qWZa3qyBmAZAy9KmlQmlqQDr+FnhXJYVpuXHNCn2QopxpTaGtrQW8wETK/yhWNFObhzdKBXUeMxwllDM78lEE+68Jk2AgSdwMJ50SErgOFiIrKowbSQ8uOpMjY5W5Jaih+/C9O9c9fggW8dZyGpF/OlB+qgYKA60ZG5KdnQlRfJlGKJrrCDf2T81+7sG8ysZxRFi4a/mIEw+kT18JWEelpm3a46tebV4HVkJ1nK5WjtzLQT1tXYKG7TayQFSvnQ3zJjyK/8PZpw2ZrwJM+dipkMK5oKYAXXEVCj5XsNPVdIBM34bMyosHw1obvpCDXgdahbFFrJUS4RCeny8t57Wj2OdHJaur3L9FWiLEbwawqbs1mimPevotAe6QVh5tYFhOGH47JlvXJmwC+9EoCETNtxOpJ0Ke2knwvA2IRTJfqZ9SN11hiTWYPsQ1cYbT67GGODWbcy77dChw+zqtSdXf2Rz6xsHlX8bHpQ5drXcg9Phga6vhRNnhwewnRx80/Cga4QLX49gMEH4LAg72mmU+WkE6+qwbwTDFoIVDq54WdTPjQFDRGP6nt7LqthOrbYnlav3yO0FHTKuM1wXNnQ5AV3iY5vhFJfA+fQVwewrW1scHMP5qsG+tnU5YPUPZ/dUGqQe+4z9O4IL+ol9HG+Y2MfXgxnrdPCj6zvwrOCHP1bH7Av16r8M9sc/&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="40" y="250" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(66.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="106" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 108px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xarray::operator=</font></div></div></foreignObject><text x="53" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="0" y="130" width="240" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(21.5,141.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="197" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 197px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xcontainer_semantic::operator=</font></div></div></foreignObject><text x="99" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="0" y="10" width="240" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(34.5,21.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="170" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 171px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xsemantic_base::operator=</font></div></div></foreignObject><text x="85" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="440" y="250" width="160" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(476.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="86" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 87px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">xarray::xarray</font></div></div></foreignObject><text x="43" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><rect x="440" y="10" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(459.5,22.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="150" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 151px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsemantic_base::assign</div></div></foreignObject><text x="75" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xsemantic_base::assign</text></switch></g><rect x="400" y="110" width="280" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(405.5,122.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="258" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 260px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic::assign_xexpression</div></div></foreignObject><text x="129" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xcontainer_semantic::assign_xexpression</text></switch></g><path d="M 120 250 L 120 176.37" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 171.12 L 123.5 178.12 L 120 176.37 L 116.5 178.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 130 L 120 56.37" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 51.12 L 123.5 58.12 L 120 56.37 L 116.5 58.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 600 270 L 710 270 Q 720 270 720 260 L 720 40 Q 720 30 710 30 L 646.37 30" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 641.12 30 L 648.12 26.5 L 646.37 30 L 648.12 33.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 540 50 L 540 103.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 540 108.88 L 536.5 101.88 L 540 103.63 L 543.5 101.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="400" y="150" width="280" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(410.5,162.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="248" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 248px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic::assign_temporary</div></div></foreignObject><text x="124" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xcontainer_semantic::assign_temporary</text></switch></g><path d="M 240 40 L 270 40 Q 280 40 280 50 L 280 260 Q 280 270 290 270 L 433.63 270" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 438.88 270 L 431.88 273.5 L 433.63 270 L 431.88 266.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 240 20 L 350 20 Q 360 20 360 30 L 360 160 Q 360 170 370 170 L 393.63 170" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 398.88 170 L 391.88 173.5 L 393.63 170 L 391.88 166.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(256.5,52.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 9px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">1</text></switch></g><g transform="translate(256.5,2.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 9px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">2</text></switch></g><rect x="240" y="330" width="200" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(268.5,342.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="142" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 14px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 143px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xt::assign_xexpression</div></div></foreignObject><text x="71" y="15" fill="#000000" text-anchor="middle" font-size="14px" font-family="Helvetica">xt::assign_xexpression</text></switch></g><path d="M 680 130 L 750 130 Q 760 130 760 140 L 760 340 Q 760 350 750 350 L 446.37 350" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 441.12 350 L 448.12 346.5 L 446.37 350 L 448.12 353.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></g></svg>
diff --git a/docs/source/developer/implementation_classes.rst b/docs/source/developer/implementation_classes.rst
index 152390a1d..d8ead757d 100644
--- a/docs/source/developer/implementation_classes.rst
+++ b/docs/source/developer/implementation_classes.rst
@@ -10,9 +10,9 @@ Implementation classes
 Requirements
 ~~~~~~~~~~~~
 
-An implementation class in `xtensor` is a final class that models a specific
+An implementation class in *xtensor* is a final class that models a specific
 kind of expression. It must inherit (either directly or indirectly) from
-``xexpression`` and define (or inherit from classes that define) the following
+:cpp:type:`xt::xexpression` and define (or inherit from classes that define) the following
 types:
 
 **container types**
@@ -46,10 +46,10 @@ types:
     template <class S, layout_type L>
     const_reverse_broadcast_iterator<S, L>;
 
-    storage_iterator;
-    const_storage_iterator;
-    reverse_storage_iterator;
-    const_reverse_storage_iterator;
+    linear_iterator;
+    const_linear_iterator;
+    reverse_linear_iterator;
+    const_reverse_linear_iterator;
 
 **layout data**
 
@@ -77,9 +77,6 @@ totally:
     template <class S>
     bool broadcast_shape(const S& shape) const;
 
-    template <class S>
-    bool is_trivial_broadcast(const S& strides) const;
-
 **data access methods**
 
 .. code::
@@ -97,7 +94,7 @@ totally:
     disable_integral_t<S, const_reference> operator[](const S& index) const;
 
     template <class I>
-    const_reference operator[](std::initialize_list<I> index) const;
+    const_reference operator[](std::initializer_list<I> index) const;
 
     template <class It>
     const_reference element(It first, It last) const;
@@ -115,7 +112,7 @@ methods, and inherits from a semantic class to provide assignment operators.
 List of available expression classes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-`xtensor` provides the following expression classes:
+*xtensor* provides the following expression classes:
 
 **Containers**
 
@@ -132,8 +129,8 @@ inheriting classes only provide constructors and assignment operators for the va
 The container classes are generally used through type aliases which set many of the template
 arguments:
 
-- ``xarray``
-- ``xtensor``
+- :cpp:type:`xt::xarray`
+- :cpp:type:`xt::xtensor`
 - ``xfixed_tensor``
 
 The classes for adaptors can be instantiated through the many overloads of ``xt::adapt`` function,
@@ -141,7 +138,7 @@ so that their templates parameters are deduced.
 
 **Scalar**
 
-`xtensor` provides the ``xscalar`` class to adapt scalar values and give them the required API.
+*xtensor* provides the ``xscalar`` class to adapt scalar values and give them the required API.
 
 **Optional containers**
 
@@ -152,7 +149,7 @@ Most of the mehtods of these classes are defined in their base class ``xoptional
 
 **Views**
 
-- ``xview``: N-dimensional view with static number of slices, supporting all kind of slices
+- :cpp:type:`xt::xview`: N-dimensional view with static number of slices, supporting all kind of slices
 - ``xstrided_view``: N-dimensional view with dynamic number of slices, supporting strided slices only (see below)
 - ``xdynamic_view``: N-dimensional view with dynamic number of slices, supporting all kind of slices
 - ``xfunctor_view``: N-dimensional view applying a functor to its underlying elements (e.g. ``imag``, ``real``)
@@ -160,7 +157,7 @@ Most of the mehtods of these classes are defined in their base class ``xoptional
 - ``xmasked_view`` : View on optional expression hiding values depending on a mask
 
 When the index of an element in the underlying expression of a view can be computed thanks to a strided scheme,
-the slice used in this view is said to be a strided slice. `xtensor` provides the following strided slices:
+the slice used in this view is said to be a strided slice. *xtensor* provides the following strided slices:
 
 - ``xrange``
 - ``xstepped_range``
@@ -184,16 +181,16 @@ Contrary to containers and views, the functional expressions are immutable.
 xarray and xtensor
 ~~~~~~~~~~~~~~~~~~
 
-Although they represent different concepts, ``xarray`` and ``xtensor`` have really similar
-implementations so only ``xarray`` will be covered.
+Although they represent different concepts, :cpp:type:`xt::xarray` and :cpp:type:`xt::xtensor` have really similar
+implementations so only :cpp:type:`xt::xarray` will be covered.
 
-``xarray`` is a strided array expression that can be assigned to. Everything ``xarray`` needs
-is already defined in classes modeling :ref:`concepts-label`, so ``xarray`` only has to inherit
+:cpp:type:`xt::xarray` is a strided array expression that can be assigned to. Everything :cpp:type:`xt::xarray` needs
+is already defined in classes modeling :ref:`concepts-label`, so :cpp:type:`xt::xarray` only has to inherit
 from these classes and define constructors and assignment operators:
 
 .. image:: xarray_uml.svg
 
-Besides implementing the methods that define value semantic, ``xarray`` and ``xtensor`` hold
+Besides implementing the methods that define value semantic, :cpp:type:`xt::xarray` and :cpp:type:`xt::xtensor` hold
 the data container. Since the ``xcontainer`` base class implements all the logic for accessing
 the data, it must me able to access the data container. This is achieved by requiring that
 every class inheriting from ``xcontainer`` provides the following methods:
@@ -204,7 +201,7 @@ every class inheriting from ``xcontainer`` provides the following methods:
     const storage_type& storage_impl() const noexcept;
 
 These are the implementation methods of the ``storage()`` interface methods defined in ``xcontainer``,
-and thus are defined in the private section of ``xarray`` and ``xtensor``. In order to grant access
+and thus are defined in the private section of :cpp:type:`xt::xarray` and :cpp:type:`xt::xtensor`. In order to grant access
 to ``xcontainer``, this last one is declared as ``friend``:
 
 .. code::
@@ -236,8 +233,8 @@ Although the base classes use the types defined in the Requirement section, they
 define them; first because different base classes may need the same types and we want
 to avoid duplication of type definitions. The second reason is that most of the types
 may rely on other types specific to the implementation classes. For instance,
-``value_type``, ``reference``, etc,  of ``xarray`` are simply the types defined in the
-container type hold by ``xarray``:
+``value_type``, ``reference``, etc,  of :cpp:type:`xt::xarray` are simply the types defined in the
+container type hold by :cpp:type:`xt::xarray`:
 
 .. code::
 
diff --git a/docs/source/developer/iterating_expression.rst b/docs/source/developer/iterating_expression.rst
index afd81c1f1..706a50c0c 100644
--- a/docs/source/developer/iterating_expression.rst
+++ b/docs/source/developer/iterating_expression.rst
@@ -12,7 +12,7 @@ Iterating over expressions
 xiterable and inner types
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-`xtensor` provides two base classes for making expressions iterable: ``xconst_iterable`` and ``xiterable``. They define
+*xtensor* provides two base classes for making expressions iterable: ``xconst_iterable`` and ``xiterable``. They define
 the API for iterating as described in :ref:`concepts-label`. For an expression to be iterable, it must inherit directly
 or indirectly from one of these classes. For instance, the ``xbroadcast`` class is defined as following:
 
@@ -108,7 +108,7 @@ amount in a given dimension, dereferencing the stepper, and moving it to the beg
 .. code::
 
     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);
@@ -123,7 +123,7 @@ expression, etc...) in the expression, and can then be used to browse the expres
 
 .. image:: stepper_basic.svg
 
-In this diagram, the data is stored in row-major order, and we step in the second dimension (dimension index starts at 0).
+In this diagram, the data is stored in row-major order, and we step in the first dimension (dimension index starts at 0).
 The positions of the stepper are represented by the red dots.
 
 The ``to_end`` method takes a layout parameter, because the ending positions of a stepper depend on the layout used to iterate.
@@ -137,7 +137,7 @@ in row-major order. Thus, if we assume that ``p`` is a pointer to the last eleme
 of the stepper are ``p + 1`` in row-major, and ``p + 3`` in column-major order.
 
 A stepper is specific to an expression type, therefore implementing a new kind of expression usually requires to implement a new
-kind of stepper. However `xtensor` provides a generic ``xindexed_stepper`` class, that can be used with any kind of expressions.
+kind of stepper. However *xtensor* provides a generic ``xindexed_stepper`` class, that can be used with any kind of expressions.
 Even though it is generally not optimal, authors of new expression types can make use of the generic index stepper in a
 first implementation.
 
@@ -155,7 +155,7 @@ method would be:
         m_it += n * p_c->strides()[dim];
     }
 
-where ``m_it`` is an itrator on the underlying buffer, and ``p_c`` a pointer to the container_based expression.
+where ``m_it`` is an iterator on the underlying buffer, and ``p_c`` a pointer to the container-based expression.
 
 However, this implementation fails when broadcasting is involved. Consider the following expression:
 
@@ -187,7 +187,7 @@ avoid that, a broadcasting offset is added to the stepper:
     }
 
 This implementation takes into account that the broadcasting is done on the last dimension and dimensions are stored in ascending
-order; here dimension 1 of ``a`` correpsonds to dimension 0 of ``b``.
+order; here dimension 1 of ``a`` corresponds to dimension 0 of ``b``.
 
 This implementation ensures that a step in dimension 0 of the function updates the stepper of ``a`` while the stepper of ``b``
 remains unchanged; on the other hand, stepping in dimension 1 will update both steppers, as illustrated below:
@@ -200,11 +200,11 @@ with different dimension arguments.
 Iterators
 ~~~~~~~~~
 
-`xtensor` iterator is implemented in the ``xiterator`` class. This latter provides a STL compliant iterator interface, and is built
+*xtensor* iterator is implemented in the ``xiterator`` class. This latter provides a STL compliant iterator interface, and is built
 upon the steppers. Whereas the steppers are tied to the expression they refer to, ``xiterator`` is generic enough to work with any
 kind of stepper.
 
-An iterator holds a stepper an multi-dimensional index. A call to ``operator++`` increases the index and calls the ``step`` method
+An iterator holds a stepper and a multi-dimensional index. A call to ``operator++`` increases the index and calls the ``step`` method
 of the stepper accordingly. The way the index is increased depends on the layout used for iterating. For a row-major order iteration
 over a container with shape ``{3, 4}``, the index iterating sequence is:
 
@@ -224,7 +224,7 @@ over a container with shape ``{3, 4}``, the index iterating sequence is:
     {2, 3}
 
 When a member of an index reaches its maximum value, it is reset to 0 and the member in the next dimension is increased. This translates
-in the calls of two methods of the stepper, first ``reset`` and then ``step``. This is illustrated by the following picture:
+into the calls of two methods of the stepper, first ``reset`` and then ``step``. This is illustrated by the following picture:
 
 .. image:: stepper_iterating.svg
 
@@ -234,4 +234,3 @@ from ``{0, 3}`` to ``{1, 0}``: first the stepper is reset to ``{0, 0}``, then ``
 
 ``xiterator`` implements a random access iterator, providing ``operator--`` and ``operator[]`` methods. The implementation of these methods
 is similar to the one of ``operator++``.
-
diff --git a/docs/source/developer/iteration.svg b/docs/source/developer/iteration.svg
index efb1d2973..b0db64d8b 100644
--- a/docs/source/developer/iteration.svg
+++ b/docs/source/developer/iteration.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="408px" height="168px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7ZxLc5swEMc/jY/t8DY+5tG0l850Joe2RwUUTCsjF+Ta6aevAImHFmcYmwBWnEth9UD895eNdqEs7LvN4XOKtuuvNMRkYRnhYWHfLyzLNByL/5NbXkqLa7ilIUrjUHSqDY/xPyxHCusuDnHW6sgoJSzeto0BTRIcsJYNpSndt7s9U9K+6hZFGBgeA0Sg9XscsnVp9V2jtn/BcbSWVzYN0fKEgt9RSneJuN7Csp+Ln7J5g+Rcon+2RiHdN0z2p4V9l1LKyqPN4Q6TXFspWznu4Uhrte4UJ6zPAOGnv4jssFxxsS72IrXYr2OGH7coyM/33N8L+3bNNoSfmfwQZdvSA8/xAfNZbzOW0t/4jhKaFhPYRvHDW55jQhp2IQy304Q17A+rlekuuV2sDacMH47en1mpxmnEdINZ+sK7iAG+0Flw6IjTfe1UaVo3/CltSGAUVfPWUvIDoWa3srbmyprWZNI6QFp7em2r/kNo602mrQu0dfTS1jIm09YD2rp6aatEW388aZdAWk8vadVwO6K2PtB2qZm23mTaroC2vl7aquF2RG1lMtEQd6WXuEq8rWLEGOKaQFypty7qqiF3VHlhYiYV10Zeb0J5YXYmFddFXjXwjiovzNAgvPzWWFvQtn4JTbAinTAhEkcJPw24FJjbb3Oh4gCRG9GwicMwv8xtlweL6kzur3tj1Ojs9tPfGkJ/mMVBurXXX43fYzoApnrTR5chqz/2dNUfE+Z6mmk7XfXHhLmeZqU1Z7ryjwmTPc1qa44zmbgyHulbXFND7oiZtAWTPc3Ka2rMHVNcmOppVl9TY+6Y4sJET7MCmxpzxxQXpnmaFdjUmDtmEt3xKE63CpsadUeVF6ZoulXY1Lg7qrwwS9OtwqZG3lHlhYnaO6ywqeF5xApPx5M7iLf+DvAmc4ANEz6gP07Cm/xtwFxIgrIsDl7zBtfmyXcd9zXN1DDjBzjIJ41SFMa4NQYj78nzeBs+xOyH8EV+/DM//ujmZwm/6R9iMcVJ3VbeDA6VFxUzuksDZTvAUBph6S+7tw8bTnI7nCRtKSaIxX/by+jynLjCNxrzCx+rgld+kzOUNyQG1e4H85i2Em19ZaJSBTBRwVF11/3Qgunuu0PLgWi5MyNrORRZ6ib/DcmCuf57I8uDYK2uYJ0NVo/XjYcHS0JiAkhOQk6CZZwElgvB8q5gnQ0WrPHMPGJBGM8EawXBkjuvK1lnkAXrWzMnS9Ak2WqRVYP2U6ytB1lmxx9DWVS9onUGWj1ev5gzWuYraBn90LI6NvDyzYnZoqVWxk5Ga/V2aPV4++QNNlqvxJlTsDsCUCsOzS3ds4/8X745wwKrtBPCcmqM6gGLfG9otrBULxvPmRZYUr6ov1pDbIj8jkA09yzuAgKRXOKlojXEhqhjr23OvfJ0CWhdXrF88KjVUSGwrnvt89GyOtDyCBNctBjz/uyobPiQFR8UueEdTGd7qBv5UcSK56P7Rf4xjl+cEX45hlOuLE14M9rkz0+Tp2xbdiflsIfyeuVogLf2j3mXbtvlkqUGuZWtia5aKjjpYw9dle0hIAgo2W2SIxxc/V74T/1dlyA0Hd8Vs054wM9P68/elMGi/raQ/ek/&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="7" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="47" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="87" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(103.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">3</text></switch></g><rect x="127" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(143.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">4</text></switch></g><rect x="7" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(23.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">5</text></switch></g><rect x="47" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(63.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">6</text></switch></g><rect x="87" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(103.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">7</text></switch></g><rect x="127" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(143.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">8</text></switch></g><rect x="7" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(23.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">9</text></switch></g><rect x="47" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(59.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">10</text></switch></g><rect x="87" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(100.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="13" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">11</text></switch></g><rect x="127" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(139.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">12</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">12</text></switch></g><g transform="translate(23.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">1</text></switch></g><g transform="translate(63.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">2</text></switch></g><rect x="247" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="287" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="327" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(343.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">3</text></switch></g><rect x="367" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(383.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">4</text></switch></g><rect x="247" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(263.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">5</text></switch></g><rect x="287" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(303.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">6</text></switch></g><rect x="327" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(343.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">7</text></switch></g><rect x="367" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(383.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">8</text></switch></g><rect x="247" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(263.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">9</text></switch></g><rect x="287" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(299.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">10</text></switch></g><rect x="327" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(340.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="13" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">11</text></switch></g><rect x="367" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(379.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">12</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">12</text></switch></g><g transform="translate(263.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">1</text></switch></g><g transform="translate(303.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">2</text></switch></g><path d="M 7 107 L 160.63 107" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 165.88 107 L 158.88 110.5 L 160.63 107 L 158.88 103.5 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 7 27 L 160.63 27" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 165.88 27 L 158.88 30.5 L 160.63 27 L 158.88 23.5 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 7 67 L 160.63 67" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 165.88 67 L 158.88 70.5 L 160.63 67 L 158.88 63.5 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 167 27 L 13.18 65.46" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 8.08 66.73 L 14.03 61.64 L 13.18 65.46 L 15.72 68.43 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 167 67 L 13.18 105.46" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 8.08 106.73 L 14.03 101.64 L 13.18 105.46 L 15.72 108.43 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 267 7 L 267 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 267 125.88 L 263.5 118.88 L 267 120.63 L 270.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 267 127 L 304.99 13.04" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 306.65 8.06 L 307.75 15.81 L 304.99 13.04 L 301.11 13.59 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 307 7 L 307 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 307 125.88 L 303.5 118.88 L 307 120.63 L 310.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 307 127 L 344.99 13.04" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 346.65 8.06 L 347.75 15.81 L 344.99 13.04 L 341.11 13.59 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 347 7 L 347 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 347 125.88 L 343.5 118.88 L 347 120.63 L 350.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 347 127 L 384.99 13.04" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 386.65 8.06 L 387.75 15.81 L 384.99 13.04 L 381.11 13.59 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 387 7 L 387 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 387 125.88 L 383.5 118.88 L 387 120.63 L 390.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(27.5,144.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="118" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 120px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">row major iteration </font></div></div></foreignObject><text x="59" y="14" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><g transform="translate(252.5,144.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="138" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 139px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">column major iteration</font></div></div></foreignObject><text x="69" y="14" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="408px" height="168px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7ZxLc5swEMc/jY/t8DY+5tG0l850Joe2RwUUTCsjF+Ta6aevAImHFmcYmwBWnEth9UD895eNdqEs7LvN4XOKtuuvNMRkYRnhYWHfLyzLNByL/5NbXkqLa7ilIUrjUHSqDY/xPyxHCusuDnHW6sgoJSzeto0BTRIcsJYNpSndt7s9U9K+6hZFGBgeA0Sg9XscsnVp9V2jtn/BcbSWVzYN0fKEgt9RSneJuN7Csp+Ln7J5g+Rcon+2RiHdN0z2p4V9l1LKyqPN4Q6TXFspWznu4Uhrte4UJ6zPAOGnv4jssFxxsS72IrXYr2OGH7coyM/33N8L+3bNNoSfmfwQZdvSA8/xAfNZbzOW0t/4jhKaFhPYRvHDW55jQhp2IQy304Q17A+rlekuuV2sDacMH47en1mpxmnEdINZ+sK7iAG+0Flw6IjTfe1UaVo3/CltSGAUVfPWUvIDoWa3srbmyprWZNI6QFp7em2r/kNo602mrQu0dfTS1jIm09YD2rp6aatEW388aZdAWk8vadVwO6K2PtB2qZm23mTaroC2vl7aquF2RG1lMtEQd6WXuEq8rWLEGOKaQFypty7qqiF3VHlhYiYV10Zeb0J5YXYmFddFXjXwjiovzNAgvPzWWFvQtn4JTbAinTAhEkcJPw24FJjbb3Oh4gCRG9GwicMwv8xtlweL6kzur3tj1Ojs9tPfGkJ/mMVBurXXX43fYzoApnrTR5chqz/2dNUfE+Z6mmk7XfXHhLmeZqU1Z7ryjwmTPc1qa44zmbgyHulbXFND7oiZtAWTPc3Ka2rMHVNcmOppVl9TY+6Y4sJET7MCmxpzxxQXpnmaFdjUmDtmEt3xKE63CpsadUeVF6ZoulXY1Lg7qrwwS9OtwqZG3lHlhYnaO6ywqeF5xApPx5M7iLf+DvAmc4ANEz6gP07Cm/xtwFxIgrIsDl7zBtfmyXcd9zXN1DDjBzjIJ41SFMa4NQYj78nzeBs+xOyH8EV+/DM//ujmZwm/6R9iMcVJ3VbeDA6VFxUzuksDZTvAUBph6S+7tw8bTnI7nCRtKSaIxX/by+jynLjCNxrzCx+rgld+kzOUNyQG1e4H85i2Em19ZaJSBTBRwVF11/3Qgunuu0PLgWi5MyNrORRZ6ib/DcmCuf57I8uDYK2uYJ0NVo/XjYcHS0JiAkhOQk6CZZwElgvB8q5gnQ0WrPHMPGJBGM8EawXBkjuvK1lnkAXrWzMnS9Ak2WqRVYP2U6ytB1lmxx9DWVS9onUGWj1ev5gzWuYraBn90LI6NvDyzYnZoqVWxk5Ga/V2aPV4++QNNlqvxJlTsDsCUCsOzS3ds4/8X745wwKrtBPCcmqM6gGLfG9otrBULxvPmRZYUr6ov1pDbIj8jkA09yzuAgKRXOKlojXEhqhjr23OvfJ0CWhdXrF88KjVUSGwrnvt89GyOtDyCBNctBjz/uyobPiQFR8UueEdTGd7qBv5UcSK56P7Rf4xjl+cEX45hlOuLE14M9rkz0+Tp2xbdiflsIfyeuVogLf2j3mXbtvlkqUGuZWtia5aKjjpYw9dle0hIAgo2W2SIxxc/V74T/1dlyA0Hd8Vs054wM9P68/elMGi/raQ/ek/&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="7" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="47" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="87" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(103.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">3</text></switch></g><rect x="127" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(143.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">4</text></switch></g><rect x="7" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(23.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">5</text></switch></g><rect x="47" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(63.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">6</text></switch></g><rect x="87" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(103.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">7</text></switch></g><rect x="127" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(143.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">8</text></switch></g><rect x="7" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(23.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">9</text></switch></g><rect x="47" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(59.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">10</text></switch></g><rect x="87" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(100.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="13" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">11</text></switch></g><rect x="127" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(139.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">12</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">12</text></switch></g><g transform="translate(23.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">1</text></switch></g><g transform="translate(63.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">2</text></switch></g><rect x="247" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="287" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="327" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(343.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">3</text></switch></g><rect x="367" y="7" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(383.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">4</text></switch></g><rect x="247" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(263.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">5</text></switch></g><rect x="287" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(303.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">6</text></switch></g><rect x="327" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(343.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">7</text></switch></g><rect x="367" y="47" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(383.5,60.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">8</text></switch></g><rect x="247" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(263.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">9</text></switch></g><rect x="287" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(299.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">10</text></switch></g><rect x="327" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(340.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="13" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">11</text></switch></g><rect x="367" y="87" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(379.5,100.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="14" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 14px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">12</div></div></foreignObject><text x="7" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">12</text></switch></g><g transform="translate(263.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">1</text></switch></g><g transform="translate(303.5,20.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="7" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 7px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="4" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">2</text></switch></g><path d="M 7 107 L 160.63 107" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 165.88 107 L 158.88 110.5 L 160.63 107 L 158.88 103.5 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 7 27 L 160.63 27" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 165.88 27 L 158.88 30.5 L 160.63 27 L 158.88 23.5 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 7 67 L 160.63 67" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 165.88 67 L 158.88 70.5 L 160.63 67 L 158.88 63.5 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 167 27 L 13.18 65.46" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 8.08 66.73 L 14.03 61.64 L 13.18 65.46 L 15.72 68.43 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 167 67 L 13.18 105.46" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 8.08 106.73 L 14.03 101.64 L 13.18 105.46 L 15.72 108.43 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 267 7 L 267 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 267 125.88 L 263.5 118.88 L 267 120.63 L 270.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 267 127 L 304.99 13.04" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 306.65 8.06 L 307.75 15.81 L 304.99 13.04 L 301.11 13.59 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 307 7 L 307 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 307 125.88 L 303.5 118.88 L 307 120.63 L 310.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 307 127 L 344.99 13.04" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 346.65 8.06 L 347.75 15.81 L 344.99 13.04 L 341.11 13.59 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 347 7 L 347 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 347 125.88 L 343.5 118.88 L 347 120.63 L 350.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 347 127 L 384.99 13.04" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 386.65 8.06 L 387.75 15.81 L 384.99 13.04 L 381.11 13.59 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 387 7 L 387 120.63" fill="none" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><path d="M 387 125.88 L 383.5 118.88 L 387 120.63 L 390.5 118.88 Z" fill="#b85450" stroke="#b85450" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(27.5,144.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="118" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 120px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">row major iteration </font></div></div></foreignObject><text x="59" y="14" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><g transform="translate(252.5,144.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="138" height="15" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 139px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 14px">column major iteration</font></div></div></foreignObject><text x="69" y="14" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
diff --git a/docs/source/developer/stepper_basic.svg b/docs/source/developer/stepper_basic.svg
index a2eec3803..69860f25e 100644
--- a/docs/source/developer/stepper_basic.svg
+++ b/docs/source/developer/stepper_basic.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="481px" height="121px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VxRb5swEP41SNsbYEjSxyZtt5dJk/qwZxecxCrBCJwm3a+fCXYIPtqlUndIs3lJOLCB78N3+u5OBGS1O36rabX9IXJWBHGYHwNyF8RxFCax+mktr50lDdPOsKl5rk/qDY/8NzMjtXXPc9YMTpRCFJJXQ2MmypJlcmCjdS0Ow9PWohhetaIbBgyPGS2g9RfP5bazLtKwt39nfLM1V45CfeSJZs+bWuxLfb0gJuvT1h3eUTOXPr/Z0lwcLkzkPiCrWgjZ/dsdV6xosTWwdeMe3jh6vu+alfKaAZqnF1rsmbnj033JV4PFYcsle6xo1u4fFN8BWW7lrlB7kfpLm6pjYM2PTM26bGQtntlKFKI+TUDC06aOrHlRXNg1MMouSqnfgWim98fG63tltWTHN583OqOo3k4mdkzWr+oUPWChcdfvZaJ3Dz3JxrS94NfYqH6tNud5e2jVH43uONLEMaSjeDKoE9egnk0GdeoY1HE4GdQzx6C2XPUCD+m5Y0jbrhoR6oVrUM8mg/rGMahtV40ItZExzmBt+eqzQ8HAOnIMa9tbo4Ltml60/TUq2K5JRttjo4INRWMI0FaPJocAD/EsRcksKLWJFnxTqt1MQcGUfdkCxTNa3OoDO57n7WWWY4yeEkotf3fhpH49vY6P+DP4gMoy8nzYvh+TEKg/oTtyj5DZdIRAmUo8IXYMwSQEitnEE2KFkBtEPqDiTT0fdghBJMTMcUHIzBNihxBMQqB2nntC7BCCSQjU1wtPiJ1dIoiEQA1+4wkBKShMRqBQN+lWpymxE1WYlIxodS/WYToLkxLXqsXJdIV55+rFSTId1q4VjJPpOtacqxin07WsmdDgDNa2v0aszhPXKsa2v8bEGgra/xzr6drWiGv1YttfY2LtWo+x7a8xa/PEtS5j22Gjgu2ccpyweY24Jh1tl40KNtSOPnEIHDtiwZxAgenThsD5IxJi5vU9Pu8FCExCoFT1PT4giGASAvWs7/EBMQSxYp5A0eubfEAMwSQEKmPf5ANiCCYhUD37Jh8QQzAJgQrbN/nABBNitTyBMtx3+cAsFCYjUKv7Lp+RXBUmJSNq3ct1mNFCpMQIn/fSh6zMb9svIrXIFrRpePYePYN04YdAZDn4pNJfIbyAKB2ByNhqVlDJX4bTj+Gmr/BTcHXhvg/Lbo0LLegbsa8zpkf16IOJiL367IkkrTdMgolONJ4f+zpmr6hRqxG8at5aEB9KET88ELVZ63JgR+xkTIcoz+F6ikZelugz1hNU966gnsytd3skqfLPYIcavpGs+qKmVmPD+GsQz+iuhbd8aqrz87ocdWyfNrZI4s+JOmq3/x5d58r6j/6R+z8=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(15.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(55.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(95.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(135.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(15.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(55.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(95.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(135.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(15.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(55.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(90.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(131.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><rect x="320" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(335.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(375.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(415.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(455.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(335.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(375.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(415.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(455.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(335.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(375.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(410.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(451.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><path d="M 180 60 L 293.63 60" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 298.88 60 L 291.88 63.5 L 293.63 60 L 291.88 56.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><ellipse cx="75" cy="35" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><ellipse cx="395" cy="115" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><g transform="translate(203.5,31.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="72" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 73px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(0, 2) </div></div></foreignObject><text x="36" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">step(0, 2)&amp;nbsp;</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="481px" height="121px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VxRb5swEP41SNsbYEjSxyZtt5dJk/qwZxecxCrBCJwm3a+fCXYIPtqlUndIs3lJOLCB78N3+u5OBGS1O36rabX9IXJWBHGYHwNyF8RxFCax+mktr50lDdPOsKl5rk/qDY/8NzMjtXXPc9YMTpRCFJJXQ2MmypJlcmCjdS0Ow9PWohhetaIbBgyPGS2g9RfP5bazLtKwt39nfLM1V45CfeSJZs+bWuxLfb0gJuvT1h3eUTOXPr/Z0lwcLkzkPiCrWgjZ/dsdV6xosTWwdeMe3jh6vu+alfKaAZqnF1rsmbnj033JV4PFYcsle6xo1u4fFN8BWW7lrlB7kfpLm6pjYM2PTM26bGQtntlKFKI+TUDC06aOrHlRXNg1MMouSqnfgWim98fG63tltWTHN583OqOo3k4mdkzWr+oUPWChcdfvZaJ3Dz3JxrS94NfYqH6tNud5e2jVH43uONLEMaSjeDKoE9egnk0GdeoY1HE4GdQzx6C2XPUCD+m5Y0jbrhoR6oVrUM8mg/rGMahtV40ItZExzmBt+eqzQ8HAOnIMa9tbo4Ltml60/TUq2K5JRttjo4INRWMI0FaPJocAD/EsRcksKLWJFnxTqt1MQcGUfdkCxTNa3OoDO57n7WWWY4yeEkotf3fhpH49vY6P+DP4gMoy8nzYvh+TEKg/oTtyj5DZdIRAmUo8IXYMwSQEitnEE2KFkBtEPqDiTT0fdghBJMTMcUHIzBNihxBMQqB2nntC7BCCSQjU1wtPiJ1dIoiEQA1+4wkBKShMRqBQN+lWpymxE1WYlIxodS/WYToLkxLXqsXJdIV55+rFSTId1q4VjJPpOtacqxin07WsmdDgDNa2v0aszhPXKsa2v8bEGgra/xzr6drWiGv1YttfY2LtWo+x7a8xa/PEtS5j22Gjgu2ccpyweY24Jh1tl40KNtSOPnEIHDtiwZxAgenThsD5IxJi5vU9Pu8FCExCoFT1PT4giGASAvWs7/EBMQSxYp5A0eubfEAMwSQEKmPf5ANiCCYhUD37Jh8QQzAJgQrbN/nABBNitTyBMtx3+cAsFCYjUKv7Lp+RXBUmJSNq3ct1mNFCpMQIn/fSh6zMb9svIrXIFrRpePYePYN04YdAZDn4pNJfIbyAKB2ByNhqVlDJX4bTj+Gmr/BTcHXhvg/Lbo0LLegbsa8zpkf16IOJiL367IkkrTdMgolONJ4f+zpmr6hRqxG8at5aEB9KET88ELVZ63JgR+xkTIcoz+F6ikZelugz1hNU966gnsytd3skqfLPYIcavpGs+qKmVmPD+GsQz+iuhbd8aqrz87ocdWyfNrZI4s+JOmq3/x5d58r6j/6R+z8=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(15.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(55.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(95.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(135.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(15.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(55.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(95.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(135.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(15.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(55.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(90.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(131.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><rect x="320" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(335.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(375.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(415.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(455.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(335.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(375.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(415.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(455.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(335.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(375.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(410.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(451.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><path d="M 180 60 L 293.63 60" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 298.88 60 L 291.88 63.5 L 293.63 60 L 291.88 56.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><ellipse cx="75" cy="35" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><ellipse cx="395" cy="115" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><g transform="translate(203.5,31.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="72" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 73px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(0, 2) </div></div></foreignObject><text x="36" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">step(0, 2)&amp;nbsp;</text></switch></g></g></svg>
diff --git a/docs/source/developer/stepper_broadcasting.svg b/docs/source/developer/stepper_broadcasting.svg
index f32982f50..5da35695e 100644
--- a/docs/source/developer/stepper_broadcasting.svg
+++ b/docs/source/developer/stepper_broadcasting.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="551px" height="281px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VzLkps4FP0aV80sMsXTj2W7O51sUpWqXszMkgG1TQVbBOS2na8fARIYXRmrJ1gwEWwMV0KIcy73hfDMfdydPmVBuv2CI5TMHCs6zdynmePYlufQn0JyriS+5VeCTRZHrFMjeIl/IH4mkx7iCOWtjgTjhMRpWxji/R6FpCULsgwf291ecdK+ahpsEBC8hEECpX/GEdlW0qVvNfLPKN5s+ZVti7X8E4TfNhk+7Nn1Zo77Wm5V8y7gY7H++TaI8PFC5H6cuY8ZxqTa250eUVJgy2Grznu+0lrPO0N7onIC4+ktSA6Iz7icFzlzLI7bmKCXNAiL4yPle+aut2SX0COb7gZ5WjHwGp8QHXWdkwx/Q484wVk5gGuVG215jZPkQs6AoXK8J0wH7Dk7lp3P5ooygk5X79euUaTaifAOkexMu5xqpqpTmGI6nLhjQ7PHRNsLhrksYIq1qUduwKU7DF851q5pWPvDYe2ZhvVqOKx9w7Cmow2G9dwwrIG99vRhvTANa9Fea8R6aRrWor3WiPXKMKyBvdaINTdfxoANDPZSI9i2aWCLFlsn2MaljqLJ1gm2abkjsNk6wYbJowXQprdG2gC38dzjPRKgZKIgiTd7ehhSKBCVrwug4jBIHljDLo6i4jJrGaNlbang78ka2LDbaow4fTACU0x7YgRYf52MwEQUWiTzGBFdhE5GYLrqTowAP6KTEZjUehMjwI/4GhmBqa8/MQL8iEZG+BgXjMwnRoAf0ckITKIXEyPAj+hkBGbay4kR4EdWGhmB6fhqYgT4EZ2MwJyd64fRlIiORCclkqR9ytqhJ9FJiWmvj90Bl0UY9/7YG3BdhHEvkL3FgGCb9gbZH3LVIMyQp8AGGnaNdT0XZshTXAOtv05GYIYMLZJ5jIguQicjMEOe3kZAP6KTEYUl0fSMOM2vwdblvqMg35aIQhY7fPlzud3m4PnZpVtPnkPgQLIYbCmhYNkHBbKV0vOEsBtucTH/fsC84UNeQvNAO7hOemoa6d6m+l3zgegcqrF4yyifuZa66AwbBCc11xjHKeTeaB89FF8vFSgnQZ7HYRdVrQdLEUN0islfjIRi/282MsUvOxcN9h8WVVMmKFotKuDHX1EW0xsv2H9qGEGR8DFVjg9ZyK0+MzskyDaIwekr03bBiy/hhcsylAQkfmvPQkYWu8JXHJeP25VSch1c8iGqG2JnNZTDgVZOayB7tWwPVKEABip1p75tNXVSqC7oUyf7mjpZojp9oBLP71mheF1rPBpl9aRRnpDn2Nb9NEqhhHKvAKF28CBA4PJxfSJoS1TH7sNJKFRWTOBApW57Lw64sx+Cg9XiyVosIAeNfFyfFN6NA4WV/CZwoFLlvRsHsKiijYNiqxLDNgeNfFxftNyNA4V1/yZwAPyBq5EDWDjJCUp/ozOm51rO74CR/1+OXdu2PmyW8LxIVkqtJFT1UePybhZYwvqemxpKqdHFP3SIZZWSZquh+VetsPTLvt9iX2IsZeW1XthXqLCEh+ythuXd+bFqCCAACvLZ8eSpfEW0GF+8v/LhCwP57YGu5KkU/+B80S0tOuQdExYKeDYLkFTnJfSnO9UM/mvS7MEyzOQcOoMpgQ+d3kGhwPFz9kE1NKoRvVmOtdqlWF+xRsbu9LJGxsP5Edmevqquc2EgsVzfk+1ZCjGo+NdaN7ove7Y8slLRFOtoMWYdfyRxr+CGP3QjCm6uGKlLs1YaLG7YVAv8K4nxGlvg5FliHCLEO8oFfmHRvO3cJ3ASs7JbgZM37+z/0+bLhxW+KXDqrIAMFzj5CpVA3YFTR4AkC6rUQyeZ9XFHZn1coSxcL2t4t/Vx5EFK39ZHnDBPD6/NC/T3erY+srrqFDxpNWiuL6X4DsEUPWz+UbfSluZvi92P/wI=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="110" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="150" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="190" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="230" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="110" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="150" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="190" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="230" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="110" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="150" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="190" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="230" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(125.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(165.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(205.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(245.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(125.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(165.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(205.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(245.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(125.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(165.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(200.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(241.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><rect x="390" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="430" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="470" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="510" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(405.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(445.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(485.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(525.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><ellipse cx="350" cy="40" rx="40" ry="40" fill="#ffffff" stroke="#000000" stroke-dasharray="3 3" pointer-events="none"/><g transform="translate(340.5,21.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 20px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 32px">+</font></div></div></foreignObject><text x="9" y="26" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><path d="M 322 68 L 274.06 155.42" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 271.54 160.02 L 271.83 152.2 L 274.06 155.42 L 277.97 155.56 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 378 68 L 390.09 151.7" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 390.84 156.89 L 386.38 150.47 L 390.09 151.7 L 393.3 149.47 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><ellipse cx="115" cy="165" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="395" cy="165" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="195" cy="165" rx="5" ry="5" fill="#97d077" stroke="#97d077" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="475" cy="165" rx="5" ry="5" fill="#97d077" stroke="#97d077" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="115" cy="245" rx="5" ry="5" fill="#3333ff" stroke="#3333ff" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="395" cy="195" rx="5" ry="5" fill="#3333ff" stroke="#3333ff" stroke-dasharray="3 3" pointer-events="none"/><g transform="translate(421.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="67" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 69px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 2)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 2)</text></switch></g><g transform="translate(420.5,41.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#3333ff">step(0, 2)</font></div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><path d="M 119 160 Q 130 130 162.5 130 Q 195 130 195 158.63" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 195 163.88 L 191.5 156.88 L 195 158.63 L 198.5 156.88 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(126.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="67" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 69px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 2)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 2)</text></switch></g><path d="M 111 169 Q 80 180 80 210 Q 80 240 103.72 243.95" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 108.9 244.82 L 101.42 247.12 L 103.72 243.95 L 102.57 240.21 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(5.5,201.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#3333ff">step(0, 2)</font></div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><path d="M 395 160 Q 410 130 435 130 Q 460 130 468.87 155" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 470.63 159.95 L 464.99 154.52 L 468.87 155 L 471.58 152.18 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(406.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="67" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 69px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 2)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 2)</text></switch></g><path d="M 390 165 Q 370 165 370 182.5 Q 370 200 383.82 196.54" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 388.92 195.27 L 382.97 200.36 L 383.82 196.54 L 381.28 193.57 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(340.5,201.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#3333ff">step(0, 2)</font></div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="551px" height="281px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VzLkps4FP0aV80sMsXTj2W7O51sUpWqXszMkgG1TQVbBOS2na8fARIYXRmrJ1gwEWwMV0KIcy73hfDMfdydPmVBuv2CI5TMHCs6zdynmePYlufQn0JyriS+5VeCTRZHrFMjeIl/IH4mkx7iCOWtjgTjhMRpWxji/R6FpCULsgwf291ecdK+ahpsEBC8hEECpX/GEdlW0qVvNfLPKN5s+ZVti7X8E4TfNhk+7Nn1Zo77Wm5V8y7gY7H++TaI8PFC5H6cuY8ZxqTa250eUVJgy2Grznu+0lrPO0N7onIC4+ktSA6Iz7icFzlzLI7bmKCXNAiL4yPle+aut2SX0COb7gZ5WjHwGp8QHXWdkwx/Q484wVk5gGuVG215jZPkQs6AoXK8J0wH7Dk7lp3P5ooygk5X79euUaTaifAOkexMu5xqpqpTmGI6nLhjQ7PHRNsLhrksYIq1qUduwKU7DF851q5pWPvDYe2ZhvVqOKx9w7Cmow2G9dwwrIG99vRhvTANa9Fea8R6aRrWor3WiPXKMKyBvdaINTdfxoANDPZSI9i2aWCLFlsn2MaljqLJ1gm2abkjsNk6wYbJowXQprdG2gC38dzjPRKgZKIgiTd7ehhSKBCVrwug4jBIHljDLo6i4jJrGaNlbang78ka2LDbaow4fTACU0x7YgRYf52MwEQUWiTzGBFdhE5GYLrqTowAP6KTEZjUehMjwI/4GhmBqa8/MQL8iEZG+BgXjMwnRoAf0ckITKIXEyPAj+hkBGbay4kR4EdWGhmB6fhqYgT4EZ2MwJyd64fRlIiORCclkqR9ytqhJ9FJiWmvj90Bl0UY9/7YG3BdhHEvkL3FgGCb9gbZH3LVIMyQp8AGGnaNdT0XZshTXAOtv05GYIYMLZJ5jIguQicjMEOe3kZAP6KTEYUl0fSMOM2vwdblvqMg35aIQhY7fPlzud3m4PnZpVtPnkPgQLIYbCmhYNkHBbKV0vOEsBtucTH/fsC84UNeQvNAO7hOemoa6d6m+l3zgegcqrF4yyifuZa66AwbBCc11xjHKeTeaB89FF8vFSgnQZ7HYRdVrQdLEUN0islfjIRi/282MsUvOxcN9h8WVVMmKFotKuDHX1EW0xsv2H9qGEGR8DFVjg9ZyK0+MzskyDaIwekr03bBiy/hhcsylAQkfmvPQkYWu8JXHJeP25VSch1c8iGqG2JnNZTDgVZOayB7tWwPVKEABip1p75tNXVSqC7oUyf7mjpZojp9oBLP71mheF1rPBpl9aRRnpDn2Nb9NEqhhHKvAKF28CBA4PJxfSJoS1TH7sNJKFRWTOBApW57Lw64sx+Cg9XiyVosIAeNfFyfFN6NA4WV/CZwoFLlvRsHsKiijYNiqxLDNgeNfFxftNyNA4V1/yZwAPyBq5EDWDjJCUp/ozOm51rO74CR/1+OXdu2PmyW8LxIVkqtJFT1UePybhZYwvqemxpKqdHFP3SIZZWSZquh+VetsPTLvt9iX2IsZeW1XthXqLCEh+ythuXd+bFqCCAACvLZ8eSpfEW0GF+8v/LhCwP57YGu5KkU/+B80S0tOuQdExYKeDYLkFTnJfSnO9UM/mvS7MEyzOQcOoMpgQ+d3kGhwPFz9kE1NKoRvVmOtdqlWF+xRsbu9LJGxsP5Edmevqquc2EgsVzfk+1ZCjGo+NdaN7ove7Y8slLRFOtoMWYdfyRxr+CGP3QjCm6uGKlLs1YaLG7YVAv8K4nxGlvg5FliHCLEO8oFfmHRvO3cJ3ASs7JbgZM37+z/0+bLhxW+KXDqrIAMFzj5CpVA3YFTR4AkC6rUQyeZ9XFHZn1coSxcL2t4t/Vx5EFK39ZHnDBPD6/NC/T3erY+srrqFDxpNWiuL6X4DsEUPWz+UbfSluZvi92P/wI=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="110" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="150" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="190" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="230" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="110" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="150" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="190" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="230" y="200" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="110" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="150" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="190" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="230" y="240" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(125.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(165.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(205.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(245.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(125.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(165.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(205.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(245.5,211.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(125.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(165.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(200.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(241.5,251.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><rect x="390" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="430" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="470" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="510" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(405.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(445.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(485.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(525.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><ellipse cx="350" cy="40" rx="40" ry="40" fill="#ffffff" stroke="#000000" stroke-dasharray="3 3" pointer-events="none"/><g transform="translate(340.5,21.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 20px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 32px">+</font></div></div></foreignObject><text x="9" y="26" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><path d="M 322 68 L 274.06 155.42" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 271.54 160.02 L 271.83 152.2 L 274.06 155.42 L 277.97 155.56 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 378 68 L 390.09 151.7" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 390.84 156.89 L 386.38 150.47 L 390.09 151.7 L 393.3 149.47 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><ellipse cx="115" cy="165" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="395" cy="165" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="195" cy="165" rx="5" ry="5" fill="#97d077" stroke="#97d077" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="475" cy="165" rx="5" ry="5" fill="#97d077" stroke="#97d077" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="115" cy="245" rx="5" ry="5" fill="#3333ff" stroke="#3333ff" stroke-dasharray="3 3" pointer-events="none"/><ellipse cx="395" cy="195" rx="5" ry="5" fill="#3333ff" stroke="#3333ff" stroke-dasharray="3 3" pointer-events="none"/><g transform="translate(421.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="67" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 69px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 2)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 2)</text></switch></g><g transform="translate(420.5,41.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#3333ff">step(0, 2)</font></div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><path d="M 119 160 Q 130 130 162.5 130 Q 195 130 195 158.63" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 195 163.88 L 191.5 156.88 L 195 158.63 L 198.5 156.88 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(126.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="67" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 69px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 2)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 2)</text></switch></g><path d="M 111 169 Q 80 180 80 210 Q 80 240 103.72 243.95" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 108.9 244.82 L 101.42 247.12 L 103.72 243.95 L 102.57 240.21 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(5.5,201.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#3333ff">step(0, 2)</font></div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><path d="M 395 160 Q 410 130 435 130 Q 460 130 468.87 155" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 470.63 159.95 L 464.99 154.52 L 468.87 155 L 471.58 152.18 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(406.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="67" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 69px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 2)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 2)</text></switch></g><path d="M 390 165 Q 370 165 370 182.5 Q 370 200 383.82 196.54" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 388.92 195.27 L 382.97 200.36 L 383.82 196.54 L 381.28 193.57 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(340.5,201.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#3333ff">step(0, 2)</font></div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
diff --git a/docs/source/developer/stepper_iterating.svg b/docs/source/developer/stepper_iterating.svg
index 92a7d8d4c..027d6739f 100644
--- a/docs/source/developer/stepper_iterating.svg
+++ b/docs/source/developer/stepper_iterating.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="381px" height="213px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VxNk6M2EP01rtpcUoAM2Mf1fCSHTVWq5pDNUQsaTAYjL8hjO79+JZD4UGObWTPy1oAPY6slJPHeU6NuYGbobnP4I8Pb9V80JMnMscLDDN3PHMe25g7/EpZjaXEttzREWRzKRrXhKf6fqCOldReHJG81ZJQmLN62jQFNUxKwlg1nGd23mz3TpD3qFkcEGJ4CnEDrP3HI1qV14Vq1/U8SR2s1sm3Jmm84eIkyukvleDMHPRefsnqDVV+yfb7GId03TOhhhu4ySln5a3O4I4nAVsFWHvd4oraad0ZS1ucAydMrTnZEzbiYFzsqLPbrmJGnLQ5Eec/5nqHVmm0SXrL5T5xvSwae4wPhva5yltEXckcTmhUdIKv48JrnOEkadgkMt9OUSQ3Ynix3HS/nSjJGDifP165Q5OokdENYduRN1AFzCfxRK+9rmpVp3WBY2bAUVlT1XIPLf0h8u7FGY8N6cTus5yPDunIoN8DaHRvW3u2w9kaGNfDXC3NY+2PDWvfXBrFejAxr4K8NYr0cG9a6vzaItQpoRgO27rAroZsA2x4b2Isbgj220FF32UbBHlvsqPtso2DD4NECaPNTY22A23imNCUalNKEkzhKeTHgUBBuXwmg4gAnn2XFJg5DMcyqi9EityT4u7duvBN3+zHiDMEIDDHtiRGwXzfJCAxEoUcaHSNgV2+SERiuookRsPc3yQgMaucTI+A6sjTICAx93YkRcB0xyIjqo8GINzECriMmGYFBtD8xAq4jJhmBkfZiYgQkmpBBRmA4vpwYAdkok4zAmF2lXsdMCchZmaSkI2ifonaY2TJJSY/bx8Euey1wEVyQNPwsHqcSMCc4z+PgHFccqaV/b/n+ZUSrduQQs6+Chd9dWfpXcsLxzI5lleOqsqosp01C7TGunO6yoJ2PYDiLiMQQ9SarQYbbQYayZSTBLH5tT6KLITnC3zTmA5+8hiGkkVyejzyq5hl2tNREtdA6KlEAHXFy8bHRbCsa5GcmrG+D9MfL9PZ6aNFuz3+UM6jVW3HQT9A97tF/GEEjKOj5JOjrBO1YbxM0iMyGFnSPByFMC/qcbE+rvYeg51DQ7iToKwWtp9cuCfq8R79e0D2eNrlO0OLz+PhTHtof2kW7UNHOpOgrFa2Ns7iw5fDONb9azwqtX1HPTTE39FvVVWIunHUPOdsdHlrd1ZgE/dObaH0P4V1Q9Ils8GCShlG5UMWTLNKMrWlEU5w81FYtfm7o+YR3tdve1W95V22dfEto8FKaHmMxbSlf9aKQLYr/EcaO0oB3jHJTPdMvlG5Pra/6MZee66vPQrE6ForVe6H0XgG9XzVxgJfKGdl+4l3zYy37N8D4r5GHCXG+rjzn2/gZ9haYCgsaLmzR4cKGSMogmEzOSE7Ypw/BUnU1G4AlPVjzIEnvlTlD8M79ID7yjIu8nYd88w6kh4dEHdkL1D8fN7yHhNnpwkNaH8hDDrn2XM1B+nDt+e+19jqy1v5KEoVm/r2QFeV/uFVe4KzCOhHYIBDpt4I6LnG2/V4UduVpvYTJU56JN7nVWXvfd+Lt51XhYELhYBomLyq+K/qtNv0tUZT986mVQ8hDJ1W0VeFeXNfVZuhKVfBi/WJ7GafU/z0APfwA&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="90" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="130" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="170" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="210" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="90" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="130" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="170" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="210" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="90" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="130" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="170" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="210" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(145.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(185.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(225.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(105.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(145.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(185.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(225.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(105.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(145.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(180.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(221.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><path d="M 110 80 Q 110 60 120 60 Q 130 60 137.15 74.3" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 139.5 79 L 133.24 74.3 L 137.15 74.3 L 139.5 71.17 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 150 80 Q 150 60 160 60 Q 170 60 177.15 74.3" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 179.5 79 L 173.24 74.3 L 177.15 74.3 L 179.5 71.17 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 190 80 Q 190 60 200 60 Q 210 60 217.15 74.3" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 219.5 79 L 213.24 74.3 L 217.15 74.3 L 219.5 71.17 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 240 80 Q 240 20 175 20 Q 110 20 101.05 73.72" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 100.18 78.9 L 97.88 71.42 L 101.05 73.72 L 104.79 72.57 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 90 95 Q 70 100 70 115 Q 70 130 84.3 137.15" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 89 139.5 L 81.17 139.5 L 84.3 137.15 L 84.3 133.24 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 200 L 120 200" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 200 L 120 200 L 120 200 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(135.5,41.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 1)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 1)</text></switch></g><g transform="translate(142.5,1.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="54" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 56px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">reset(1)</div></div></foreignObject><text x="27" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">reset(1)</text></switch></g><path d="M 170 20 L 170 20" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 170 20 L 170 20 L 170 20 Z" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(0.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(0, 1)</div></div></foreignObject><text x="34" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">step(0, 1)</text></switch></g><g transform="translate(276.5,141.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="97" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 98px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">{0, 3} to {1, 0}</div></div></foreignObject><text x="49" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">{0, 3} to {1, 0}</text></switch></g><g transform="translate(276.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="97" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 98px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#97d077">{0, 0} to {0, 3}</font></div></div></foreignObject><text x="49" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="381px" height="213px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VxNk6M2EP01rtpcUoAM2Mf1fCSHTVWq5pDNUQsaTAYjL8hjO79+JZD4UGObWTPy1oAPY6slJPHeU6NuYGbobnP4I8Pb9V80JMnMscLDDN3PHMe25g7/EpZjaXEttzREWRzKRrXhKf6fqCOldReHJG81ZJQmLN62jQFNUxKwlg1nGd23mz3TpD3qFkcEGJ4CnEDrP3HI1qV14Vq1/U8SR2s1sm3Jmm84eIkyukvleDMHPRefsnqDVV+yfb7GId03TOhhhu4ySln5a3O4I4nAVsFWHvd4oraad0ZS1ucAydMrTnZEzbiYFzsqLPbrmJGnLQ5Eec/5nqHVmm0SXrL5T5xvSwae4wPhva5yltEXckcTmhUdIKv48JrnOEkadgkMt9OUSQ3Ynix3HS/nSjJGDifP165Q5OokdENYduRN1AFzCfxRK+9rmpVp3WBY2bAUVlT1XIPLf0h8u7FGY8N6cTus5yPDunIoN8DaHRvW3u2w9kaGNfDXC3NY+2PDWvfXBrFejAxr4K8NYr0cG9a6vzaItQpoRgO27rAroZsA2x4b2Isbgj220FF32UbBHlvsqPtso2DD4NECaPNTY22A23imNCUalNKEkzhKeTHgUBBuXwmg4gAnn2XFJg5DMcyqi9EityT4u7duvBN3+zHiDMEIDDHtiRGwXzfJCAxEoUcaHSNgV2+SERiuookRsPc3yQgMaucTI+A6sjTICAx93YkRcB0xyIjqo8GINzECriMmGYFBtD8xAq4jJhmBkfZiYgQkmpBBRmA4vpwYAdkok4zAmF2lXsdMCchZmaSkI2ifonaY2TJJSY/bx8Euey1wEVyQNPwsHqcSMCc4z+PgHFccqaV/b/n+ZUSrduQQs6+Chd9dWfpXcsLxzI5lleOqsqosp01C7TGunO6yoJ2PYDiLiMQQ9SarQYbbQYayZSTBLH5tT6KLITnC3zTmA5+8hiGkkVyejzyq5hl2tNREtdA6KlEAHXFy8bHRbCsa5GcmrG+D9MfL9PZ6aNFuz3+UM6jVW3HQT9A97tF/GEEjKOj5JOjrBO1YbxM0iMyGFnSPByFMC/qcbE+rvYeg51DQ7iToKwWtp9cuCfq8R79e0D2eNrlO0OLz+PhTHtof2kW7UNHOpOgrFa2Ns7iw5fDONb9azwqtX1HPTTE39FvVVWIunHUPOdsdHlrd1ZgE/dObaH0P4V1Q9Ils8GCShlG5UMWTLNKMrWlEU5w81FYtfm7o+YR3tdve1W95V22dfEto8FKaHmMxbSlf9aKQLYr/EcaO0oB3jHJTPdMvlG5Pra/6MZee66vPQrE6ForVe6H0XgG9XzVxgJfKGdl+4l3zYy37N8D4r5GHCXG+rjzn2/gZ9haYCgsaLmzR4cKGSMogmEzOSE7Ypw/BUnU1G4AlPVjzIEnvlTlD8M79ID7yjIu8nYd88w6kh4dEHdkL1D8fN7yHhNnpwkNaH8hDDrn2XM1B+nDt+e+19jqy1v5KEoVm/r2QFeV/uFVe4KzCOhHYIBDpt4I6LnG2/V4UduVpvYTJU56JN7nVWXvfd+Lt51XhYELhYBomLyq+K/qtNv0tUZT986mVQ8hDJ1W0VeFeXNfVZuhKVfBi/WJ7GafU/z0APfwA&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="90" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="130" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="170" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="210" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="90" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="130" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="170" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="210" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="90" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="130" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="170" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="210" y="160" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(145.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(185.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(225.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(105.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(145.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(185.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(225.5,131.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(105.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(145.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(180.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(221.5,171.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><path d="M 110 80 Q 110 60 120 60 Q 130 60 137.15 74.3" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 139.5 79 L 133.24 74.3 L 137.15 74.3 L 139.5 71.17 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 150 80 Q 150 60 160 60 Q 170 60 177.15 74.3" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 179.5 79 L 173.24 74.3 L 177.15 74.3 L 179.5 71.17 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 190 80 Q 190 60 200 60 Q 210 60 217.15 74.3" fill="none" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 219.5 79 L 213.24 74.3 L 217.15 74.3 L 219.5 71.17 Z" fill="#97d077" stroke="#97d077" stroke-miterlimit="10" pointer-events="none"/><path d="M 240 80 Q 240 20 175 20 Q 110 20 101.05 73.72" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 100.18 78.9 L 97.88 71.42 L 101.05 73.72 L 104.79 72.57 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 90 95 Q 70 100 70 115 Q 70 130 84.3 137.15" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 89 139.5 L 81.17 139.5 L 84.3 137.15 L 84.3 133.24 Z" fill="#3333ff" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 200 L 120 200" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 200 L 120 200 L 120 200 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(135.5,41.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(1, 1)</div></div></foreignObject><text x="34" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step(1, 1)</text></switch></g><g transform="translate(142.5,1.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="54" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 56px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">reset(1)</div></div></foreignObject><text x="27" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">reset(1)</text></switch></g><path d="M 170 20 L 170 20" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><path d="M 170 20 L 170 20 L 170 20 Z" fill="none" stroke="#3333ff" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(0.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="68" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 68px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step(0, 1)</div></div></foreignObject><text x="34" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">step(0, 1)</text></switch></g><g transform="translate(276.5,141.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="97" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 98px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">{0, 3} to {1, 0}</div></div></foreignObject><text x="49" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">{0, 3} to {1, 0}</text></switch></g><g transform="translate(276.5,111.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="97" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(51, 51, 255); line-height: 1.2; vertical-align: top; width: 98px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font color="#97d077">{0, 0} to {0, 3}</font></div></div></foreignObject><text x="49" y="17" fill="#3333FF" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
diff --git a/docs/source/developer/stepper_to_end.svg b/docs/source/developer/stepper_to_end.svg
index ce24546a2..588899cf9 100644
--- a/docs/source/developer/stepper_to_end.svg
+++ b/docs/source/developer/stepper_to_end.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="481px" height="161px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7ZxNc5swEIZ/jWfaG1jgj2PjJO2lM53JoceOCrJhgpEH5Njpr68ACYyWJM6MsySRfIlZQODnhRWvVmFCVtvj94Lukp88Ztlk6sXHCbmeTKe+F0zlnyry2ERCL2wCmyKN1UZd4C79x/SeKrpPY1b2NhScZyLd9YMRz3MWiV6MFgU/9Ddb86x/1B3dMBC4i2gGo7/TWCRNdBF6XfwHSzeJPrLvqTV/aXS/Kfg+V8ebTMm6/jSrt1S3pbYvExrzw0mI3EzIquBcNN+2xxXLKrYaW7Pf7RNr2/MuWC7O2UHp9ECzPdNnXJ+XeNQsDkkq2N2ORtXyQeo9IVeJ2GZyyZdfablrFFinRyZbvSpFwe/Zime8qBsgXv2Ra9Zplp3Eb+tPFee5UNeAP1PLve2I/Mh4TMukOkR9XHXirBDs+OSP91uk8lJlfMtE8Sg3UTtMA6WCukp9rcqh01xvkpzIrWNUXWWbtuWOtPyiYA+DJ1aD9wzwMzzwwYjgVSp4EXy7/wVYL/qoAzzSoWWk2/SBj3pmG+rZaKjnlqE2czUi6oVlqI1UvcAjvbSMtJmqEVFri2MP69l4rH3LWJvJGpP1mFbyHWRrTPPoj+ke30O+RoVtm2M0EzYqbNtMIxgKwYQNbaMHaMufJvqA+zxznjMDpQrRLN3kcjGSKJiMX1Wg0ohm39SKbRrH1WGuhhStB1HrQSdv1LwenqfH9BJ6QG/pOz3M3I8pCHSgMB3ZJ8hsPEGgUSVOELMPQRREt3EiSOAEMbqQJaIe0PGGTg+zC8EUBNrimRPE7EIwBYHeee4EMbsQTEGgv144QczRJYIoCPTgSycIGILCVAQadV1GsFoSc6AKU5IBr+7MOhzOwpTEtnpxMF5p3rqKcRCMxlrfQvawHm/OGrGtYhyON2mNQGv8uVmb+RqxOk9sqxib+RqTtW0FYzNfY7K2rV5s5mtM1rbNMjbzNer/h9g2z9hM2KiwrXOOI05eI7ZZRzNlY8LWbbgpPs8ldsSCeQANphs2BMkfUxDoQmE+sk+Q8WbBBdCqujk+oBPBFAT6WTfHB/QhiBXzAJpeN8kH9CGYgkBn7Cb5gD4EUxDont0kH9CHYAoCHbab5AMHmBCr5QG04W6WDxyFQlREP9K5WT7Pj1VhSjLg1p1dhyNamJJAvw4EkXuku/IpbK8aSGzfgQTeoaTjiJOriIF9oAP3B7D7l8B+RgH5k2IPdZFRYx/w3m+G/Yxa8gWxL+fX3nwOsXdxxKt97o2H/Yyy8ifFHoZmbg/xsJ9RYWZ5/K16w2PVa2a0LNPoua63Vwp6FUQWg1dEvojwBFE4gEjHCpZRkT70mx/ipo7wi6fywN2NYT4QeQb6ku+LiKm9OvqgIWLOnzYbErTYMAEaqmVsf/Z5ykJDXgq2+1O9L/OLJCAb8PyvQOwP8WTV3qVvkPQGXozYlg8v/mQFPXqnkfexNWqfG96iYxqo515KJLnYvQy2ue+6N+6Sm/8=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="160" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-dasharray="3 3" pointer-events="none"/><rect x="120" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-dasharray="3 3" pointer-events="none"/><rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(15.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(55.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(95.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(135.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(15.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(55.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(95.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(135.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(15.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(55.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(90.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(131.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><rect x="320" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(335.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(375.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(415.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(455.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(335.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(375.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(415.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(455.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(335.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(375.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(410.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(451.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><ellipse cx="155" cy="155" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><ellipse cx="460" cy="115" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><ellipse cx="195" cy="115" rx="5" ry="5" fill="#97d077" stroke="#97d077" pointer-events="none"/><ellipse cx="475" cy="100" rx="5" ry="5" fill="#97d077" stroke="#97d077" pointer-events="none"/><path d="M 200 60 L 273.63 60" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 278.88 60 L 271.88 63.5 L 273.63 60 L 271.88 56.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(194.5,21.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 111px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step_back(1, 1)</div></div></foreignObject><text x="55" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step_back(1, 1)</text></switch></g><g transform="translate(194.5,81.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(255, 51, 51); line-height: 1.2; vertical-align: top; width: 111px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step_back(0, 1)</div></div></foreignObject><text x="55" y="17" fill="#FF3333" text-anchor="middle" font-size="16px" font-family="Helvetica">step_back(0, 1)</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="481px" height="161px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7ZxNc5swEIZ/jWfaG1jgj2PjJO2lM53JoceOCrJhgpEH5Njpr68ACYyWJM6MsySRfIlZQODnhRWvVmFCVtvj94Lukp88Ztlk6sXHCbmeTKe+F0zlnyry2ERCL2wCmyKN1UZd4C79x/SeKrpPY1b2NhScZyLd9YMRz3MWiV6MFgU/9Ddb86x/1B3dMBC4i2gGo7/TWCRNdBF6XfwHSzeJPrLvqTV/aXS/Kfg+V8ebTMm6/jSrt1S3pbYvExrzw0mI3EzIquBcNN+2xxXLKrYaW7Pf7RNr2/MuWC7O2UHp9ECzPdNnXJ+XeNQsDkkq2N2ORtXyQeo9IVeJ2GZyyZdfablrFFinRyZbvSpFwe/Zime8qBsgXv2Ra9Zplp3Eb+tPFee5UNeAP1PLve2I/Mh4TMukOkR9XHXirBDs+OSP91uk8lJlfMtE8Sg3UTtMA6WCukp9rcqh01xvkpzIrWNUXWWbtuWOtPyiYA+DJ1aD9wzwMzzwwYjgVSp4EXy7/wVYL/qoAzzSoWWk2/SBj3pmG+rZaKjnlqE2czUi6oVlqI1UvcAjvbSMtJmqEVFri2MP69l4rH3LWJvJGpP1mFbyHWRrTPPoj+ke30O+RoVtm2M0EzYqbNtMIxgKwYQNbaMHaMufJvqA+zxznjMDpQrRLN3kcjGSKJiMX1Wg0ohm39SKbRrH1WGuhhStB1HrQSdv1LwenqfH9BJ6QG/pOz3M3I8pCHSgMB3ZJ8hsPEGgUSVOELMPQRREt3EiSOAEMbqQJaIe0PGGTg+zC8EUBNrimRPE7EIwBYHeee4EMbsQTEGgv144QczRJYIoCPTgSycIGILCVAQadV1GsFoSc6AKU5IBr+7MOhzOwpTEtnpxMF5p3rqKcRCMxlrfQvawHm/OGrGtYhyON2mNQGv8uVmb+RqxOk9sqxib+RqTtW0FYzNfY7K2rV5s5mtM1rbNMjbzNer/h9g2z9hM2KiwrXOOI05eI7ZZRzNlY8LWbbgpPs8ldsSCeQANphs2BMkfUxDoQmE+sk+Q8WbBBdCqujk+oBPBFAT6WTfHB/QhiBXzAJpeN8kH9CGYgkBn7Cb5gD4EUxDont0kH9CHYAoCHbab5AMHmBCr5QG04W6WDxyFQlREP9K5WT7Pj1VhSjLg1p1dhyNamJJAvw4EkXuku/IpbK8aSGzfgQTeoaTjiJOriIF9oAP3B7D7l8B+RgH5k2IPdZFRYx/w3m+G/Yxa8gWxL+fX3nwOsXdxxKt97o2H/Yyy8ifFHoZmbg/xsJ9RYWZ5/K16w2PVa2a0LNPoua63Vwp6FUQWg1dEvojwBFE4gEjHCpZRkT70mx/ipo7wi6fywN2NYT4QeQb6ku+LiKm9OvqgIWLOnzYbErTYMAEaqmVsf/Z5ykJDXgq2+1O9L/OLJCAb8PyvQOwP8WTV3qVvkPQGXozYlg8v/mQFPXqnkfexNWqfG96iYxqo515KJLnYvQy2ue+6N+6Sm/8=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="160" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-dasharray="3 3" pointer-events="none"/><rect x="120" y="120" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-dasharray="3 3" pointer-events="none"/><rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="0" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="40" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="80" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="120" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(15.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(55.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(95.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(135.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(15.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(55.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(95.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(135.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(15.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(55.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(90.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(131.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><rect x="320" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="40" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="320" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="360" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="400" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><rect x="440" y="80" width="40" height="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(335.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">0</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">0</text></switch></g><g transform="translate(375.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">1</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">1</text></switch></g><g transform="translate(415.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">2</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">2</text></switch></g><g transform="translate(455.5,11.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">3</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">3</text></switch></g><g transform="translate(335.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">4</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">4</text></switch></g><g transform="translate(375.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">5</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">5</text></switch></g><g transform="translate(415.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">6</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">6</text></switch></g><g transform="translate(455.5,51.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">7</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">7</text></switch></g><g transform="translate(335.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">8</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">8</text></switch></g><g transform="translate(375.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 10px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">9</div></div></foreignObject><text x="5" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">9</text></switch></g><g transform="translate(410.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">10</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">10</text></switch></g><g transform="translate(451.5,91.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="17" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 18px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">11</div></div></foreignObject><text x="9" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">11</text></switch></g><ellipse cx="155" cy="155" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><ellipse cx="460" cy="115" rx="5" ry="5" fill="#ff3333" stroke="#ff3333" pointer-events="none"/><ellipse cx="195" cy="115" rx="5" ry="5" fill="#97d077" stroke="#97d077" pointer-events="none"/><ellipse cx="475" cy="100" rx="5" ry="5" fill="#97d077" stroke="#97d077" pointer-events="none"/><path d="M 200 60 L 273.63 60" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 278.88 60 L 271.88 63.5 L 273.63 60 L 271.88 56.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(194.5,21.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(151, 208, 119); line-height: 1.2; vertical-align: top; width: 111px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step_back(1, 1)</div></div></foreignObject><text x="55" y="17" fill="#97D077" text-anchor="middle" font-size="16px" font-family="Helvetica">step_back(1, 1)</text></switch></g><g transform="translate(194.5,81.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(255, 51, 51); line-height: 1.2; vertical-align: top; width: 111px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">step_back(0, 1)</div></div></foreignObject><text x="55" y="17" fill="#FF3333" text-anchor="middle" font-size="16px" font-family="Helvetica">step_back(0, 1)</text></switch></g></g></svg>
diff --git a/docs/source/developer/xarray_uml.svg b/docs/source/developer/xarray_uml.svg
index 2cc84c29c..958d142ea 100644
--- a/docs/source/developer/xarray_uml.svg
+++ b/docs/source/developer/xarray_uml.svg
@@ -1,3 +1,3 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="344px" height="640px" viewBox="-0.5 -0.5 344 640" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36&quot; version=&quot;9.3.2&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram id=&quot;e3c463fd-7d45-922b-6f4c-4b6b824d21ae&quot; name=&quot;Page-1&quot;&gt;5VrLcpswFP0abzsIAcbLJk3SRTvTmSzarjyyUbAajDxCTux+fWUjmcdVXOIaxaTeGF09QEfnPmGEr5ebO0FWi688odnI95LNCH8a+T6aeJH620m2WuKhcSlJBUu0rBLcs9/UDNTSNUto0RgoOc8kWzWFc57ndC4bMiIEf24Oe+BZ864rklIguJ+TDEq/s0QuSmkcepX8M2XpwtwZebpnRuaPqeDrXN9v5OOH/a/sXhKzlh5fLEjCn2sifDPC14JzWV4tN9c024FrYCvn3b7Qe3huQXPZZYJfTngi2VpvfUM3K0GLgvFcP6LcGlgWcpmpKzTCV4UU/JFe84yLfR/29j/V88CyrCbX21dynkvbePjIehdPVEi6qYn0Fu4oX1IptmqI7vUD/0NYTtKM88dx2X6ujg8Zdi1qR2eOlGjGpIfFK9TUhQbODiKGICoSku1g8MMY4BdhgF9ggQ+fAb4AwlfQJcklm09npKCDgRHSEE8gjL3RMHx/NMQWNe6LhhGADwBH8+Tjzruo1izj80e17W5YvoCZgkpsfyihp/atmz/1anTDZK1LtXY95azklu22YVraf6Kjx1DwtZjThsZJIlIqG46AJg3HCI+qdhDhER4LmhHJnpru1HY6+g7fOFPPe0STQoSbi5T70fPqHq691KS9VBC1lipxAEvtCXPYeicOjaEKqhBFEpZTMTVGbTD6qNQPnEII7Znfkz2L3589C02c6MCeTf4fezaG9iy4LHs2gZp0sj1rLxUEcV/2zIQqdc4oRO91kwu54CnPSXZTSa/26Q9N9HnWCHWMAnbiaEK0SXqUMb+olFstIGvJlah6zi+cr06mdycuxpCLcUcudiZZVxOAjMlq+qNCTpmkgsyy4cTWgdFEoz8WR9RXYI0sWfKwPFEYNNEL3LkhZMmOB88+FDksLyBLgjxs+qHQXXUBwbQY+rR3EgcZXas7H+MDLiQSwl4zeEFx64y7xkFgIXPQPURBsDRQpXWDUcK2DXNam0KWzHjYNgzHY3c2zJIKK3CYirKnwyeitajQGxFhWjxwIrqsKZhSz8U405NcZsM94otyj2HLq/nnco/g+M/nHn2YZb4tKfqMsCzpvQkPLoVCqFUeMunraynUXgjj3upMhjHDtco4bNd6I1OBdeHWLO+gXerg2KkSmr3VlXB8UTqIPVDv9VvpSXdDDuq9YW/vryzv4l3SyH9zGqGutVo3PApaJjgy4etrWRSYF+kHOga9ccjyHcIuSWHpmq+LN6k8AzNu4UbndMXpp0WWrxLcO8Z/gq+drrj8ssjyPt6lOTuvNWuZpL+HqhE0b6VuXkpkerJPBCHu2TyialYfX5bDq09c8c0f&lt;/diagram&gt;&lt;/mxfile&gt;" style="background-color: rgb(255, 255, 255);"><defs/><rect x="5.5" y="238" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(28.5,256.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="64" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xexpression</div></div></foreignObject><text x="32" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xexpression</text></switch></g><rect x="95.5" y="223" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(98.5,231.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><rect x="5.5" y="353" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(16.5,371.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="87" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsemantic_base</div></div></foreignObject><text x="44" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xsemantic_base</text></switch></g><rect x="95.5" y="338" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(98.5,346.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 61 353 L 61 300.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 61 289.12 L 66.5 300.12 L 55.5 300.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0.5" y="475" width="120" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(5.5,493.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer_semantic</text></switch></g><rect x="95.5" y="460" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(98.5,468.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 61 475 L 61 415.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 61 404.12 L 66.5 415.12 L 55.5 415.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 116 460 L 116 460" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 116 460 L 116 460 L 116 460 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="213" y="15" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(227.5,33.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="81" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xconst_iterable</div></div></foreignObject><text x="41" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xconst_iterable</text></switch></g><rect x="303" y="0" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,8.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><rect x="213" y="128" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(244.5,146.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="46" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xiterable</div></div></foreignObject><text x="23" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xiterable</text></switch></g><rect x="303" y="113" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,121.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 268 128 L 268 77.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 66.12 L 273.5 77.12 L 262.5 77.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="213" y="353" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(239.5,371.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="56" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer</div></div></foreignObject><text x="28" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer</text></switch></g><rect x="303" y="347" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,355.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><rect x="213" y="475" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(218.5,493.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="98" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xstrided_container</div></div></foreignObject><text x="49" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xstrided_container</text></switch></g><rect x="303" y="460" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,468.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 268 240 L 268 190.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 179.12 L 273.5 190.12 L 262.5 190.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 475 L 268 415.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 404.12 L 273.5 415.12 L 262.5 415.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="115.5" y="589" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(153.5,607.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 171 589 L 100.46 532.57" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 91.87 525.7 L 103.9 528.28 L 97.03 536.86 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 171 589 L 232.06 533.18" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 240.17 525.75 L 235.77 537.24 L 228.35 529.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="213" y="238" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(212.5,256.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontiguous_iterable</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontiguous_iterable</text></switch></g><rect x="303" y="223" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,231.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 268 353 L 268 300.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 289.12 L 273.5 300.12 L 262.5 300.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="344px" height="640px" viewBox="-0.5 -0.5 344 640" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36&quot; version=&quot;9.3.2&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram id=&quot;e3c463fd-7d45-922b-6f4c-4b6b824d21ae&quot; name=&quot;Page-1&quot;&gt;5VrLcpswFP0abzsIAcbLJk3SRTvTmSzarjyyUbAajDxCTux+fWUjmcdVXOIaxaTeGF09QEfnPmGEr5ebO0FWi688odnI95LNCH8a+T6aeJH620m2WuKhcSlJBUu0rBLcs9/UDNTSNUto0RgoOc8kWzWFc57ndC4bMiIEf24Oe+BZ864rklIguJ+TDEq/s0QuSmkcepX8M2XpwtwZebpnRuaPqeDrXN9v5OOH/a/sXhKzlh5fLEjCn2sifDPC14JzWV4tN9c024FrYCvn3b7Qe3huQXPZZYJfTngi2VpvfUM3K0GLgvFcP6LcGlgWcpmpKzTCV4UU/JFe84yLfR/29j/V88CyrCbX21dynkvbePjIehdPVEi6qYn0Fu4oX1IptmqI7vUD/0NYTtKM88dx2X6ujg8Zdi1qR2eOlGjGpIfFK9TUhQbODiKGICoSku1g8MMY4BdhgF9ggQ+fAb4AwlfQJcklm09npKCDgRHSEE8gjL3RMHx/NMQWNe6LhhGADwBH8+Tjzruo1izj80e17W5YvoCZgkpsfyihp/atmz/1anTDZK1LtXY95azklu22YVraf6Kjx1DwtZjThsZJIlIqG46AJg3HCI+qdhDhER4LmhHJnpru1HY6+g7fOFPPe0STQoSbi5T70fPqHq691KS9VBC1lipxAEvtCXPYeicOjaEKqhBFEpZTMTVGbTD6qNQPnEII7Znfkz2L3589C02c6MCeTf4fezaG9iy4LHs2gZp0sj1rLxUEcV/2zIQqdc4oRO91kwu54CnPSXZTSa/26Q9N9HnWCHWMAnbiaEK0SXqUMb+olFstIGvJlah6zi+cr06mdycuxpCLcUcudiZZVxOAjMlq+qNCTpmkgsyy4cTWgdFEoz8WR9RXYI0sWfKwPFEYNNEL3LkhZMmOB88+FDksLyBLgjxs+qHQXXUBwbQY+rR3EgcZXas7H+MDLiQSwl4zeEFx64y7xkFgIXPQPURBsDRQpXWDUcK2DXNam0KWzHjYNgzHY3c2zJIKK3CYirKnwyeitajQGxFhWjxwIrqsKZhSz8U405NcZsM94otyj2HLq/nnco/g+M/nHn2YZb4tKfqMsCzpvQkPLoVCqFUeMunraynUXgjj3upMhjHDtco4bNd6I1OBdeHWLO+gXerg2KkSmr3VlXB8UTqIPVDv9VvpSXdDDuq9YW/vryzv4l3SyH9zGqGutVo3PApaJjgy4etrWRSYF+kHOga9ccjyHcIuSWHpmq+LN6k8AzNu4UbndMXpp0WWrxLcO8Z/gq+drrj8ssjyPt6lOTuvNWuZpL+HqhE0b6VuXkpkerJPBCHu2TyialYfX5bDq09c8c0f&lt;/diagram&gt;&lt;/mxfile&gt;" style="background-color: rgb(255, 255, 255);"><defs/><rect x="5.5" y="238" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(28.5,256.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="64" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xexpression</div></div></foreignObject><text x="32" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xexpression</text></switch></g><rect x="95.5" y="223" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(98.5,231.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><rect x="5.5" y="353" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(16.5,371.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="87" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsemantic_base</div></div></foreignObject><text x="44" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xsemantic_base</text></switch></g><rect x="95.5" y="338" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(98.5,346.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 61 353 L 61 300.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 61 289.12 L 66.5 300.12 L 55.5 300.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0.5" y="475" width="120" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(5.5,493.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer_semantic</text></switch></g><rect x="95.5" y="460" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(98.5,468.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 61 475 L 61 415.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 61 404.12 L 66.5 415.12 L 55.5 415.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 116 460 L 116 460" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 116 460 L 116 460 L 116 460 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="213" y="15" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(227.5,33.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="81" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xconst_iterable</div></div></foreignObject><text x="41" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xconst_iterable</text></switch></g><rect x="303" y="0" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,8.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><rect x="213" y="128" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(244.5,146.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="46" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xiterable</div></div></foreignObject><text x="23" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xiterable</text></switch></g><rect x="303" y="113" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,121.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 268 128 L 268 77.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 66.12 L 273.5 77.12 L 262.5 77.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="213" y="353" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(239.5,371.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="56" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer</div></div></foreignObject><text x="28" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer</text></switch></g><rect x="303" y="347" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,355.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><rect x="213" y="475" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(218.5,493.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="98" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xstrided_container</div></div></foreignObject><text x="49" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xstrided_container</text></switch></g><rect x="303" y="460" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,468.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 268 240 L 268 190.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 179.12 L 273.5 190.12 L 262.5 190.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 475 L 268 415.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 404.12 L 273.5 415.12 L 262.5 415.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="115.5" y="589" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(153.5,607.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 171 589 L 100.46 532.57" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 91.87 525.7 L 103.9 528.28 L 97.03 536.86 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 171 589 L 232.06 533.18" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 240.17 525.75 L 235.77 537.24 L 228.35 529.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="213" y="238" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(212.5,256.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontiguous_iterable</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontiguous_iterable</text></switch></g><rect x="303" y="223" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(306.5,231.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="33" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xarray</div></div></foreignObject><text x="17" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xarray</text></switch></g><path d="M 268 353 L 268 300.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 268 289.12 L 273.5 300.12 L 262.5 300.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></svg>
diff --git a/docs/source/developer/xcontainer_classes.svg b/docs/source/developer/xcontainer_classes.svg
index 3d5a55320..ecfa32f63 100644
--- a/docs/source/developer/xcontainer_classes.svg
+++ b/docs/source/developer/xcontainer_classes.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="131px" height="519px" viewBox="-0.5 -0.5 131 519" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36&quot; version=&quot;9.3.2&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;5VhBk5sgGP01XndEJDHHNrvbXjrTmT20Pe0QJcqESAZxk/TXlwRQUbN1plknsV4iD/iAx+N7QQ8ut4cvAu+ybzwhzAv85ODBRy8IAPBn6ueEHDWCwFwDqaCJaVQDL/Q3MaBv0JImpHAaSs6ZpDsXjHmek1g6GBaC791ma87cUXc4JR3gJcasi/6gicw0GiG/xr8SmmayWrCpWeF4kwpe5mY8L4Dr86Ort9jGMu2LDCd834DgkweXgnOp37aHJWEnbi1tut/zhdpq3oLkckiHQHd4w6w0Sz8oTgv5SiUReKX40NOUR0tNJrdMvQEPfi6k4Buy5IyLcx30z4+qWVPGGrihQOE8l33tzSyIkORwcSWg4kfpjvAtkeKompgOod0cKzmki/t6/4CVV9bYO9sNG8mkVeSaNvVimOtnEXZYfLwb3lDo8maLDd7CHtrgFWgLu+K7e9mBWTSe7tCEdAcQHE14sw5vHdpInnw6GYkqrRiPN2rRw5i8wJhiRRx/KtB/QLb4y0QjSvaNKlU61eheyTM9LcOWjFWCehNI0rKygpciJs4Jk1ikRDoZf8BGNTYCvSNgQRiW9M2dRN/umBG+c6oGrnQAfeTqIGptsF6P6dW0sr8FAsgNpFnoBDqLpVr2IP3Me11TYpoTcTcHsJ254GJEx4wmlLlgNJ5lLrrKU9yoP8vJ6/0rEPkjeqeNOwkJhovxzBOA/8U9F133nN+YeyLgml7ot0xvqHu2A0HYmsv13BP0XzolTUteFvd/8wyi4GFEKwVTun0Gs3kPdx+Wyro30ImmMnvmbidx+WHr0LRCDE5c7UAg+rDE1b1vT0guNyuN6mLyr9KAMLiSNFSx/karm9cfwuHTHw==&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><rect x="0" y="15" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(14.5,33.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="81" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xconst_iterable</div></div></foreignObject><text x="41" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xconst_iterable</text></switch></g><rect x="90" y="0" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,8.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="0" y="128" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(31.5,146.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="46" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xiterable</div></div></foreignObject><text x="23" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xiterable</text></switch></g><rect x="90" y="113" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,121.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 55 128 L 55 77.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 55 66.12 L 60.5 77.12 L 49.5 77.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0" y="355" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(26.5,373.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="56" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer</div></div></foreignObject><text x="28" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer</text></switch></g><rect x="90" y="340" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,348.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="0" y="468" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(5.5,486.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="98" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xstrided_container</div></div></foreignObject><text x="49" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xstrided_container</text></switch></g><rect x="90" y="453" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,461.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 55 468 L 55 417.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 55 406.12 L 60.5 417.12 L 49.5 417.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0" y="242.5" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(-0.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontiguous_iterable</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontiguous_iterable</text></switch></g><rect x="90" y="227.5" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,236.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 55 243 L 54.19 190.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 54.02 179.12 L 59.69 190.03 L 48.69 190.2 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 54 355 L 54 304.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 54 293.12 L 59.5 304.12 L 48.5 304.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="131px" height="519px" viewBox="-0.5 -0.5 131 519" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36&quot; version=&quot;9.3.2&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;5VhBk5sgGP01XndEJDHHNrvbXjrTmT20Pe0QJcqESAZxk/TXlwRQUbN1plknsV4iD/iAx+N7QQ8ut4cvAu+ybzwhzAv85ODBRy8IAPBn6ueEHDWCwFwDqaCJaVQDL/Q3MaBv0JImpHAaSs6ZpDsXjHmek1g6GBaC791ma87cUXc4JR3gJcasi/6gicw0GiG/xr8SmmayWrCpWeF4kwpe5mY8L4Dr86Ort9jGMu2LDCd834DgkweXgnOp37aHJWEnbi1tut/zhdpq3oLkckiHQHd4w6w0Sz8oTgv5SiUReKX40NOUR0tNJrdMvQEPfi6k4Buy5IyLcx30z4+qWVPGGrihQOE8l33tzSyIkORwcSWg4kfpjvAtkeKompgOod0cKzmki/t6/4CVV9bYO9sNG8mkVeSaNvVimOtnEXZYfLwb3lDo8maLDd7CHtrgFWgLu+K7e9mBWTSe7tCEdAcQHE14sw5vHdpInnw6GYkqrRiPN2rRw5i8wJhiRRx/KtB/QLb4y0QjSvaNKlU61eheyTM9LcOWjFWCehNI0rKygpciJs4Jk1ikRDoZf8BGNTYCvSNgQRiW9M2dRN/umBG+c6oGrnQAfeTqIGptsF6P6dW0sr8FAsgNpFnoBDqLpVr2IP3Me11TYpoTcTcHsJ254GJEx4wmlLlgNJ5lLrrKU9yoP8vJ6/0rEPkjeqeNOwkJhovxzBOA/8U9F133nN+YeyLgml7ot0xvqHu2A0HYmsv13BP0XzolTUteFvd/8wyi4GFEKwVTun0Gs3kPdx+Wyro30ImmMnvmbidx+WHr0LRCDE5c7UAg+rDE1b1vT0guNyuN6mLyr9KAMLiSNFSx/karm9cfwuHTHw==&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><rect x="0" y="15" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(14.5,33.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="81" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xconst_iterable</div></div></foreignObject><text x="41" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xconst_iterable</text></switch></g><rect x="90" y="0" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,8.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="0" y="128" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(31.5,146.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="46" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xiterable</div></div></foreignObject><text x="23" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xiterable</text></switch></g><rect x="90" y="113" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,121.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 55 128 L 55 77.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 55 66.12 L 60.5 77.12 L 49.5 77.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0" y="355" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(26.5,373.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="56" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer</div></div></foreignObject><text x="28" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer</text></switch></g><rect x="90" y="340" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,348.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="0" y="468" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(5.5,486.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="98" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xstrided_container</div></div></foreignObject><text x="49" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xstrided_container</text></switch></g><rect x="90" y="453" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,461.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 55 468 L 55 417.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 55 406.12 L 60.5 417.12 L 49.5 417.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0" y="242.5" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(-0.5,261.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontiguous_iterable</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontiguous_iterable</text></switch></g><rect x="90" y="227.5" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(105.5,236.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 55 243 L 54.19 190.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 54.02 179.12 L 59.69 190.03 L 48.69 190.2 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 54 355 L 54 304.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 54 293.12 L 59.5 304.12 L 48.5 304.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></svg>
diff --git a/docs/source/developer/xfunction_tree.svg b/docs/source/developer/xfunction_tree.svg
index a0b551d8a..791a9cd06 100644
--- a/docs/source/developer/xfunction_tree.svg
+++ b/docs/source/developer/xfunction_tree.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="411px" height="322px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VnLctowFP0aL8tYMga6TEjSLtqZzmTRdilsYasRlivLwfTrK1kStvygzABJpoEF+J579TrnSpaEFyw31SeO8vQrizH1oB9XXnDnQQj8KZQ/CtlpJPRDDSScxCaoAR7JH2xLGrQkMS6cQMEYFSR3wYhlGY6EgyHO2dYNWzPqtpqjBPeAxwjRPvqdxCLV6CL0G/wzJklqWwa+8axQ9JRwVmamPQ8G6/qj3Rtk6zLxRYpitm1Bwb0XLDljQj9tqiWmiltLmy73MOLd95vjTBxTwOj0jGiJbY/rfomd5UIWkLRL43abEoEfcxQpz1YqL7FUbKi0gHxERa61WJMKy/pvC8HZE14yynhdVeDXH+lZE0pbuKFI4iwTQ/Gml5gLXI2OFOz5k3mJ2QYLvpMhpgC0EpmUXBhz29LXQGlLWoshk1HJvuKGVflgiB0mORgg+bbHsxyacAl1+ctYhjvUGQhRkmTSjCQVWOK3iigis/nGODYkjumYgnW2Kr3u/AMKKNzM0wCeSRHoKrKfRC1JpgOSTM8gybQnSbUus0gQlnlwhjaKGKrkyGlZeFDW508mE+mqwSJHKiwRNREm3FpU/z64QW9WbCMqmF12+oHZwhE77GsNpmFfbHgGscP+mhbL5d6YjIuUJSxD9L5BO0S1dMIVET8UPJmHxvxpoiQVfNf2KbtxxjfqzSTNFWXRk4YeiOq1DbBaKPMXFmJnAFQKJqGmp18YywfzZmTKAvhPdRUljrYFK3mEnekiEE+wcKAjMoBjigR5dms/Rc/ZVc//Ss/529uEHM/zSaviwn0D7l9tL7ApWbxb0gP4eqx/vMzSdWDlui5cl1u47HH14CRq6I4oKgoSHdr3jdF2aHe2T4NWEoB2EoBuChxBNOwTPT+a6NZECgcmksWO1sO08I0R2fDY4hl87MxPPRxTqH0G7tQDgk5F3QOGJqFXUZ0d+1EflzDgLSUMGEsY/zwJs7gmzMkJ07+giVhW1J1BnKOde1qNWbmSedQ9kmpLf/fy7d0dRYNwWL32UXQ+kIXnOIqC/l3QVc9T75Hmrylo/ybJ3gGpITvSzH6XzDo+FDU5NzIggHnVOO2VEWpdJemarldJdtfV2b/PXu7eEIQXknt1lXtsuZ6+mNzSbP560W/r5v+t4P4v&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><ellipse cx="205" cy="81" rx="40" ry="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(195.5,62.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 32px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 20px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">+</div></div></foreignObject><text x="9" y="34" fill="#000000" text-anchor="middle" font-size="32px" font-family="Helvetica">+</text></switch></g><g transform="translate(138.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="134" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 135px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xfunction&lt;plus, ...<span>&gt;</span></div></div></foreignObject><text x="67" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">xfunction&amp;lt;plus, ...&lt;span&gt;&amp;gt;&lt;/span&gt;</text></switch></g><path d="M 242 11 L 242 11" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 242 11 L 242 11 L 242 11 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 242 11 L 242 11" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 242 11 L 242 11 L 242 11 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><ellipse cx="85" cy="241" rx="40" ry="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><ellipse cx="325" cy="241" rx="40" ry="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><path d="M 206 11 L 206 11" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 206 11 L 206 11 L 206 11 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 177 109 L 116.34 207.58" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 113.59 212.05 L 114.27 204.25 L 116.34 207.58 L 120.24 207.92 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 233 109 L 293.66 207.58" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 296.41 212.05 L 289.76 207.92 L 293.66 207.58 L 295.73 204.25 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(2.5,302.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="165" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 165px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">const xarray&lt;double&gt;&amp;</div></div></foreignObject><text x="83" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">const xarray&amp;lt;double&amp;gt;&amp;amp;</text></switch></g><g transform="translate(242.5,302.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="165" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 165px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">const xarray&lt;double&gt;&amp;</div></div></foreignObject><text x="83" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">const xarray&amp;lt;double&amp;gt;&amp;amp;</text></switch></g><g transform="translate(75.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 32px">a</font></div></div></foreignObject><text x="9" y="26" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><g transform="translate(315.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 32px">b</font></div></div></foreignObject><text x="9" y="26" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="411px" height="322px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;7VnLctowFP0aL8tYMga6TEjSLtqZzmTRdilsYasRlivLwfTrK1kStvygzABJpoEF+J579TrnSpaEFyw31SeO8vQrizH1oB9XXnDnQQj8KZQ/CtlpJPRDDSScxCaoAR7JH2xLGrQkMS6cQMEYFSR3wYhlGY6EgyHO2dYNWzPqtpqjBPeAxwjRPvqdxCLV6CL0G/wzJklqWwa+8axQ9JRwVmamPQ8G6/qj3Rtk6zLxRYpitm1Bwb0XLDljQj9tqiWmiltLmy73MOLd95vjTBxTwOj0jGiJbY/rfomd5UIWkLRL43abEoEfcxQpz1YqL7FUbKi0gHxERa61WJMKy/pvC8HZE14yynhdVeDXH+lZE0pbuKFI4iwTQ/Gml5gLXI2OFOz5k3mJ2QYLvpMhpgC0EpmUXBhz29LXQGlLWoshk1HJvuKGVflgiB0mORgg+bbHsxyacAl1+ctYhjvUGQhRkmTSjCQVWOK3iigis/nGODYkjumYgnW2Kr3u/AMKKNzM0wCeSRHoKrKfRC1JpgOSTM8gybQnSbUus0gQlnlwhjaKGKrkyGlZeFDW508mE+mqwSJHKiwRNREm3FpU/z64QW9WbCMqmF12+oHZwhE77GsNpmFfbHgGscP+mhbL5d6YjIuUJSxD9L5BO0S1dMIVET8UPJmHxvxpoiQVfNf2KbtxxjfqzSTNFWXRk4YeiOq1DbBaKPMXFmJnAFQKJqGmp18YywfzZmTKAvhPdRUljrYFK3mEnekiEE+wcKAjMoBjigR5dms/Rc/ZVc//Ss/529uEHM/zSaviwn0D7l9tL7ApWbxb0gP4eqx/vMzSdWDlui5cl1u47HH14CRq6I4oKgoSHdr3jdF2aHe2T4NWEoB2EoBuChxBNOwTPT+a6NZECgcmksWO1sO08I0R2fDY4hl87MxPPRxTqH0G7tQDgk5F3QOGJqFXUZ0d+1EflzDgLSUMGEsY/zwJs7gmzMkJ07+giVhW1J1BnKOde1qNWbmSedQ9kmpLf/fy7d0dRYNwWL32UXQ+kIXnOIqC/l3QVc9T75Hmrylo/ybJ3gGpITvSzH6XzDo+FDU5NzIggHnVOO2VEWpdJemarldJdtfV2b/PXu7eEIQXknt1lXtsuZ6+mNzSbP560W/r5v+t4P4v&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><ellipse cx="205" cy="81" rx="40" ry="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(195.5,62.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 32px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 20px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">+</div></div></foreignObject><text x="9" y="34" fill="#000000" text-anchor="middle" font-size="32px" font-family="Helvetica">+</text></switch></g><g transform="translate(138.5,12.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="134" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 135px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xfunction&lt;plus, ...<span>&gt;</span></div></div></foreignObject><text x="67" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">xfunction&amp;lt;plus, ...&lt;span&gt;&amp;gt;&lt;/span&gt;</text></switch></g><path d="M 242 11 L 242 11" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 242 11 L 242 11 L 242 11 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 242 11 L 242 11" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 242 11 L 242 11 L 242 11 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><ellipse cx="85" cy="241" rx="40" ry="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><ellipse cx="325" cy="241" rx="40" ry="40" fill="#ffffff" stroke="#000000" pointer-events="none"/><path d="M 206 11 L 206 11" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 206 11 L 206 11 L 206 11 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 177 109 L 116.34 207.58" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 113.59 212.05 L 114.27 204.25 L 116.34 207.58 L 120.24 207.92 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 233 109 L 293.66 207.58" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 296.41 212.05 L 289.76 207.92 L 293.66 207.58 L 295.73 204.25 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><g transform="translate(2.5,302.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="165" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 165px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">const xarray&lt;double&gt;&amp;</div></div></foreignObject><text x="83" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">const xarray&amp;lt;double&amp;gt;&amp;amp;</text></switch></g><g transform="translate(242.5,302.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="165" height="17" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 165px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">const xarray&lt;double&gt;&amp;</div></div></foreignObject><text x="83" y="17" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">const xarray&amp;lt;double&amp;gt;&amp;amp;</text></switch></g><g transform="translate(75.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 32px">a</font></div></div></foreignObject><text x="9" y="26" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g><g transform="translate(315.5,222.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="18" height="36" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 16px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; width: 19px; white-space: nowrap; word-wrap: normal; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;"><font style="font-size: 32px">b</font></div></div></foreignObject><text x="9" y="26" fill="#000000" text-anchor="middle" font-size="16px" font-family="Helvetica">[Not supported by viewer]</text></switch></g></g></svg>
diff --git a/docs/source/developer/xsemantic_classes.svg b/docs/source/developer/xsemantic_classes.svg
index 861d145ae..95c501844 100644
--- a/docs/source/developer/xsemantic_classes.svg
+++ b/docs/source/developer/xsemantic_classes.svg
@@ -1,2 +1,2 @@
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="301px" height="299px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;3ZjLctowFIafxtuOZdnBLBuStIt2pjNZtF1lhH2wVYQPI4tg+vQVWMIXAeNhAgllE+vX/T+fdRR7dLKovki2zL9jCsIL/LTy6IMXBMQPA/1nq2xqJfKjWsgkT02jRnjmf8H2NOqKp1B2GipEofiyKyZYFJCojsakxHW32QxFd9Yly8ARnhMmXPUnT1Veq3HkN/pX4FluZya+qZmyZJ5JXBVmPi+gs92vrl4wO5ZpX+YsxXVLoo8enUhEVT8tqgmIrbfWtrrf05Ha/bolFGpIBxOnVyZWZusVVEsJZcmxMEtUG2tLrhZCPxGP3pdK4hwmKFDu6qi/++maGReipZvtax0Ldai9WQFIBdXRXZC9N5o5wAUoudFNTIcgNHZa3Axt6yZ2xKKVt+Jm48kMLtl+5MYy/WBcO+wgdRx8uBnfKO36Zm1s+RYesI2+gW2hC14JC1YonrxMWQk342GfPTJyTbwYfNF/BB858NZeir47xzfHNijSz9tMoktTgclcb3qYk0cc067IzS8t+p8iW/xtRoOKq1aVLm1r6l7pE99uw5ZMriRNECDt5bISVzKBzmummMxAdY78AYFqBSI6AbAEwRR/7S7iUHTMDD+Q64mPvkDBuBfgej+mVzuX9Qca9wYKewPVLjgD7WDZb3sQPyP39NJXEcV4AfLFnmM38yaSu55xceweYcGFjrD4ho+woG/ciF7tCBu7CL5yWN8efTR4R/psYr5J/MK+c1fEj5B3TaHBFXPoyM2h4UfLoePorXJobyB7xXz7HErc/z0vT9B5kLTAGzngDSBo/PEJ2t++N/aMiM8jiPq9Qym42C2MUBcYHYZnU0SpcsywYOKxUe93H2cgNYFu0XSKjcNXd0NKn9CTKP0BpTZGYCuFWmrW+Q1xeTbbAziMXQ7jwRwOBuxICtHF5rtWHe3m4yF9/Ac=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="80" y="15" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(102.5,33.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="64" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xexpression</div></div></foreignObject><text x="32" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xexpression</text></switch></g><rect x="170" y="0" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(185.5,8.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="80" y="130" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(91.5,148.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="86" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsemantic_base</div></div></foreignObject><text x="43" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xsemantic_base</text></switch></g><rect x="170" y="115" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(185.5,123.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 135 130 L 135 77.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 135 66.12 L 140.5 77.12 L 129.5 77.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0" y="248" width="120" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(4.5,266.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer_semantic</text></switch></g><rect x="100" y="233" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(115.5,241.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="160" y="248" width="120" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(177.5,266.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="85" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xview_semantic</div></div></foreignObject><text x="43" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xview_semantic</text></switch></g><rect x="260" y="233" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(275.5,241.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 60 248 L 101.01 189.9" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 107.36 180.91 L 105.51 193.07 L 96.52 186.73 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 220 248 L 170.78 189.29" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 163.72 180.86 L 175 185.75 L 166.57 192.82 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 233 L 120 233" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 233 L 120 233 L 120 233 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="301px" height="299px" version="1.1" content="&lt;mxfile userAgent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36&quot; version=&quot;8.0.9&quot; editor=&quot;www.draw.io&quot; type=&quot;device&quot;&gt;&lt;diagram&gt;3ZjLctowFIafxtuOZdnBLBuStIt2pjNZtF1lhH2wVYQPI4tg+vQVWMIXAeNhAgllE+vX/T+fdRR7dLKovki2zL9jCsIL/LTy6IMXBMQPA/1nq2xqJfKjWsgkT02jRnjmf8H2NOqKp1B2GipEofiyKyZYFJCojsakxHW32QxFd9Yly8ARnhMmXPUnT1Veq3HkN/pX4FluZya+qZmyZJ5JXBVmPi+gs92vrl4wO5ZpX+YsxXVLoo8enUhEVT8tqgmIrbfWtrrf05Ha/bolFGpIBxOnVyZWZusVVEsJZcmxMEtUG2tLrhZCPxGP3pdK4hwmKFDu6qi/++maGReipZvtax0Ldai9WQFIBdXRXZC9N5o5wAUoudFNTIcgNHZa3Axt6yZ2xKKVt+Jm48kMLtl+5MYy/WBcO+wgdRx8uBnfKO36Zm1s+RYesI2+gW2hC14JC1YonrxMWQk342GfPTJyTbwYfNF/BB858NZeir47xzfHNijSz9tMoktTgclcb3qYk0cc067IzS8t+p8iW/xtRoOKq1aVLm1r6l7pE99uw5ZMriRNECDt5bISVzKBzmummMxAdY78AYFqBSI6AbAEwRR/7S7iUHTMDD+Q64mPvkDBuBfgej+mVzuX9Qca9wYKewPVLjgD7WDZb3sQPyP39NJXEcV4AfLFnmM38yaSu55xceweYcGFjrD4ho+woG/ciF7tCBu7CL5yWN8efTR4R/psYr5J/MK+c1fEj5B3TaHBFXPoyM2h4UfLoePorXJobyB7xXz7HErc/z0vT9B5kLTAGzngDSBo/PEJ2t++N/aMiM8jiPq9Qym42C2MUBcYHYZnU0SpcsywYOKxUe93H2cgNYFu0XSKjcNXd0NKn9CTKP0BpTZGYCuFWmrW+Q1xeTbbAziMXQ7jwRwOBuxICtHF5rtWHe3m4yF9/Ac=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g transform="translate(0.5,0.5)"><rect x="80" y="15" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(102.5,33.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="64" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xexpression</div></div></foreignObject><text x="32" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xexpression</text></switch></g><rect x="170" y="0" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(185.5,8.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="80" y="130" width="110" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(91.5,148.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="86" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xsemantic_base</div></div></foreignObject><text x="43" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xsemantic_base</text></switch></g><rect x="170" y="115" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(185.5,123.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 135 130 L 135 77.12" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 135 66.12 L 140.5 77.12 L 129.5 77.12 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><rect x="0" y="248" width="120" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(4.5,266.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="110" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xcontainer_semantic</div></div></foreignObject><text x="55" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xcontainer_semantic</text></switch></g><rect x="100" y="233" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(115.5,241.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><rect x="160" y="248" width="120" height="50" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(177.5,266.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="85" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">xview_semantic</div></div></foreignObject><text x="43" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">xview_semantic</text></switch></g><rect x="260" y="233" width="40" height="30" fill="#ffffff" stroke="#000000" pointer-events="none"/><g transform="translate(275.5,241.5)"><switch><foreignObject style="overflow:visible;" pointer-events="all" width="9" height="12" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; vertical-align: top; white-space: nowrap; text-align: center;"><div xmlns="http://www.w3.org/1999/xhtml" style="display:inline-block;text-align:inherit;text-decoration:inherit;">D</div></div></foreignObject><text x="5" y="12" fill="#000000" text-anchor="middle" font-size="12px" font-family="Helvetica">D</text></switch></g><path d="M 60 248 L 101.01 189.9" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 107.36 180.91 L 105.51 193.07 L 96.52 186.73 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 220 248 L 170.78 189.29" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 163.72 180.86 L 175 185.75 L 166.57 192.82 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 233 L 120 233" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/><path d="M 120 233 L 120 233 L 120 233 Z" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="none"/></g></svg>
diff --git a/docs/source/developer/xtensor_internals.rst b/docs/source/developer/xtensor_internals.rst
index f03c844e0..ff1e897dd 100644
--- a/docs/source/developer/xtensor_internals.rst
+++ b/docs/source/developer/xtensor_internals.rst
@@ -7,8 +7,8 @@
 Internals of xtensor
 ====================
 
-This section provides information about `xtensor`'s internals and its architecture. It is intended for developers
-who want to contribute to `xtensor` or simply understand how it works under the hood. `xtensor` makes heavy use
+This section provides information about *xtensor*'s internals and its architecture. It is intended for developers
+who want to contribute to *xtensor* or simply understand how it works under the hood. *xtensor* makes heavy use
 of the CRTP pattern, template meta-programming, universal references and perfect forwarding. One should be familiar
 with these notions before going any further.
 
diff --git a/docs/source/expression.rst b/docs/source/expression.rst
index 4910e5280..8aa5d7324 100644
--- a/docs/source/expression.rst
+++ b/docs/source/expression.rst
@@ -10,16 +10,16 @@
 Expressions and lazy evaluation
 ===============================
 
-`xtensor` is more than an N-dimensional array library: it is an expression engine that allows numerical computation on any object implementing the expression interface.
-These objects can be in-memory containers such as ``xarray<T>`` and ``xtensor<T>``, but can also be backed by a database or a representation on the file system. This
-also enables creating adaptors as expressions for other data structures.
+*xtensor* is more than an N-dimensional array library: it is an expression engine that allows numerical computation on any object implementing the expression interface.
+These objects can be in-memory containers such as :cpp:type:`xt::xarray\<T\>` and :cpp:type:`xt::xtensor\<T\>`, but can also be backed by a database or a representation on the file system.
+This also enables creating adaptors as expressions for other data structures.
 
 Expressions
 -----------
 
 Assume ``x``, ``y`` and ``z`` are arrays of *compatible shapes* (we'll come back to that later), the return type of an expression such as ``x + y * sin(z)`` is **not an array**.
-The result is an ``xexpression`` which offers the same interface as an N-dimensional array but does not hold any value. Such expressions can be plugged into others to build
-more complex expressions:
+The result is an :cpp:type:`xt::xexpression` which offers the same interface as an N-dimensional array but does not hold any value.
+Such expressions can be plugged into others to build more complex expressions:
 
 .. code::
 
@@ -27,12 +27,12 @@ more complex expressions:
     auto f2 = w + 2 * cos(f);
 
 The expression engine avoids the evaluation of intermediate results and their storage in temporary arrays, so you can achieve the same performance as if you had written
-a simple loop. Assuming ``x``, ``y`` and ``z`` are one-dimensional arrays of length ``n``, 
+a simple loop. Assuming ``x``, ``y`` and ``z`` are one-dimensional arrays of length ``n``,
 
 .. code::
 
     xt::xarray<double> res = x + y * sin(z)
-   
+
 will produce quite the same assembly as the following loop:
 
 .. code::
@@ -71,8 +71,10 @@ and the size of the data, it might be convenient to store the result of the expr
 Forcing evaluation
 ------------------
 
-If you have to force the evaluation of an xexpression for some reason (for example, you want to have all results in memory to perform a sort or use external BLAS functions) then you can use ``xt::eval`` on an xexpression.
-Evaluating will either return an rvalue to a newly allocated container in the case of a xexpression, or a reference to a container in case you are evaluating a ``xarray`` or ``xtensor``. Note that, in order to avoid copies, you should use an universal reference on the lefthand side (``auto&&``). For example:
+If you have to force the evaluation of an xexpression for some reason (for example, you want to have all results in memory to perform a sort or use external BLAS functions) then you can use :cpp:func:`xt::eval` on an xexpression.
+Evaluating will either return a *rvalue* to a newly allocated container in the case of an xexpression, or a reference to a container in case you are evaluating a :cpp:type:`xt::xarray` or :cpp:type:`xt::xtensor`.
+Note that, in order to avoid copies, you should use a universal reference on the lefthand side (``auto&&``).
+For example:
 
 .. code::
 
@@ -86,23 +88,23 @@ Evaluating will either return an rvalue to a newly allocated container in the ca
 Broadcasting
 ------------
 
-The number of dimensions of an ``xexpression`` and the sizes of these dimensions are provided by the ``shape()`` method, which returns a sequence of unsigned integers
-specifying the size of each dimension. We can operate on expressions of different shapes of dimensions in an elementwise fashion. Broadcasting rules of `xtensor` are
-similar to those of Numpy_ and libdynd_.
+The number of dimensions of an :cpp:type:`xt::xexpression` and the sizes of these dimensions are provided by the :cpp:func:`~xt::xexpression::shape` method, which returns a sequence of unsigned integers
+specifying the size of each dimension. We can operate on expressions of different shapes of dimensions in an elementwise fashion.
+Broadcasting rules of *xtensor* are similar to those of NumPy_ and libdynd_.
 
 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)``.
+For example, if ``A`` has shape ``(2, 3)``, and ``B`` has shape ``(4, 2, 3)``, the result of a broadcast operation with ``A`` and ``B`` has shape ``(4, 2, 3)``.
 
-.. code::
+.. code:: none
 
        (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:
+The same rule holds for scalars, which are handled as 0-D expressions. If ``A`` is a scalar, the equation becomes:
 
-.. code::
+.. code:: none
 
            () # A
     (4, 2, 3) # B
@@ -112,28 +114,62 @@ The same rule holds for scalars, which are handled as 0-D expressions. If `A` is
 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:
 
-.. code::
+.. code:: none
 
        (2, 3) # A
     (4, 2, 1) # B
     ---------
     (4, 2, 3) # Result
 
+Accessing elements
+------------------
+
+You can access the elements of any :cpp:type:`xt::xexpression` with :cpp:func:`~xt::xexpression::operator()()`:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    auto f = 2 * a;
+
+    double d1 = a(0, 2);
+    double d2 = f(1, 2);
+
+It is possible to call :cpp:func:`~xt::xexpression::operator()()` with fewer or more arguments than the number of dimensions
+of the expression:
+
+- if :cpp:func:`~xt::xexpression::operator()()` is called with too many arguments, we drop the most left ones
+- if :cpp:func:`~xt::xexpression::operator()()` is called with too few arguments, we prepend them with ``0`` values until
+  we match the number of dimensions
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+
+    double d1 = a(2); // equivalent to a(0, 2)
+    double d2 = a(1, 1, 2) // equivalent to a(1, 2)
+
+The reason for this is that it is the one rule that ensures ``(a + b)(i0, ..., in) = a(i0, ..., in) + b(i0, ..., in)``,
+i.e. commutativity of element access and broadcasting.
+
 Expression interface
 --------------------
 
-All ``xexpression`` s in `xtensor` provide at least the following interface:
+All :cpp:type:`xt::xexpression` s in :cpp:type:`xt::xtensor` provide at least the following interface:
 
 Shape
 ~~~~~
 
-- ``dimension()`` returns the number of dimension of the expression.
-- ``shape()`` returns the shape of the expression.
+- :cpp:func:`~xt::xexpression::dimension`: returns the number of dimensions of the expression.
+- :cpp:func:`~xt::xexpression::shape`: returns the shape of the expression.
 
 .. code::
 
     #include <vector>
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     using array_type = xt::xarray<double>;
     using shape_type = array_type::shape_type;
@@ -147,15 +183,23 @@ Shape
 Element access
 ~~~~~~~~~~~~~~
 
-- ``operator()`` is an access operator which can take multiple integral arguments or none.
-- ``at()`` is similar to ``operator()`` but checks that its number of arguments does not exceed the number of dimensions, and performs bounds checking. This should not be used where you expect ``operator()`` to perform broadcasting.
-- ``operator[]`` has two overloads: one that takes a single integral argument and is equivalent to the call of ``operator()`` with one argument, and one with a single multi-index argument, which can be of a size determined at runtime. This operator also supports braced initializer arguments.
-- ``element()`` is an access operator which takes a pair of iterators on a container of indices.
+- :cpp:func:`~xt::xexpression::operator()()` is an access operator that can take multiple integral arguments or none.
+- :cpp:func:`~xt::xexpression::at` is similar to :cpp:func:`~xt::xexpression::operator()()` but checks that its number
+  of arguments does not exceed the number of dimensions, and performs bounds checking.
+  This should not be used where you expect :cpp:func:`~xt::xexpression::operator()()` to perform broadcasting.
+- :cpp:func:`~xt::xexpression::operator[]` has two overloads: one that takes a single integral argument and is
+  equivalent to the call of :cpp:func:`~xt::xexpression::operator()()` with one argument, and one with a single
+  multi-index argument, which can be of a size determined at runtime.
+  This operator also supports braced initializer arguments.
+- :cpp:func:`~xt::xexpression::element` is an access operator which takes a pair of iterators on a container of indices.
+- :cpp:func:`~xt::xexpression::periodic` is the equivalent of :cpp:func:`~xt::xexpression::operator()()` that can deal
+  with periodic indices (for example ``-1`` for the last item along an axis).
+- :cpp:func:`~xt::xexpression::in_bounds` returns a ``bool`` that is ``true`` only if indices are valid for the array.
 
 .. code::
 
     #include <vector>
-    #inclde "xtensor/xarray.hpp"
+    #inclde "xtensor/containers/xarray.hpp"
 
     // xt::xarray<double> a = ...
     std::vector<size_t> index = {1, 1, 1};
@@ -167,12 +211,26 @@ Element access
 Iterators
 ~~~~~~~~~
 
-- ``begin()`` and ``end()`` return instances of ``xiterator`` which can be used to iterate over all the elements of the expression. The layout of the iteration can be specified
-  through the ``layout_type`` template parameter, accepted values are ``layout_type::row_major`` and ``layout_type::column_major``. If not specified, ``XTENSOR_DEFAULT_LAYOUT`` is used.
-  This iterator pair permits to use algorithms of the STL with ``xexpression`` as if they were simple containers.
-- ``begin(shape)`` and ``end(shape)`` are similar but take a *broadcasting shape* as an argument. Elements are iterated upon in ``XTENSOR_DEFAULT_LAYOUT`` if no ``layout_type`` template parameter is specified. Certain dimensions are repeated to match the provided shape as per the rules described above.
-- ``rbegin()`` and ``rend()`` return instances of ``xiterator`` which can be used to iterate over all the elements of the reversed expression. As ``begin()`` and ``end()``, the layout of the iteration can be specified through the ``layout_type`` parameter.
-- ``rbegin(shape)`` and ``rend(shape)`` are the reversed counterpart of ``begin(shape)`` and ``end(shape)``.
-
-.. _NumPy: http://www.numpy.org
+- :cpp:func:`~xt::xexpression::begin` and :cpp:func:`~xt::xexpression::end` return instances of :cpp:type:`xt::xiterator`
+  which can be used to iterate over all the elements of the expression.
+  The layout of the iteration can be specified through the :cpp:enum:`xt::layout_type` template parameter, accepted values
+  are :cpp:enumerator:`xt::layout_type::row_major` and :cpp:enumerator:`xt::layout_type::column_major`.
+  If not specified, :c:macro:`XTENSOR_DEFAULT_TRAVERSAL` is used.
+  This iterator pair permits to use algorithms of the STL with :cpp:type:`xt::xexpression` as if they were simple containers.
+- :cpp:func:`begin(shape) <xt::xiterator xt::xexpression::begin(xt::xshape)>` and
+  :cpp:func:`end(shape) <xt::xiterator xt::xexpression::end(xt::xshape)>` are similar but take a *broadcasting shape*
+  as an argument.
+  Elements are iterated upon in :c:macro:`XTENSOR_DEFAULT_TRAVERSAL` if no :cpp:enum:`xt::layout_type` template parameter
+  is specified.
+  Certain dimensions are repeated to match the provided shape as per the rules described above.
+- :cpp:func:`~xt::xexpression::rbegin` and :cpp:func:`~xt::xexpression::rend` return instances of :cpp:type:`xt::xiterator`
+  which can be used to iterate over all the elements of the reversed expression.
+  As :cpp:func:`~xt::xexpression::begin` and :cpp:func:`~xt::xexpression::end`, the layout of the iteration can be
+  specified through the :cpp:enum:`xt::layout_type` parameter.
+- :cpp:func:`rbegin(shape) <xt::xiterator xt::xexpression::rbegin(xt::xshape)>` and
+  :cpp:func:`rend(shape) <xt::xiterator xt::xexpression::rend(xt::xshape)>` are the reversed counterpart of
+  :cpp:func:`begin(shape) <xt::xiterator xt::xexpression::begin(xt::xshape)>` and
+  :cpp:func:`end(shape) <xiterator xt::xexpression::end(xt::xshape)>`.
+
+.. _NumPy: https://numpy.org/
 .. _libdynd: http://libdynd.org
diff --git a/docs/source/external-structures.rst b/docs/source/external-structures.rst
index 4b74ad404..4d82738f2 100644
--- a/docs/source/external-structures.rst
+++ b/docs/source/external-structures.rst
@@ -7,14 +7,14 @@
 Extending xtensor
 =================
 
-``xtensor`` provides means to plug external data structures into its expression engine without
+*xtensor* provides means to plug external data structures into its expression engine without
 copying any data.
 
 Adapting one-dimensional containers
 -----------------------------------
 
 You may want to use your own one-dimensional container as a backend for tensor data containers
-and even for the shape or the strides. This is the simplest structure to plug into ``xtensor``.
+and even for the shape or the strides. This is the simplest structure to plug into *xtensor*.
 In the following example, we define new container and adaptor types for user-specified storage and shape types.
 
 .. code::
@@ -27,7 +27,7 @@ In the following example, we define new container and adaptor types for user-spe
     using my_tensor_type = xt::xtensor_container<container_type, 3>;
     using my_adaptor_type = xt::xtensor_adaptor<container_type, 3>;
 
-These new types will have all the features of the core ``xt::xtensor`` and ``xt::xarray`` types.
+These new types will have all the features of the core :cpp:type:`xt::xtensor` and :cpp:type:`xt::xarray` types.
 ``xt::xarray_container`` and ``xt::xtensor_container`` embed the data container, while
 ``xt::xarray_adaptor`` and ``xt::xtensor_adaptor`` hold a reference on an already initialized
 container.
@@ -39,15 +39,43 @@ A requirement for the user-specified containers is to provide a minimal ``std::v
 - iterator methods (``begin``, ``end``, ``cbegin``, ``cend``)
 - ``size`` and ``reshape``, ``resize`` methods
 
-``xtensor`` does not require that the container has a contiguous memory layout, only that it
+*xtensor* does not require that the container has a contiguous memory layout, only that it
 provides the aforementioned interface. In fact, the container could even be backed by a
 file on the disk, a database or a binary message.
 
+Adapting a pointer
+------------------
+
+Suppose that you want to use the *xtensor* machinery on a small contiguous subset of a large tensor.
+You can, of course, use :ref:`view-description`, but for efficiency you can also use pointers to the right bit of memory.
+Consider an example of an ``[M, 2, 2]`` tensor ``A``,
+for which you want to operate on ``A[i, :, :]`` for different ``i``.
+In this case the most efficient *xtensor* has to offer is:
+
+.. code-block:: cpp
+
+    int main()
+    {
+        size_t M = 3;
+        size_t nd = 2;
+        size_t size = nd * nd;
+        xt::xarray<int> A = xt::arange<int>(M * size).reshape({M, nd, nd});
+        auto b = xt::adapt(&A.flat(0), std::array<size_t, 2>{nd, nd});
+
+        for (size_t i = 0; i < M; ++i) {
+            b.reset_buffer(&A.flat(i * size), size);
+        }
+        return 0;
+    }
+
+where ``xt::adapt`` first creates an ``xt::xtensor_adaptor`` on the memory of ``A[0, :, :]``.
+Then, inside the loop, we only replace the pointer to the relevant ``A[i, 0, 0]``.
+
 Structures that embed shape and strides
 ---------------------------------------
 
 Some structures may gather data container, shape and strides, making them impossible to plug
-into ``xtensor`` with the method above. This section illustrates how to adapt such structures
+into *xtensor* with the method above. This section illustrates how to adapt such structures
 with the following simple example:
 
 .. code::
@@ -71,7 +99,7 @@ with the following simple example:
 Define inner types
 ~~~~~~~~~~~~~~~~~~
 
-The following tells ``xtensor`` which types must be used for getting shape, strides, and data:
+The following tells *xtensor* which types must be used for getting shape, strides, and data:
 
 .. code::
 
@@ -117,13 +145,13 @@ Next step is to inherit from the ``xcontainer`` and the ``xcontainer_semantic``
     };
 
 Thanks to definition of the previous structures, inheriting from ``xcontainer`` brings almost all the container
-API available in the other entities of ``xtensor``, while  inheriting from ``xtensor_semantic`` brings the support
+API available in the other entities of *xtensor*, while  inheriting from ``xtensor_semantic`` brings the support
 for mathematical operations.
 
 Define semantic
 ~~~~~~~~~~~~~~~
 
-``xtensor`` classes have full value semantic, so you may define the constructors specific to your structures,
+*xtensor* classes have full value semantic, so you may define the constructors specific to your structures,
 and use the default copy and move constructors and assign operators. Note these last ones *must* be declared as
 they are declared as ``protected`` in the base class.
 
@@ -133,7 +161,7 @@ they are declared as ``protected`` in the base class.
     class raw_tensor_adaptor : public xcontainer<raw_tensor_adaptor<T>>,
                                public xcontainer_semantic<raw_tensor_adaptor<T>>
     {
-    
+
     public:
 
         using self_type = raw_tensor_adaptor<T>;
@@ -161,7 +189,7 @@ they are declared as ``protected`` in the base class.
             return semantic_base::operator=(e);
         }
     };
-    
+
 The last two methods are extended copy constructor and assign operator. They allow writing things like
 
 .. code::
@@ -169,17 +197,17 @@ The last two methods are extended copy constructor and assign operator. They all
     using tensor_type = raw_tensor_adaptor<double>;
     tensor_type a, b, c;
     // .... init a, b and c
-    tnesor_type d = a + b - c;
+    tensor_type d = a + b - c;
 
 Implement the resize methods
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The next methods to define are the overloads of ``resize``. ``xtensor`` provides utility functions to compute
+The next methods to define are the overloads of ``resize``. *xtensor* provides utility functions to compute
 strides based on the shape and the layout, so the implementation of the ``resize`` overloads is straightforward:
 
 .. code::
 
-    #include "xtensor/xstrides.hpp" // for utility functions
+    #include <xtensor/core/xstrides.hpp> // for utility functions
 
     template <class T>
     void resize(const shape_type& shape)
@@ -271,7 +299,7 @@ The following definitions are required:
 .. code::
 
     template <class T>
-    struct xcontainer_inner_type<table_adaptor<T>>
+    struct xcontainer_inner_types<table_adaptor<T>>
     {
         using temporary_type = xarray<T>;
     };
@@ -299,7 +327,8 @@ and to define a bunch of typedefs.
 
     public:
 
-        using self_type = table<T>;
+        using self_type = table_adaptor<T>;
+        using semantic_base = xcontainer_semantic<self_type>;
 
         using value_type = T;
         using reference = T&;
@@ -314,7 +343,7 @@ and to define a bunch of typedefs.
         using shape_type = inner_shape_type;
         using strides_type = inner_strides_type;
 
-        using iterable_base = xexpression_iterable<self_type>;
+        using iterable_base = xiterable<self_type>;
         using stepper = typename iterable_base::stepper;
         using const_stepper = typename iterable_base::const_stepper;
     };
@@ -353,7 +382,6 @@ constructor and assign operator.
 
         template <class E>
         table_adaptor(const xexpression<E>& e)
-            : base_type()
         {
             semantic_base::assign(e);
         }
@@ -364,11 +392,11 @@ constructor and assign operator.
             return semantic_base::operator=(e);
         }
     };
-    
+
 Implement access operators
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-``xtensor`` requires that the following access operators are defined
+*xtensor* requires that the following access operators are defined
 
 .. code::
 
@@ -436,16 +464,10 @@ This part is relatively straightforward:
     template <class S>
     bool broadcast_shape(const S& s) const
     {
-        // Available in "xtensor/xtrides.hpp"
+        // Available in "xtensor/core/xstrides.hpp"
         return xt::broadcast_shape(shape(), s);
     }
 
-    template <class S>
-    bool is_trivial_broadcast(const S& str) const noexcept
-    {
-        return false;
-    }
-
 Implement resize overloads
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -488,4 +510,3 @@ iterators.
         size_type offset = s.size() - dimension();
         return const_stepper(this, offset, true);
     }
-
diff --git a/docs/source/file_loading.rst b/docs/source/file_loading.rst
index 800c09218..348b12e40 100644
--- a/docs/source/file_loading.rst
+++ b/docs/source/file_loading.rst
@@ -7,19 +7,19 @@
 File input and output
 =====================
 
-``xtensor`` has some builtin mechanisms to make loading and saving data easy.
-The base xtensor package allows to save and load data in the ``.csv``, ``.json`` and ``.npy``
+*xtensor* has some built-in mechanisms to make loading and saving data easy.
+The base *xtensor* package allows to save and load data in the ``.csv``, ``.json`` and ``.npy``
 format.
 Please note that many more input and output formats are available in the `xtensor-io
-<https://github.com/QuantStack/xtensor-io>`_ package.
-``xtensor-io`` offers functions to load and store from image files (``jpg``, ``gif``, ``png``...), 
-sound files (``wav``, ``ogg``...), and compressed numpy format ``npz``.
+<https://github.com/xtensor-stack/xtensor-io>`_ package.
+`xtensor-io` offers functions to load and store from image files (``jpg``, ``gif``, ``png``...),
+sound files (``wav``, ``ogg``...), HDF5 files (``h5``, ``hdf5``, ...), and compressed NumPy format (``npz``).
 
 
 Loading CSV data into xtensor
 -----------------------------
 
-The following example code demonstrates how to use ``load_csv`` and ``dump_csv`` to load and 
+The following example code demonstrates how to use :cpp:func:`xt::load_csv` and :cpp:func:`xt::dump_csv` to load and
 save data in the Comma-separated value format. The reference documentation is :doc:`api/xcsv`.
 
 .. code::
@@ -28,18 +28,18 @@ save data in the Comma-separated value format. The reference documentation is :d
     #include <fstream>
     #include <iostream>
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xcsv.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xcsv.hpp>
 
     int main()
     {
-        ifstream in_file;
+        std::ifstream in_file;
         in_file.open("in.csv");
         auto data = xt::load_csv<double>(in_file);
 
-        ofstream out_file;
+        std::ofstream out_file;
         out_file("out.csv");
-        
+
         xt::xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
         xt::dump_csv(out_file, a);
 
@@ -49,8 +49,8 @@ save data in the Comma-separated value format. The reference documentation is :d
 Loading NPY data into xtensor
 -----------------------------
 
-The following example demonstrates how to load and store xtensor data in the ``npy`` "NumPy" format, 
-using the ``load_npy`` and ``dump_npy`` functions.
+The following example demonstrates how to load and store xtensor data in the ``npy`` "NumPy" format,
+using the :cpp:func:`xt::load_npy` and :cpp:func:`xt::dump_npy` functions.
 Reference documentation for the functions used is found here :doc:`api/xnpy`.
 
 .. code::
@@ -59,8 +59,8 @@ Reference documentation for the functions used is found here :doc:`api/xnpy`.
     #include <iostream>
     #include <fstream>
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xnpy.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xnpy.hpp>
 
     int main()
     {
@@ -77,20 +77,20 @@ Reference documentation for the functions used is found here :doc:`api/xnpy`.
 Loading JSON data into xtensor
 ------------------------------
 
-It's possible to load and dump data to json, using the json library written by 
-``nlohmann`` (https://nlohmann.github.io/json/) which offers a convenient way 
-to handle json data in C++. Note that the library needs to be seperately installed.
+It's possible to load and dump data to json, using the json library written by
+`nlohmann` (https://nlohmann.github.io/json/) which offers a convenient way
+to handle json data in C++. Note that the library needs to be separately installed.
 The reference documentation is found :doc:`api/xjson`.
 
 
 .. code::
 
-    #include "xtensor/xjson.hpp"
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/io/xjson.hpp>
+    #include <xtensor/containers/xarray.hpp>
 
     int main()
     {
-        
+
         xt::xarray<double> t =  {{{1, 2},
                                   {3, 4}},
                                  {{1, 2},
@@ -102,5 +102,5 @@ The reference documentation is found :doc:`api/xjson`.
 
         xt::xarray<double> res;
         auto j = "[[10.0,10.0],[10.0,10.0]]"_json;
-        from_json(j, res);
+        xt::from_json(j, res);
     }
diff --git a/docs/source/getting_started.rst b/docs/source/getting_started.rst
index bce4ba786..45f315f8a 100644
--- a/docs/source/getting_started.rst
+++ b/docs/source/getting_started.rst
@@ -7,7 +7,7 @@
 Getting started
 ===============
 
-This short guide explains how to get started with `xtensor` once you haveve installed it with one of
+This short guide explains how to get started with *xtensor* once you have installed it with one of
 the methods described in the installation section.
 
 First example
@@ -16,9 +16,9 @@ First example
 .. code::
 
     #include <iostream>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xio.hpp"
-    #include "xtensor/xview.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
+    #include <xtensor/views/xview.hpp>
 
     int main(int argc, char* argv[])
     {
@@ -32,7 +32,7 @@ First example
 
         xt::xarray<double> res = xt::view(arr1, 1) + arr2;
 
-        std::cout << res;
+        std::cout << res << std::endl;
 
         return 0;
     }
@@ -43,15 +43,18 @@ array.
 Compiling the first example
 ---------------------------
 
-`xtensor` is a header-only library, so there is no library to link with. The only constraint
-is that the compiler must be able to find the headers of `xtensor`, this is usually done
-by having the diretory containing the headers in the include path. With GCC, use the ``-I`` option
+*xtensor* is a header-only library, so there is no library to link with. The only constraint
+is that the compiler must be able to find the headers of *xtensor* (and *xtl*), this is usually done
+by having the directory containing the headers in the include path. With G++, use the ``-I`` option
 to achieve this. Assuming the first example code is located in ``example.cpp``, the compilation command
 is:
 
 .. code:: bash
 
-    gcc -I /path/to/xtensor/ example.cpp -o example
+    g++ -I /path/to/xtensor/ -I /path/to/xtl/ example.cpp -o example
+
+Note that if you installed *xtensor* and *xtl* with *Cmake*, their headers will be located in the same
+directory, so you will need to provide only one path with the ``-I`` option.
 
 When you run the program, it produces the following output:
 
@@ -62,7 +65,7 @@ When you run the program, it produces the following output:
 Building with cmake
 -------------------
 
-A better alternative for building programs using `xtensor` is to use `cmake`, especially if you are
+A better alternative for building programs using *xtensor* is to use *Cmake*, especially if you are
 developing for several platforms. Assuming the following folder structure:
 
 .. code:: bash
@@ -81,9 +84,37 @@ The following minimal ``CMakeLists.txt`` is enough to build the first example:
 
     find_package(xtl REQUIRED)
     find_package(xtensor REQUIRED)
-    
+
     add_executable(first_example src/example.cpp)
-    target_link_libraries(first_example xtensor)
+
+    if(MSVC)
+        set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
+    endif()
+
+    target_link_libraries(first_example xtensor xtensor::optimize xtensor::use_xsimd)
+
+.. note::
+
+    .. code:: cmake
+
+        target_link_libraries(... xtensor::optimize)
+
+    set the following compiler flags, if supported by the target compiler:
+
+    *   Unix: ``-march=native``;
+    *   Windows: ``/EHsc /MP /bigobj``.
+
+    This may speed-up your code, but renders it hardware dependent.
+
+.. note::
+
+    .. code:: cmake
+
+        target_link_libraries(... xtensor::use_xsimd)
+
+    enables `xsimd <https://github.com/xtensor-stack/xsimd>`_: an optional dependency of xtensor that enables simd acceleration,
+    i.e. executing a same operation on a batch of data in a single CPU instruction.
+    This is well-suited to improve performance when operating on tensors, but renders it hardware dependent.
 
 `cmake` has to know where to find the headers, this is done through the ``CMAKE_INSTALL_PREFIX``
 variable. Note that ``CMAKE_INSTALL_PREFIX`` is usually the path to a folder containing the following
@@ -101,6 +132,8 @@ the first example with cmake and then runs the program:
     make
     ./first_program
 
+See :ref:`build-configuration` for more details about the build options.
+
 Second example: reshape
 -----------------------
 
@@ -109,8 +142,8 @@ This second example initializes a 1-dimensional array and reshapes it in-place:
 .. code::
 
     #include <iostream>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xio.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
 
     int main(int argc, char* argv[])
     {
@@ -131,14 +164,29 @@ When compiled and run, this produces the following output:
      {4, 5, 6},
      {7, 8, 9}}
 
+.. tip::
+
+  To print the shape to the standard output you can use either:
+
+  .. code-block:: cpp
+
+      const auto& s = arr.shape();
+      std::copy(s.cbegin(), s.cend(), std::ostream_iterator<double>(std::cout, " "));
+
+  Or:
+
+  .. code-block:: cpp
+
+      std::cout << xt::adapt(arr.shape()); // with: #include <xtensor/containers/xadapt.hpp>
+
 Third example: index access
 ---------------------------
 
 .. code::
 
     #include <iostream>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xio.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
 
     int main(int argc, char* argv[])
     {
@@ -146,7 +194,7 @@ Third example: index access
           {{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<int> arr2
@@ -162,18 +210,18 @@ Outputs:
 
     1.0
     1
-     
+
 Fourth example: broadcasting
 ----------------------------
 
-This last example shows how to broadcast the ``xt::pow`` universal function:
+This last example shows how to broadcast the :cpp:func:`xt::pow` universal function:
 
 .. code::
 
     #include <iostream>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xmath.hpp"
-    #include "xtensor/xio.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/core/xmath.hpp>
+    #include <xtensor/io/xio.hpp>
 
     int main(int argc, char* argv[])
     {
@@ -199,4 +247,3 @@ Outputs:
      {1, 32, 243},
      {1, 64, 729},
      {1, 128, 2187}}
-
diff --git a/docs/source/histogram.rst b/docs/source/histogram.rst
index 42cdf9db1..f1e37c94c 100644
--- a/docs/source/histogram.rst
+++ b/docs/source/histogram.rst
@@ -4,35 +4,35 @@
 
    The full license is in the file LICENSE, distributed with this software.
 
+.. _histogram:
+
 Histogram
 =========
 
 Basic usage
 -----------
 
-.. note::
-
-    .. code-block:: cpp
-
-        xt::histogram(a, bins[, weights][, density])
-        xt::histogram_bin_edges(a, bins[, weights][, left, right][, bins][, mode])
+* :cpp:func:`xt::histogram(a, bins[, weights][, density]) <xt::histogram>`
+* :cpp:func:`xt::histogram_bin_edges(a[, weights][, left, right][, bins][, mode]) <xt::histogram_bin_edges>`
 
+.. note::
     Any of the options ``[...]`` can be omitted (though the order must be preserved). The defaults are:
 
-    *   ``weights = xt::ones(data.shape())``
-    *   ``density = false``
-    *   ``left = xt::amin(data)(0)``
-    *   ``right = xt::amax(data)(0)``
-    *   ``bins = 10``
-    *   ``mode = xt::histogram::automatic``
+    *   ``weights`` = :cpp:func:`xt::ones(data.shape()) <xt::ones>`
+    *   ``density`` = ``false``
+    *   ``left`` = :cpp:func:`xt::amin(data)(0) <xt::amin>`
+    *   ``right`` = :cpp:func:`Xt::amax(data)(0) <xt::amax>`
+    *   ``bins`` = ``10``
+    *   ``mode`` = :cpp:enumerator:`xt::histogram::automatic`
 
-The behavior, in-, and output of ``histogram`` is similar to that of `numpy.histogram <https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html>`_ with that difference that the bin-edges are obtained by a separate function call:
+The behavior, in-, and output of :cpp:func:`xt::histogram` is similar to that of :any:`numpy.histogram`
+with that difference that the bin-edges are obtained by a separate function call:
 
 .. code-block:: cpp
 
-    #include <xtensor/xtensor.hpp>
-    #include <xtensor/xhistogram.hpp>
-    #include <xtensor/xio.hpp>
+    #include <xtensor/containers/xtensor.hpp>
+    #include <xtensor/misc/xhistogram.hpp>
+    #include <xtensor/io/xio.hpp>
 
     int main()
     {
@@ -48,13 +48,14 @@ The behavior, in-, and output of ``histogram`` is similar to that of `numpy.hist
 Bin-edges algorithm
 -------------------
 
-To customize the algorithm to be used to construct the histogram, one needs to make use of the latter ``histogram_bin_edges``. For example:
+To customize the algorithm to be used to construct the histogram, one needs to make use of the latter
+:cpp:func:`xt::histogram_bin_edges`. For example:
 
 .. code-block:: cpp
 
-    #include <xtensor/xtensor.hpp>
-    #include <xtensor/xhistogram.hpp>
-    #include <xtensor/xio.hpp>
+    #include <xtensor/containers/xtensor.hpp>
+    #include <xtensor/misc/xhistogram.hpp>
+    #include <xtensor/io/xio.hpp>
 
     int main()
     {
@@ -70,12 +71,10 @@ To customize the algorithm to be used to construct the histogram, one needs to m
         return 0;
     }
 
-The following algorithms are available:
-
-*   ``automatic``: equivalent to ``linspace``.
-
-*   ``linspace``: linearly spaced bin-edges.
-
-*   ``logspace``: bins that logarithmically increase in size.
+The following :cpp:enum:`xt::histogram_algorithm` are available:
 
-*   ``uniform``: bin-edges such that the number of data-points is the same in all bins (as much as possible).
+* :cpp:enumerator:`~xt::histogram_algorithm::automatic`: equivalent to :cpp:enumerator:`~xt::histogram_algorithm::linspace`.
+* :cpp:enumerator:`~xt::histogram_algorithm::linspace`: linearly spaced bin-edges.
+* :cpp:enumerator:`~xt::histogram_algorithm::logspace`: bins that logarithmically increase in size.
+* :cpp:enumerator:`~xt::histogram_algorithm::uniform`: bin-edges such that the number of data points is
+  the same in all bins (as much as possible).
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 922a00886..d28e135ea 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -12,25 +12,25 @@ Multi-dimensional arrays with broadcasting and lazy computing.
 Introduction
 ------------
 
-`xtensor` is a C++ library meant for numerical analysis with multi-dimensional
+*xtensor* is a C++ library meant for numerical analysis with multi-dimensional
 array expressions.
 
-`xtensor` provides
+*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`.
+- tools to manipulate array expressions and build upon *xtensor*.
 
-Containers of `xtensor` are inspired by `NumPy`_, the Python array programming
+Containers of *xtensor* are inspired by `NumPy`_, the Python array programming
 library. **Adaptors** for existing data structures to be plugged into the
 expression system can easily be written.
 
-In fact, `xtensor` can be used to **process numpy data structures in-place**
-using Python's `buffer protocol`_. For more details on the numpy bindings,
+In fact, *xtensor* can be used to **process NumPy data structures in-place**
+using Python's `buffer protocol`_. For more details on the NumPy bindings,
 check out the xtensor-python_ project. Language bindings for R and Julia are
 also available.
 
-`xtensor` requires a modern C++ compiler supporting C++14. The following C++
+*xtensor* requires a modern C++ compiler supporting C++14. The following C++
 compilers are supported:
 
 - On Windows platforms, Visual C++ 2015 Update 2, or more recent
@@ -63,11 +63,30 @@ for details.
    scalar
    adaptor
    operator
-   histogram
    view
+   indices
    builder
    missing
+   histogram
+   random
+   rank
    file_loading
+   build-options
+   pitfall
+
+.. toctree::
+   :caption: QUICK REFERENCE
+   :maxdepth: 2
+
+   quickref/basic
+   quickref/builder
+   quickref/operator
+   quickref/math
+   quickref/reducer
+   view
+   quickref/iterator
+   quickref/manipulation
+   quickref/chunked_arrays
 
 .. toctree::
    :caption: API REFERENCE
@@ -75,16 +94,18 @@ for details.
 
    api/expression_index
    api/container_index
+   api/iterator_index
    api/function_index
    api/io_index
    api/xmath
+   api/shape
 
 .. toctree::
    :caption: DEVELOPER ZONE
    :maxdepth: 2
 
    compilers
-   build-options
+   dev-build-options
    developer/xtensor_internals
    external-structures
    releasing
@@ -96,8 +117,9 @@ for details.
    numpy-differences
    closure-semantics
    related
+   bindings
 
-.. _NumPy: http://www.numpy.org
+.. _NumPy: https://numpy.org/
 .. _Buffer Protocol: https://docs.python.org/3/c-api/buffer.html
 .. _libdynd: http://libdynd.org
-.. _xtensor-python: https://github.com/QuantStack/xtensor-python
+.. _xtensor-python: https://github.com/xtensor-stack/xtensor-python
diff --git a/docs/source/indices.rst b/docs/source/indices.rst
new file mode 100644
index 000000000..e32fce8c7
--- /dev/null
+++ b/docs/source/indices.rst
@@ -0,0 +1,289 @@
+.. 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.
+
+Indices
+=======
+
+Definition
+----------
+
+There are two types of indices: *array indices* and *flat indices*. Consider this example (stored in row-major):
+
+.. code-block:: cpp
+
+    #include <xtensor/containers/xtensor.hpp>
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    int main()
+    {
+        xt::xarray<size_t> a = xt::arange<size_t>(3 * 4);
+
+        a.reshape({3,4});
+
+        std::cout << a << std::endl;
+    }
+
+Which prints
+
+.. code-block:: none
+
+    {{ 0,  1,  2,  3},
+     { 4,  5,  6,  7},
+     { 8,  9, 10, 11}}
+
+The *array index* ``{1, 2}`` corresponds to the *flat index* ``6``.
+
+Operators: array index
+------------------------
+
+An *array index* can be specified to an operators by a sequence of numbers.
+To this end the following operators are at your disposal:
+
+:cpp:func:`operator()(args...) <xt::xcontainer::operator>`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*   Example: ``a(1, 2) == 6``.
+*   See also: :cpp:func:`xt::xcontainer::operator()`.
+
+Returns a (constant) reference to the element,
+specified by an *array index* given by a number of unsigned integers.
+
+*   If the number of indices is less that the dimension of the array,
+    the indices are pre-padded with zeros until the dimension is matched
+    (example: ``a(2) == a(0, 2) == 2``).
+
+*   If the number of indices is greater than the dimension of the array,
+    the first ``#indices - dimension`` indices are ignored.
+
+*   To post-pad an arbitrary number of zeros use ``xt::missing``
+    (example ``a(2, xt::missing) == a(2, 0) == 8``.
+
+:cpp:func:`at(args...) <xt::xcontainer::at>`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*   Example: ``a.at(1, 2) == 6``.
+*   See also: :cpp:func:`xt::xcontainer::at`.
+
+Same as :cpp:func:`~xt::xcontainer::operator()`:
+Returns a (constant) reference to the element,
+specified by an *array index* given by a number of unsigned integers.
+
+:cpp:func:`unchecked(args...) <xt::xcontainer::unchecked>`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*   Example: ``a.unchecked(1, 2) == 6``.
+*   See also: :cpp:func:`xt::xcontainer::unchecked`.
+
+Returns a (constant) reference to the element,
+specified by an *array index* given by a number of unsigned integers.
+Different than :cpp:func:`~xt::xcontainer::operator()` there are no bounds checks (even when assertions)
+are turned on, and the number of indices is assumed to match the dimension of the array.
+:cpp:func:`~xt::xcontainer::unchecked` is thus aimed at performance.
+
+.. note::
+
+    If you assume responsibility for bounds-checking, this operator can be used to virtually
+    post-pad zeros if you specify less indices than the rank of the array.
+    Example: ``a.unchecked(1) == a(1, 0)``.
+
+:cpp:func:`periodic(args...) <xt::xcontainer::periodic>`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*   Example: ``a.periodic(-1, -2) == 7``.
+*   See also: :cpp:func:`xt::xcontainer::periodic`.
+
+Returns a (constant) reference to the element,
+specified by an *array index* given by a number of signed integers.
+Negative and 'overflowing' indices are changed by assuming periodicity along that axis.
+For example, for the first axis: ``-1 -> a.shape(0) - 1 = 2``,
+likewise for example ``3 -> 3 - a.shape(0) = 0``.
+Of course this comes as the cost of some extra complexity.
+
+:cpp:func:`in_bounds(args...) <xt::xcontainer::in_bounds>`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*   Example: ``a.in_bounds(1, 2) == true``.
+*   See also: :cpp:func:`xt::xcontainer::in_bounds`.
+
+Check if the *array index* is 'in bounds', return ``false`` otherwise.
+
+:cpp:func:`operator[]({...}) <xt::xcontainer::operator[]>`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*   Example: ``a[{1, 2}] == 6``.
+*   See also: :cpp:func:`xt::xcontainer::operator[]`.
+
+Returns a (constant) reference to the element,
+specified by an *array index* given by a list of unsigned integers.
+
+Operators: flat index
+---------------------
+
+:cpp:func:`flat(i) <xt::xcontainer::flat>`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+*   Example: ``a.flat(6) == 6``.
+*   See also: :cpp:func:`xt::xcontainer::flat`.
+
+Returns a (constant) reference to the element specified by a *flat index*,
+given an unsigned integer.
+
+.. note::
+
+    If the layout would not have been the default *row major*,
+    but *column major*, then ``a.flat(6) == 2``.
+
+.. note::
+
+    In many cases ``a.flat(i) == a.data()[i]``.
+
+Array indices
+-------------
+
+Functions like :cpp:func:`xt::argwhere(a \< 5) <xt::argwhere>` return a ``std::vector`` of *array indices*.
+Using the same matrix as above, we can do
+
+.. code-block:: cpp
+
+    int main()
+    {
+        xt::xarray<size_t> a = xt::arange<size_t>(3 * 4);
+
+        a.reshape({3,4});
+
+        auto idx = xt::from_indices(xt::argwhere(a >= 6));
+
+        std::cout << idx << std::endl;
+    }
+
+which prints
+
+.. code-block:: none
+
+    {{1, 2},
+     {1, 3},
+     {2, 0},
+     {2, 1},
+     {2, 2},
+     {2, 3}}
+
+To print the ``std::vector``, it is converted to a :cpp:type:`xt::xtensor\<size_t, 2\> <xt::xtensor>`
+array, which is done using :cpp:func:`xt::from_indices`.
+
+From array indices to flat indices
+----------------------------------
+
+To convert the array indices to a :cpp:type:`xt::xtensor\<size_t, 1\> <xt::xtensor>` of flat indices,
+:cpp:func:`xt::ravel_indices` can be used.
+For the same example:
+
+.. code-block:: cpp
+
+    #include <xtensor/containers/xtensor.hpp>
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    int main()
+    {
+        xt::xarray<size_t> a = xt::arange<size_t>(3 * 4);
+
+        a.reshape({3,4});
+
+        auto idx = xt::ravel_indices(xt::argwhere(a >= 6), a.shape());
+
+        std::cout << idx << std::endl;
+    }
+
+which prints
+
+.. code-block:: none
+
+    { 6,  7,  8,  9, 10, 11}
+
+.. note::
+
+    To convert to a ``std::vector`` use
+
+    .. code-block:: cpp
+
+        auto idx = xt::ravel_indices<xt::ravel_vector_tag>(xt::argwhere(a >= 6), a.shape());
+
+1-D arrays: array indices == flat indices
+-----------------------------------------
+
+For 1-D arrays the array indices and flat indices coincide.
+One can use the generic functions :cpp:func:`xt::flatten_indices` to get a
+:cpp:type:`xt::xtensor\<size_t, 1\> <xt::xtensor>` of (array/flat) indices.
+For example:
+
+.. code-block:: cpp
+
+    #include <xtensor/containers/xtensor.hpp>
+    #include <xtensor/views/xview.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    int main()
+    {
+        xt::xtensor<size_t, 1> a = xt::arange<size_t>(16);
+
+        auto idx = xt::flatten_indices(xt::argwhere(a >= 6));
+
+        std::cout << idx << std::endl;
+
+        std::cout << xt::view(a, xt::keep(idx)) << std::endl;
+    }
+
+which prints the indices and the selection (which are in this case identical):
+
+.. code-block:: none
+
+    { 6,  7,  8,  9, 10, 11, 12, 13, 14, 15}
+    { 6,  7,  8,  9, 10, 11, 12, 13, 14, 15}
+
+From flat indices to array indices
+----------------------------------
+
+To convert *flat indices* to *array_indices* the function :cpp:func:`xt::unravel_indices` can be used.
+For example
+
+.. code-block:: cpp
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/containers/xtensor.hpp>
+    #include <xtensor/core/xstrides.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    int main()
+    {
+        xt::xarray<size_t> a = xt::arange<size_t>(3 * 4);
+
+        a.reshape({3,4});
+
+        auto flat_indices = xt::ravel_indices(xt::argwhere(a >= 6), a.shape());
+
+        auto array_indices = xt::from_indices(xt::unravel_indices(flat_indices, a.shape()));
+
+        std::cout << "flat_indices = " << std::endl << flat_indices << std::endl;
+        std::cout << "array_indices = " << std::endl << array_indices << std::endl;
+    }
+
+which prints
+
+.. code-block:: none
+
+    flat_indices =
+    { 6,  7,  8,  9, 10, 11}
+    array_indices =
+    {{1, 2},
+     {1, 3},
+     {2, 0},
+     {2, 1},
+     {2, 2},
+     {2, 3}}
+
+Notice that once again the function :cpp:func:`xt::from_indices` has been used to convert a
+``std::vector`` of indices to a :cpp:type:`xt::xtensor` array for printing.
diff --git a/docs/source/installation.rst b/docs/source/installation.rst
index c149ca28d..bc0bdb7ca 100644
--- a/docs/source/installation.rst
+++ b/docs/source/installation.rst
@@ -21,7 +21,7 @@
 Installation
 ============
 
-Although ``xtensor`` is a header-only library, we provide standardized means to
+Although *xtensor* is a header-only library, we provide standardized means to
 install it, with package managers or with cmake.
 
 Besides the xtensor headers, all these methods place the ``cmake`` project
@@ -30,14 +30,14 @@ cmake's ``find_package`` to locate xtensor headers.
 
 .. image:: conda.svg
 
-Using the conda package
------------------------
+Using the conda-forge package
+-----------------------------
 
-A package for xtensor is available on the conda package manager.
+A package for xtensor is available on the mamba (or conda) package manager.
 
 .. code::
 
-    conda install -c conda-forge xtensor
+    mamba install -c conda-forge xtensor
 
 .. image:: debian.svg
 
@@ -67,7 +67,7 @@ A package for xtensor is available on the Spack package manager.
 From source with cmake
 ----------------------
 
-You can also install ``xtensor`` from source with cmake. This requires that you
+You can also install *xtensor* from source with cmake. This requires that you
 have the xtl_ library installed on your system. On Unix platforms, from the
 source directory:
 
@@ -89,16 +89,26 @@ On Windows platforms, from the source directory:
     nmake install
 
 ``path_to_prefix`` is the absolute path to the folder where cmake searches for
-dependencies and installs libraries. ``xtensor`` installation from cmake assumes
+dependencies and installs libraries. *xtensor* installation from cmake assumes
 this folder contains ``include`` and ``lib`` subfolders.
 
 See the :doc:`build-options` section for more details about cmake options.
 
+Although not officially supported, *xtensor* can be installed with MinGW:
+
+.. code::
+
+    mkdir build
+    cd build
+    cmake -G "MinGW Makefiles" -DCMAKE_INSTALL_PREFIX=path_to_prefix ..
+    mingw32-make
+    mingw32-make install
+
 Including xtensor in your project
 ---------------------------------
 
-The different packages of ``xtensor`` are built with cmake, so whatever the
-installation mode you choose, you can add ``xtensor`` to your project using cmake:
+The different packages of *xtensor* are built with cmake, so whatever the
+installation mode you choose, you can add *xtensor* to your project using cmake:
 
 .. code::
 
@@ -106,4 +116,4 @@ installation mode you choose, you can add ``xtensor`` to your project using cmak
     target_include_directories(your_target PUBLIC ${xtensor_INCLUDE_DIRS})
     target_link_libraries(your_target PUBLIC xtensor)
 
-.. _xtl: https://github.com/QuantStack/xtl
+.. _xtl: https://github.com/xtensor-stack/xtl
diff --git a/docs/source/missing.rst b/docs/source/missing.rst
index ffb15ab0a..80cba080c 100644
--- a/docs/source/missing.rst
+++ b/docs/source/missing.rst
@@ -7,17 +7,18 @@
 Missing values
 ==============
 
-``xtensor`` handles missing values and comprises specialized container types for an optimized support of missing values.
+*xtensor* handles missing values and provides specialized container types for an optimized support of missing values.
 
 Optional expressions
 --------------------
 
-Support of missing values in xtensor is primarily provided through the ``xoptional`` value type and the ``xtensor_optional`` and
-``xarray_optional`` containers. In the following example, we instantiate a 2-D tensor with a missing value:
+Support of missing values in xtensor is primarily provided through the :cpp:type:`xtl::xoptional`
+value type and the :cpp:type:`xt::xtensor_optional` and :cpp:type:`xt::xarray_optional` containers.
+In the following example, we instantiate a 2-D tensor with a missing value:
 
 .. code:: cpp
 
-    xtensor_optional<double, 2> m
+    xt::xtensor_optional<double, 2> m
         {{ 1.0 ,       2.0         },
          { 3.0 , missing<double>() }};
 
@@ -25,16 +26,19 @@ This code is semantically equivalent to
 
 .. code:: cpp
 
-    xtensor<xoptional<double>, 2> m
+    xt::xtensor<xtl::xoptional<double>, 2> m
         {{ 1.0 ,       2.0         },
          { 3.0 , missing<double>() }};
 
-The ``xtensor_optional`` container is optimized to handle missing values. Internally, instead of holding a single container
-of optional values, it holds an array of ``double`` and a boolean container where each value occupies a single bit instead of ``sizeof(bool)``
-bytes.
+The :cpp:type:`xt::xtensor_optional` container is optimized to handle missing values.
+Internally, instead of holding a single container of optional values, it holds an array of ``double``
+and a boolean container where each value occupies a single bit instead of ``sizeof(bool)`` bytes.
 
-The ``xtensor_optional::reference`` typedef, which is the return type of ``operator()`` is a reference proxy which can be used as an
-lvalue for assigning new values in the array. It happens to be an instance of ``xoptional<T, B>`` where ``T`` and ``B`` are actually the reference types of the underlying storage for values and boolean flags.
+The :cpp:type:`xt::xtensor_optional::reference` typedef, which is the return type of
+:cpp:func:`~xt::xexpression::operator()` is a reference proxy which can be used as an
+lvalue for assigning new values in the array.
+It happens to be an instance of :cpp:type:`xtl::xoptional\<T, B\> <xtl::optional>` where ``T`` and
+``B`` are actually the reference types of the underlying storage for values and boolean flags.
 
 This technique enables performance improvements in mathematical operations over boolean arrays including SIMD optimizations, and
 reduces the memory footprint of optional arrays. It should be transparent to the user.
@@ -47,14 +51,14 @@ same way as regular scalars.
 
 .. code:: cpp
 
-    xtensor_optional<double, 2> a
+    xt::xtensor_optional<double, 2> a
         {{ 1.0 ,       2.0         },
          { 3.0 , missing<double>() }};
 
-    xtensor<double, 1> b
+    xt::xtensor<double, 1> b
         { 1.0, 2.0 };
 
-    // `b` is broadcasted to match the shape of `a`
+    // ``b`` is broadcasted to match the shape of ``a``
     std::cout << a + b << std::endl;
 
 outputs:
@@ -67,24 +71,25 @@ outputs:
 Optional assemblies
 -------------------
 
-The classes ``xoptional_assembly`` and ``xoptional_assembly_adaptor`` provide containers and adaptors holding missing values that are optimized
-for element-wise operations.
-Contrary to ``xtensor_optional`` and ``xarray_optional``, the optional assemblies hold two expressions, one holding the values, the other holding
-the mask for the missing values. The difference between ``xoptional_assembly`` and ``xoptional_assembly_adaptor`` is that the first one is the owner
-of the two expressions while the last one holds a reference on at least one of the two expressions.
+The classes :cpp:type:`xt::xoptional_assembly` and :cpp:type:`xt::xoptional_assembly_adaptor` provide
+containers and adaptors holding missing values that are optimized for element-wise operations.
+Contrary to :cpp:type:`xt::xtensor_optional` and :cpp:type:`xt::xarray_optional`, the optional
+assemblies hold two expressions, one holding the values, the other holding the mask for the missing values.
+The difference between :cpp:type:`xt::xoptional_assembly` and :cpp:type:`xt::xoptional_assembly_adaptor`
+is that the first one is the owner of the two expressions while the last one holds a reference on at least
+one of the two expressions.
 
 .. code:: cpp
 
-    xarray<double> v
+    xt::xarray<double> v
         {{ 1.0, 2.0 },
          { 3.0, 4.0 }};
 
-    xarray<bool> hv
+    xt::xarray<bool> hv
         {{ true, true  },
          { true, false }};
 
-    xoptional_assembly<xarray<double>, xarray<bool>>
-    assembly(v, vh);
+    xt::xoptional_assembly<xt::xarray<double>, xt::xarray<bool>> assembly(v, hv);
     std::cout << assembly << std::endl;
 
 outputs:
@@ -97,16 +102,19 @@ outputs:
 Handling expressions with missing values
 ----------------------------------------
 
-Functions ``has_value(E&& e)`` and ``value(E&& e)`` return expressions corresponding to the underlying value and flag of optional elements. When ``e`` is an lvalue, ``value(E&& e)`` and ``has_value(E&& e)`` are lvalues too.
+Functions :cpp:func:`xt::has_value(E&& e) <xt::has_value>` and :cpp:func:`xt::value(E&& e) <xt::value>`
+return expressions corresponding to the underlying value and flag of optional elements.
+When ``e`` is an lvalue, :cpp:func:`xt::has_value(E&& e) <xt::has_value>` and
+:cpp:func:`xt::value(E&& e) <xt::value>` are lvalues too.
 
 .. code:: cpp
 
-    xtensor_optional<double, 2> a
+    xt::xtensor_optional<double, 2> a
         {{ 1.0 ,       2.0         },
          { 3.0 , missing<double>() }};
 
 
-    xtensor<bool, 2> b = has_value(a);
+    xt::xtensor<bool, 2> b = xt::has_value(a);
 
     std::cout << b << std::endl;
 
diff --git a/docs/source/numpy-differences.rst b/docs/source/numpy-differences.rst
index 12371ffda..03968685e 100644
--- a/docs/source/numpy-differences.rst
+++ b/docs/source/numpy-differences.rst
@@ -12,25 +12,42 @@ Notable differences with numpy
    :align: right
 
 xtensor and numpy are very different libraries in their internal semantics. While xtensor
-is a lazy expression system, Numpy manipulates in-memory containers, however, similarities in
+is a lazy expression system, numpy manipulates in-memory containers, however, similarities in
 APIs are obvious. See e.g. the numpy to xtensor cheat sheet.
 
-And this page tracks the subtle differences of behavior between numpy and xtensor.
+And this page tracks the subtle differences of behavior between NumPy and xtensor.
 
 Zero-dimensional arrays
 -----------------------
 
-With numpy, 0-D arrays are nearly indistinguishable from scalars. This led to some issues w.r.t.
+With NumPy, 0-D arrays are nearly indistinguishable from scalars. This led to some issues w.r.t.
 universal functions returning scalars with 0-D array inputs instead of actual arrays...
 
-In xtensor, 0-D expressions are not implicitely convertible to scalar values. Values held by 0-D
+In xtensor, 0-D expressions are not implicitly convertible to scalar values. Values held by 0-D
 expressions can be accessed in the same way as values of higher dimensional arrays, that is with
 ``operator[]``, ``operator()`` and ``element``.
 
+Accumulators (``cumsum``, ``cumprod``) throw an exception if an axis argument is passed and the
+array argument is a 0-D argument:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    xt::xarray<double> x = 1;
+    std::cout << xt::cumsum(x, 0) << std::endl;
+    // Outputs:
+    // Standard Exception: Axis larger than expression dimension in accumulator.
+
+    std::cout << xt::cumsum(x) << std::endl;
+    //Outputs:
+    // 1
+
 Meshgrid
 --------
 
-Numpy's version of meshgrid supports two modes: the 'xy' indexing and the 'ij' indexing.
+:any:`numpy.meshgrid` supports two modes: the 'xy' indexing and the 'ij' indexing.
 
 The following code
 
@@ -47,7 +64,7 @@ The following code
     print 'xy:', [m.shape for m in xy]
 
 
-would return 
+would return
 
 .. code-block:: python
 
@@ -70,7 +87,7 @@ be assigned to a container such as xarray or xtensor.
 Missing values
 --------------
 
-Support of missing values in numpy can be emulated with the masked array module,
+Support of missing values in NumPy can be emulated with the masked array module,
 which provides a means to handle arrays that have missing or invalid data.
 
 Support of missing values in xtensor is done through a notion of optional values, implemented in ``xoptional<T, B>``, which serves both as a value type for container and as a reference proxy for optimized storage types. See the section of the documentation on :doc:`missing`.
@@ -78,5 +95,24 @@ Support of missing values in xtensor is done through a notion of optional values
 Strides
 -------
 
-Strided containers of xtensor and numpy having the same exact memory layout may have different strides when accessing them through the ``strides`` attribute.
+Strided containers of xtensor and NumPy having the same exact memory layout may have different strides when accessing them through the ``strides`` attribute.
 The reason is an optimization in xtensor, which is to set the strides to ``0`` in dimensions of length ``1``, which simplifies the implementation of broadcasting of universal functions.
+
+.. tip::
+
+    Use the free function ``xt::strides`` to switch between representations.
+
+    .. code-block:: cpp
+
+        xt::strides(a); // strides of ``a`` corresponding to storage
+        xt::strides(a, xt::stride_type::normal); // same
+
+        xt::strides(a, xt::stride_type::internal); // ``== a.strides()``
+
+        xt::strides(a, xt::stride_type::bytes) // strides in bytes, as in NumPy
+
+
+Array indices
+-------------
+
+Array indices are in xtensor stored as a ``std::vector`` of array indices, whereby each entry corresponds to the array indices of one item. This results in a slightly different usage of ``xt::ravel_indices`` than of :any:`numpy.ravel_multi_index`.
diff --git a/docs/source/numpy.rst b/docs/source/numpy.rst
index e4f5d21fb..814f3ec6d 100644
--- a/docs/source/numpy.rst
+++ b/docs/source/numpy.rst
@@ -4,7 +4,7 @@
 
    The full license is in the file LICENSE, distributed with this software.
 
-From numpy to xtensor
+From NumPy to xtensor
 =====================
 
 .. image:: numpy.svg
@@ -51,6 +51,10 @@ From numpy to xtensor
        border-left: none;
    }
 
+   .rst-content table.docutils td > p {
+       overflow: auto;
+   }
+
    .rst-content table.docutils tr:hover {
        background-color: #d0e0e0;
    }
@@ -79,19 +83,22 @@ From numpy to xtensor
 Containers
 ----------
 
-Two container types are provided. ``xarray`` (dynamic number of dimensions) and ``xtensor``
-(static number of dimensions).
+Two container types are provided. :cpp:type:`xt::xarray` (dynamic number of dimensions)
+and :cpp:type:`xt::xtensor` (static number of dimensions).
+
+.. table::
+   :widths: 50 50
 
-+------------------------------------------------+------------------------------------------------+
-|             Python 3 - numpy                   |               C++ 14 - xtensor                 |
-+================================================+================================================+
-| ``np.array([[3, 4], [5, 6]])``                 | | ``xt::xarray<double>({{3, 4}, {5, 6}})``     |
-|                                                | | ``xt::xtensor<double, 2>({{3, 4}, {5, 6}})`` |
-+------------------------------------------------+------------------------------------------------+
-| ``arr.reshape([3, 4])``                        | ``arr.reshape({3, 4})``                        |
-+------------------------------------------------+------------------------------------------------+
-| ``arr.astype(np.float64)``                     | ``xt::cast<double>(arr)``                      |
-+------------------------------------------------+------------------------------------------------+
+   +------------------------------------------------------+------------------------------------------------------------------------+
+   |             Python 3 - NumPy                         |               C++ 14 - xtensor                                         |
+   +======================================================+========================================================================+
+   | :any:`np.array([[3, 4], [5, 6]]) <numpy.array>`      || :cpp:type:`xt::xarray\<double\>({{3, 4}, {5, 6}}) <xt::xarray>`       |
+   |                                                      || :cpp:type:`xt::xtensor\<double, 2\>({{3, 4}, {5, 6}}) <xt::xtensor>`  |
+   +------------------------------------------------------+------------------------------------------------------------------------+
+   | :any:`arr.reshape([3, 4]) <numpy.ndarray.reshape>`   | :cpp:func:`arr.reshape({3, 4}) <xt::xstrided_container::reshape>`      |
+   +------------------------------------------------------+------------------------------------------------------------------------+
+   | :any:`arr.astype(np.float64) <numpy.ndarray.astype>` | :cpp:func:`xt::cast\<double\>(arr) <xt::cast>`                         |
+   +------------------------------------------------------+------------------------------------------------------------------------+
 
 Initializers
 ------------
@@ -100,27 +107,60 @@ Lazy helper functions return tensor expressions. Return types don't hold any val
 evaluated upon access or assignment. They can be assigned to a container or directly used in
 expressions.
 
-+-----------------------------------------------+-----------------------------------------------+
-|             Python 3 - numpy                  |               C++ 14 - xtensor                |
-+===============================================+===============================================+
-| ``np.linspace(1.0, 10.0, 100)``               | ``xt::linspace<double>(1.0, 10.0, 100)``      |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.logspace(2.0, 3.0, 4)``                  | ``xt::logspace<double>(2.0, 3.0, 4)``         |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.arange(3, 7)``                           | ``xt::arange(3, 7)``                          |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.eye(4)``                                 | ``xt::eye(4)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.zeros([3, 4])``                          | ``xt::zeros<double>({3, 4})``                 |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.ones([3, 4])``                           | ``xt::ones<double>({3, 4})``                  |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.empty([3, 4])``                          | ``xt::empty<double>({3, 4})``                 |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.meshgrid(x0, x1, x2, indexing='ij')``    | ``xt::meshgrid(x0, x1, x2)``                  |
-+-----------------------------------------------+-----------------------------------------------+
-
-xtensor's ``meshgrid`` implementation corresponds to numpy's ``'ij'`` indexing order.
+.. table::
+   :widths: 50 50
+
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   |             Python 3 - NumPy                                   |               C++ 14 - xtensor                                    |
+   +================================================================+===================================================================+
+   | :any:`np.linspace(1.0, 10.0, 100) <numpy.linspace>`            | :cpp:func:`xt::linspace\<double\>(1.0, 10.0, 100) <xt::linspace>` |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   | :any:`np.logspace(2.0, 3.0, 4) <numpy.logspace>`               | :cpp:func:`xt::logspace\<double\>(2.0, 3.0, 4) <xt::logspace>`    |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   | :any:`np.arange(3, 7) <numpy.arange>`                          | :cpp:func:`xt::arange(3, 7) <xt::arange>`                         |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   | :any:`np.eye(4) <numpy.eye>`                                   | :cpp:func:`xt::eye(4) <xt::eye>`                                  |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   | :any:`np.zeros([3, 4]) <numpy.zeros>`                          | :cpp:func:`xt::zeros\<double\>({3, 4}) <xt::zeros>`               |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   | :any:`np.ones([3, 4]) <numpy.ones>`                            | :cpp:func:`xt::ones\<double\>({3, 4}) <xt::ones>`                 |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   | :any:`np.empty([3, 4]) <numpy.empty>`                          | :cpp:func:`xt::empty\<double\>({3, 4}) <xt::empty>`               |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+   | :any:`np.meshgrid(x0, x1, x2, indexing='ij') <numpy.meshgrid>` | :cpp:func:`xt::meshgrid(x0, x1, x2) <xt::meshgrid>`               |
+   +----------------------------------------------------------------+-------------------------------------------------------------------+
+
+xtensor's :cpp:func:`meshgrid <xt::meshgrid>` implementation corresponds to numpy's ``'ij'`` indexing order.
+
+Slicing and indexing
+--------------------
+
+See :any:`numpy indexing <numpy:arrays.indexing>` page.
+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   |             Python 3 - NumPy            |                   C++ 14 - xtensor                                        |
+   +=========================================+===========================================================================+
+   | ``a[3, 2]``                             | :cpp:func:`a(3, 2) <xt::xcontainer::operator()>`                          |
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   | :any:`a.flat[4] <numpy.ndarray.flat>`   | :cpp:func:`a.flat(4) <xt::xcontainer::flat>`                              |
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   | ``a[3]``                                || :cpp:func:`xt::view(a, 3, xt::all()) <xt::view>`                         |
+   |                                         || :cpp:func:`xt::row(a, 3) <xt::row>`                                      |
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   | ``a[:, 2]``                             || :cpp:func:`xt::view(a, xt::all(), 2) <xt::view>`                         |
+   |                                         || :cpp:func:`xt::col(a, 2) <xt::col>`                                      |
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   | ``a[:5, 1:]``                           | :cpp:func:`xt::view(a, xt::range(_, 5), xt::range(1, _)) <xt::range>`     |
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   | ``a[5:1:-1, :]``                        | :cpp:func:`xt::view(a, xt::range(5, 1, -1), xt::all()) <xt::all>`         |
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   | ``a[..., 3]``                           | :cpp:func:`xt::strided_view(a, {xt::ellipsis(), 3}) <xt::ellipsis>`       |
+   +-----------------------------------------+---------------------------------------------------------------------------+
+   | :any:`a[:, np.newaxis] <numpy.newaxis>` | :cpp:func:`xt::view(a, xt::all(), xt::newaxis()) <xt::newaxis>`           |
+   +-----------------------------------------+---------------------------------------------------------------------------+
 
 Broadcasting
 ------------
@@ -128,45 +168,47 @@ Broadcasting
 xtensor offers lazy numpy-style broadcasting, and universal functions. Unlike numpy, no copy
 or temporary variables are created.
 
-+-----------------------------------------------------+-----------------------------------------------------+
-|             Python 3 - numpy                        |                   C++ 14 - xtensor                  |
-+=====================================================+=====================================================+
-| | ``a[:, np.newaxis]``                              | | ``xt::view(a, xt::all(), xt::newaxis())``         |
-| | ``a[:5, 1:]``                                     | | ``xt::view(a, xt::range(_, 5), xt::range(1, _))`` |
-| | ``a[5:1:-1, :]``                                  | | ``xt::view(a, xt::range(5, 1, -1), xt::all())``   |
-| | ``a[..., 3]``                                     | | ``xt::strided_view(a, {xt::ellipsis, 3})``        |
-+-----------------------------------------------------+-----------------------------------------------------+
-| ``np.broadcast(a, [4, 5, 7])``                      | ``xt::broadcast(a, {4, 5, 7})``                     |
-+-----------------------------------------------------+-----------------------------------------------------+
-| ``np.vectorize(f)``                                 | ``xt::vectorize(f)``                                |
-+-----------------------------------------------------+-----------------------------------------------------+
-| ``a[a > 5]``                                        | ``xt::filter(a, a > 5)``                            |
-+-----------------------------------------------------+-----------------------------------------------------+
-| ``a[[0, 1], [0, 0]]``                               | ``xt::index_view(a, {{0, 0}, {1, 0}})``             |
-+-----------------------------------------------------+-----------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------------------------+------------------------------------------------------------------+
+   |             Python 3 - NumPy                        |                   C++ 14 - xtensor                               |
+   +=====================================================+==================================================================+
+   | :any:`np.broadcast(a, [4, 5, 7]) <numpy.broadcast>` | :cpp:func:`xt::broadcast(a, {4, 5, 7}) <xt::broadcast>`          |
+   +-----------------------------------------------------+------------------------------------------------------------------+
+   | :any:`np.vectorize(f) <numpy.vectorize>`            | :cpp:func:`xt::vectorize(f) <xt::vectorize>`                     |
+   +-----------------------------------------------------+------------------------------------------------------------------+
+   | ``a[a > 5]``                                        | :cpp:func:`xt::filter(a, a > 5) <xt::filter>`                    |
+   +-----------------------------------------------------+------------------------------------------------------------------+
+   | ``a[[0, 1], [0, 0]]``                               | :cpp:func:`xt::index_view(a, {{0, 0}, {1, 0}}) <xt::index_view>` |
+   +-----------------------------------------------------+------------------------------------------------------------------+
 
 Random
 ------
 
 The random module provides simple ways to create random tensor expressions, lazily.
-
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.random.seed(0)``                         | ``xt::random::seed(0)``                       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.random.randn(10, 10)``                   | ``xt::random::randn<double>({10, 10})``       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.random.randint(10, 10)``                 | ``xt::random::randint<int>({10, 10})``        |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.random.rand(3, 4)``                      | ``xt::random::rand<double>({3, 4})``          |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.random.choice(arr, 5)``                  | ``xt::random::choice(arr, 5)``                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.random.shuffle(arr)``                    | ``xt::random::shuffle(arr)``                  |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.random.permutation(30)``                 | ``xt::random::permutation(30)``               |
-+-----------------------------------------------+-----------------------------------------------+
+See :any:`numpy.random` and :ref:`xtensor random <random>` page.
+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+   |            Python 3 - NumPy                                           |                C++ 14 - xtensor                                                   |
+   +=======================================================================+===================================================================================+
+   | :any:`np.random.seed(0) <numpy.random.seed>`                          | :cpp:func:`xt::random::seed(0) <xt::random::seed>`                                |
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+   | :any:`np.random.randn(10, 10) <numpy.random.randn>`                   | :cpp:func:`xt::random::randn\<double\>({10, 10}) <xt::random::randn>`             |
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+   | :any:`np.random.randint(10, 10) <numpy.random.randint>`               | :cpp:func:`xt::random::randint\<int\>({10, 10}) <xt::random::randint>`            |
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+   | :any:`np.random.rand(3, 4) <numpy.random.rand>`                       | :cpp:func:`xt::random::rand\<double\>({3, 4}) <xt::random::rand>`                 |
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+   | :any:`np.random.choice(arr, 5[, replace][, p]) <numpy.random.choice>` | :cpp:func:`xt::random::choice(arr, 5[, weights][, replace]) <xt::random::choice>` |
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+   | :any:`np.random.shuffle(arr) <numpy.random.shuffle>`                  | :cpp:func:`xt::random::shuffle(arr) <xt::random::shuffle>`                        |
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
+   | :any:`np.random.permutation(30) <numpy.random.permutation>`           | :cpp:func:`xt::random::permutation(30) <xt::random::permutation>`                 |
+   +-----------------------------------------------------------------------+-----------------------------------------------------------------------------------+
 
 Concatenation, splitting, squeezing
 -----------------------------------
@@ -174,21 +216,38 @@ Concatenation, splitting, squeezing
 Concatenating expressions does not allocate memory, it returns a tensor or view expression holding
 closures on the specified arguments.
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.stack([a, b, c], axis=1)``               | ``xt::stack(xtuple(a, b, c), 1)``             |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.concatenate([a, b, c], axis=1)``         | ``xt::concatenate(xtuple(a, b, c), 1)``       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.squeeze(a)``                             | ``xt::squeeze(a)``                            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.expand_dims(a, 1)``                      | ``xt::expand_dims(a ,1)``                     |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.atleast_3d(a)``                          | ``xt::atleast_3d(a)``                         |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.split(a, 4, axis=0)``                    | ``xt::split(a, 4, 0)``                        |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   |            Python 3 - NumPy                                                 |                C++ 14 - xtensor                                            |
+   +=============================================================================+============================================================================+
+   | :any:`np.stack([a, b, c], axis=1) <numpy.stack>`                            | :cpp:func:`xt::stack(xtuple(a, b, c), 1) <xt::stack>`                      |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.hstack([a, b, c]) <numpy.hstack>`                                  | :cpp:func:`xt::hstack(xtuple(a, b, c)) <xt::hstack>`                       |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.vstack([a, b, c]) <numpy.vstack>`                                  | :cpp:func:`xt::vstack(xtuple(a, b, c)) <xt::vstack>`                       |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.concatenate([a, b, c], axis=1) <numpy.concatenate>`                | :cpp:func:`xt::concatenate(xtuple(a, b, c), 1) <xt::concatenate>`          |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.tile(a, reps) <numpy.tile>`                                        | :cpp:func:`xt::tile(a, reps) <xt::tile>`                                   |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.squeeze(a) <numpy.squeeze>`                                        | :cpp:func:`xt::squeeze(a) <xt::squeeze>`                                   |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.expand_dims(a, 1) <numpy.expand_dims>`                             | :cpp:func:`xt::expand_dims(a ,1) <xt::expand_dims>`                        |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.atleast_3d(a) <numpy.atleast_3d>`                                  | :cpp:func:`xt::atleast_3d(a) <xt::atleast_3d>`                             |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.split(a, 4, axis=0) <numpy.split>`                                 | :cpp:func:`xt::split(a, 4, 0) <xt::split>`                                 |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.hsplit(a, 4) <numpy.hsplit>`                                       | :cpp:func:`xt::hsplit(a, 4) <xt::hsplit>`                                  |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.vsplit(a, 4) <numpy.vsplit>`                                       | :cpp:func:`xt::vsplit(a, 4) <xt::vsplit>`                                  |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.trim_zeros(a, trim='fb') <numpy.trim_zeros>`                       | :cpp:func:`xt::trim_zeros(a, "fb") <xt::trim_zeros>`                       |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
+   | :any:`np.pad(a, pad_width, mode='constant', constant_values=0) <numpy.pad>` | :cpp:func:`xt::pad(a, pad_width[, xt::pad_mode::constant][, 0]) <xt::pad>` |
+   +-----------------------------------------------------------------------------+----------------------------------------------------------------------------+
 
 Rearrange elements
 ------------------
@@ -196,29 +255,42 @@ Rearrange elements
 In the same spirit as concatenation, the following operations do not allocate any memory and do
 not modify the underlying xexpression.
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.diag(a)``                                | ``xt::diag(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.diagonal(a)``                            | ``xt::diagonal(a)``                           |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.triu(a)``                                | ``xt::triu(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.tril(a, k=1)``                           | ``xt::tril(a, 1)``                            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.flip(a, axis=3)``                        | ``xt::flip(a, 3)``                            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.flipud(a)``                              | ``xt::flip(a, 0)``                            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.fliplr(a)``                              | ``xt::flip(a, 1)``                            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.transpose(a, (1, 0, 2))``                | ``xt::transpose(a, {1, 0, 2})``               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.rot90(a)``                               | ``xt::rot90(a)``                              |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.rot90(a, 2, (1, 2))``                    | ``xt::rot90<2>(a, {1, 2})``                   |
-+-----------------------------------------------+-----------------------------------------------+
+.. list-table::
+   :widths: 50 50
+   :header-rows: 1
+
+   * - Python3 - NumPy
+     - C++14 - xtensor
+   * - :any:`np.nan_to_num(a) <numpy.nan_to_num>`
+     - :cpp:func:`xt::nan_to_num(a) <xt::nan_to_num>`
+   * - :any:`np.diag(a) <numpy.diag>`
+     - :cpp:func:`xt::diag(a) <xt::diag>`
+   * - :any:`np.diagonal(a) <numpy.diagonal>`
+     - :cpp:func:`xt::diagonal(a) <xt::diagonal>`
+   * - :any:`np.triu(a) <numpy.triu>`
+     - :cpp:func:`xt::triu(a) <xt::triu>`
+   * - :any:`np.tril(a, k=1) <numpy.tril>`
+     - :cpp:func:`xt::tril(a, 1) <xt::tril>`
+   * - :any:`np.flip(a, axis=3) <numpy.flip>`
+     - :cpp:func:`xt::flip(a, 3) <xt::flip>`
+   * - :any:`np.flipud(a) <numpy.flipud>`
+     - :cpp:func:`xt::flip(a, 0) <xt::flip>`
+   * - :any:`np.fliplr(a) <numpy.fliplr>`
+     - :cpp:func:`xt::flip(a, 1) <xt::flip>`
+   * - :any:`np.transpose(a, (1, 0, 2)) <numpy.transpose>`
+     - :cpp:func:`xt::transpose(a, {1, 0, 2}) <xt::transpose>`
+   * - :any:`np.swapaxes(a, 0, -1) <numpy.swapaxes>`
+     - :cpp:func:`xt::swapaxes(a, 0, -1) <xt::swapaxes>`
+   * - :any:`np.moveaxis(a, 0, -1) <numpy.moveaxis>`
+     - :cpp:func:`xt::moveaxis(a, 0, -1) <xt::moveaxis>`
+   * - :any:`np.ravel(a, order='F') <numpy.ravel>`
+     - :cpp:func:`xt::ravel\<xt::layout_type::column_major\>(a) <xt::ravel>`
+   * - :any:`np.rot90(a) <numpy.rot90>`
+     - :cpp:func:`xt::rot90(a) <xt::rot90>`
+   * - :any:`np.rot90(a, 2, (1, 2)) <numpy.rot90>`
+     - :cpp:func:`xt::rot90\<2\>(a, {1, 2}) <xt::rot90>`
+   * - :any:`np.roll(a, 2, axis=1) <numpy.roll>`
+     - :cpp:func:`xt::roll(a, 2, 1) <xt::roll>`
 
 Iteration
 ---------
@@ -226,158 +298,275 @@ Iteration
 xtensor follows the idioms of the C++ STL providing iterator pairs to iterate on arrays in
 different fashions.
 
-+----------------------------------------------------------------+----------------------------------------------------------------+
-|            Python 3 - numpy                                    |                C++ 14 - xtensor                                |
-+================================================================+================================================================+
-| | ``for x in np.nditer(a):``                                   | | ``for(auto it=a.begin(); it!=a.end(); ++it)``                |
-+----------------------------------------------------------------+----------------------------------------------------------------+
-| Iterating over ``a`` with a prescribed broadcasting shape      | | ``a.begin({3, 4})``                                          |
-|                                                                | | ``a.end({3, 4})``                                            |
-+----------------------------------------------------------------+----------------------------------------------------------------+
-| Iterating over ``a`` in a row-major fashion                    | | ``a.begin<xt::layout_type::row_major>()``                    |
-|                                                                | | ``a.begin<xt::layout_type::row_major>()``                    |
-+----------------------------------------------------------------+----------------------------------------------------------------+
-| Iterating over ``a`` in a column-major fashion                 | | ``a.begin<xt::layout_type::column_major>()``                 |
-|                                                                | | ``a.end<xt::layout_type::column_major>()``                   |
-+----------------------------------------------------------------+----------------------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------------------------------+------------------------------------------------+
+   |            Python 3 - NumPy                               |                C++ 14 - xtensor                |
+   +===========================================================+================================================+
+   | :any:`for x in np.nditer(a): <numpy.nditer>`              |  ``for(auto it=a.begin(); it!=a.end(); ++it)`` |
+   +-----------------------------------------------------------+------------------------------------------------+
+   | Iterating over ``a`` with a prescribed broadcasting shape | | ``a.begin({3, 4})``                          |
+   |                                                           | | ``a.end({3, 4})``                            |
+   +-----------------------------------------------------------+------------------------------------------------+
+   | Iterating over ``a`` in a row-major fashion               | | ``a.begin<xt::layout_type::row_major>()``    |
+   |                                                           | | ``a.begin<xt::layout_type::row_major>()``    |
+   +-----------------------------------------------------------+------------------------------------------------+
+   | Iterating over ``a`` in a column-major fashion            | | ``a.begin<xt::layout_type::column_major>()`` |
+   |                                                           | | ``a.end<xt::layout_type::column_major>()``   |
+   +-----------------------------------------------------------+------------------------------------------------+
 
 Logical
 -------
 
-Logical universal functions are truly lazy. ``xt::where(condition, a, b)`` does not evaluate ``a``
-where ``condition`` is falsy, and it does not evaluate ``b`` where ``condition`` is truthy.
-
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.where(a > 5, a, b)``                     | ``xt::where(a > 5, a, b)``                    |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.where(a > 5)``                           | ``xt::where(a > 5)``                          |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.argwhere(a > 5)``                        | ``xt::argwhere(a > 5)``                       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.any(a)``                                 | ``xt::any(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.all(a)``                                 | ``xt::all(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.logical_and(a, b)``                      | ``a && b``                                    |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.logical_or(a, b)``                       | ``a || b``                                    |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.isclose(a, b)``                          | ``xt::isclose(a, b)``                         |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.allclose(a, b)``                         | ``xt::allclose(a, b)``                        |
-+-----------------------------------------------+-----------------------------------------------+
+Logical universal functions are truly lazy.
+:cpp:func:`xt::where(condition, a, b) <xt::where>` does not evaluate ``a`` where ``condition``
+is falsy, and it does not evaluate ``b`` where ``condition`` is truthy.
+
+.. table::
+   :widths: 50 50
+
+   +-------------------------------------------------+------------------------------------------------+
+   |            Python 3 - NumPy                     |                C++ 14 - xtensor                |
+   +=================================================+================================================+
+   | :any:`np.where(a > 5, a, b) <numpy.where>`      | :cpp:func:`xt::where(a > 5, a, b) <xt::where>` |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.where(a > 5) <numpy.where>`            | :cpp:func:`xt::where(a > 5) <xt::where>`       |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.argwhere(a > 5) <numpy.argwhere>`      | :cpp:func:`xt::argwhere(a > 5) <xt::argwhere>` |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.any(a) <numpy.any>`                    | :cpp:func:`xt::any(a) <xt::any>`               |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.all(a) <numpy.all>`                    | :cpp:func:`xt::all(a) <xt::all>`               |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.isin(a, b) <numpy.isin>`               | :cpp:func:`xt::isin(a, b) <xt::isin>`          |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.in1d(a, b) <numpy.in1d>`               | :cpp:func:`xt::in1d(a, b) <xt::in1d>`          |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.logical_and(a, b) <numpy.logical_and>` | ``a && b``                                     |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.logical_or(a, b) <numpy.logical_or>`   | ``a || b``                                     |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.isclose(a, b) <numpy.isclose>`         | :cpp:func:`xt::isclose(a, b) <xt::isclose>`    |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`np.allclose(a, b) <numpy.allclose>`       | :cpp:func:`xt::allclose(a, b) <xt::allclose>`  |
+   +-------------------------------------------------+------------------------------------------------+
+   | :any:`a = ~b <numpy.invert>`                    | ``a = !b``                                     |
+   +-------------------------------------------------+------------------------------------------------+
+
+Indices
+-------
+
+.. table::
+   :widths: 50 50
+
+   +-------------------------------------------------------------------------+-----------------------------------------------------------------------+
+   |            Python 3 - NumPy                                             |                C++ 14 - xtensor                                       |
+   +=========================================================================+=======================================================================+
+   | :any:`np.ravel_multi_index(indices, a.shape) <numpy.ravel_multi_index>` | :cpp:func:`xt::ravel_indices(indices, a.shape()) <xt::ravel_indices>` |
+   +-------------------------------------------------------------------------+-----------------------------------------------------------------------+
 
 Comparisons
 -----------
 
-+--------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                |                C++ 14 - xtensor               |
-+============================================+===============================================+
-| ``np.equal(a, b)``                         | ``xt::equal(a, b)``                           |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.not_equal(a)``                        | ``xt::not_equal(a)``                          |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.nonzero(a)``                          | ``xt::nonzero(a)``                            |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.flatnonzero(a)``                      | ``xt::flatnonzero(a)``                        |
-+--------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------------------------+----------------------------------------------------------+
+   |            Python 3 - NumPy                         |                C++ 14 - xtensor                          |
+   +=====================================================+==========================================================+
+   | :any:`np.equal(a, b) <numpy.equal>`                 | :cpp:func:`xt::equal(a, b) <xt::equal>`                  |
+   +-----------------------------------------------------+----------------------------------------------------------+
+   | :any:`np.not_equal(a, b) <numpy.not_equal>`         | :cpp:func:`xt::not_equal(a, b) <xt::not_equal>`          |
+   +-----------------------------------------------------+----------------------------------------------------------+
+   | :any:`np.less(a, b) <numpy.less>`                   || :cpp:func:`xt::less(a, b) <xt::less>`                   |
+   |                                                     || ``a < b``                                               |
+   +-----------------------------------------------------+----------------------------------------------------------+
+   | :any:`np.less_equal(a, b) <numpy.less_equal>`       || :cpp:func:`xt::less_equal(a, b) <xt::less_equal>`       |
+   |                                                     || ``a <= b``                                              |
+   +-----------------------------------------------------+----------------------------------------------------------+
+   | :any:`np.greater(a, b) <numpy.greater>`             || :cpp:func:`xt::greater(a, b) <xt::greater>`             |
+   |                                                     || ``a > b``                                               |
+   +-----------------------------------------------------+----------------------------------------------------------+
+   | :any:`np.greater_equal(a, b) <numpy.greater_equal>` || :cpp:func:`xt::greater_equal(a, b) <xt::greater_equal>` |
+   |                                                     || ``a >= b``                                              |
+   +-----------------------------------------------------+----------------------------------------------------------+
+   | :any:`np.nonzero(a) <numpy.nonzero>`                | :cpp:func:`xt::nonzero(a) <xt::nonzero>`                 |
+   +-----------------------------------------------------+----------------------------------------------------------+
+   | :any:`np.flatnonzero(a) <numpy.flatnonzero>`        | :cpp:func:`xt::flatnonzero(a) <xt::flatnonzero>`         |
+   +-----------------------------------------------------+----------------------------------------------------------+
 
 Minimum, Maximum, Sorting
 -------------------------
 
-+--------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                |                C++ 14 - xtensor               |
-+============================================+===============================================+
-| ``np.amin(a)``                             | ``xt::amin(a)``                               |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.amax(a)``                             | ``xt::amax(a)``                               |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.argmin(a)``                           | ``xt::argmin(a)``                             |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.argmax(a, axis=1)``                   | ``xt::argmax(a, 1)``                          |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.sort(a, axis=1)``                     | ``xt::sort(a, 1)``                            |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.argsort(a, axis=1)``                  | ``xt::argsort(a, 1)``                         |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.unique(a)``                           | ``xt::unique(a)``                             |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.setdiff1d(ar1, ar2)``                 | ``xt::setdiff1d(ar1, ar2)``                   |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.diff(a[, n, axis])``                  | ``xt::diff(a[, n, axis])``                    |
-+--------------------------------------------+-----------------------------------------------+
+.. list-table::
+   :widths: 50 50
+   :header-rows: 1
+
+   * - Python3 - NumPy
+     - C++14 - xtensor
+   * - :any:`np.amin(a) <numpy.amin>`
+     - :cpp:func:`xt::amin(a) <xt::amin>`
+   * - :any:`np.amax(a) <numpy.amax>`
+     - :cpp:func:`xt::amax(a) <xt::amax>`
+   * - :any:`np.argmin(a) <numpy.argmin>`
+     - :cpp:func:`xt::argmin(a) <xt::argmin>`
+   * - :any:`np.argmax(a, axis=1) <numpy.argmax>`
+     - :cpp:func:`xt::argmax(a, 1) <xt::argmax>`
+   * - :any:`np.sort(a, axis=1) <numpy.sort>`
+     - :cpp:func:`xt::sort(a, 1) <xt::sort>`
+   * - :any:`np.argsort(a, axis=1) <numpy.argsort>`
+     - :cpp:func:`xt::argsort(a, 1) <xt::argsort>`
+   * - :any:`np.unique(a) <numpy.unique>`
+     - :cpp:func:`xt::unique(a) <xt::unique>`
+   * - :any:`np.setdiff1d(ar1, ar2) <numpy.setdiff1d>`
+     - :cpp:func:`xt::setdiff1d(ar1, ar2) <xt::setdiff1d>`
+   * - :any:`np.partition(a, kth) <numpy.partition>`
+     - :cpp:func:`xt::partition(a, kth) <xt::partition>`
+   * - :any:`np.argpartition(a, kth) <numpy.argpartition>`
+     - :cpp:func:`xt::argpartition(a, kth) <xt::argpartition>`
+   * - :any:`np.quantile(a, [.1 .3], method="linear") <numpy.quantile>`
+     - :cpp:func:`xt::quantile(a, {.1, .3}, xt::quantile_method::linear) <xt::quantile>`
+   * - :any:`np.quantile(a, [.1, .3], axis=1 method="linear") <numpy.quantile>`
+     - :cpp:func:`xt::quantile(a, {.1, .3}, 1, xt::quantile_method::linear) <xt::quantile>`
+   * -
+     - :cpp:func:`xt::quantile(a, {.1, .3}, 1, 1.0, 1.0) <xt::quantile>`
+   * - :any:`np.median(a, axis=1) <numpy.median>`
+     - :cpp:func:`xt::median(a, 1) <xt::median>`
 
 Complex numbers
 ---------------
 
-Functions ``xt::real`` and ``xt::imag`` respectively return views on the real and imaginary part
-of a complex expression. The returned value is an expression holding a closure on the passed
-argument.
-
-+--------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                |                C++ 14 - xtensor               |
-+============================================+===============================================+
-| ``np.real(a)``                             | ``xt::real(a)``                               |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.imag(a)``                             | ``xt::imag(a)``                               |
-+--------------------------------------------+-----------------------------------------------+
-| ``np.conj(a)``                             | ``xt::conj(a)``                               |
-+--------------------------------------------+-----------------------------------------------+
-
-- The constness and value category (rvalue / lvalue) of ``real(a)`` is the same as that of ``a``.
-  Hence, if ``a`` is a non-const lvalue, ``real(a)`` is an non-const lvalue reference, to which
+Functions :cpp:func:`xt::real` and :cpp:func:`xt::imag` respectively return views on the real and imaginary part
+of a complex expression.
+The returned value is an expression holding a closure on the passed argument.
+
+.. table::
+   :widths: 50 50
+
+   +--------------------------------+------------------------------------+
+   |            Python 3 - NumPy    |                C++ 14 - xtensor    |
+   +================================+====================================+
+   | :any:`np.real(a) <numpy.real>` | :cpp:func:`xt::real(a) <xt::real>` |
+   +--------------------------------+------------------------------------+
+   | :any:`np.imag(a) <numpy.imag>` | :cpp:func:`xt::imag(a) <xt::imag>` |
+   +--------------------------------+------------------------------------+
+   | :any:`np.conj(a) <numpy.conj>` | :cpp:func:`xt::conj(a) <xt::conj>` |
+   +--------------------------------+------------------------------------+
+
+- The constness and value category (rvalue / lvalue) of :cpp:func:`xt::real(a) <xt::real>` is the same as that of ``a``.
+  Hence, if ``a`` is a non-const lvalue, :cpp:func:`real(a) <xt::real>` is an non-const lvalue reference, to which
   one can assign a real expression.
-- If ``a`` has complex values, the same holds for ``imag(a)``. The constness and value category of
-  ``imag(a)`` is the same as that of ``a``.
-- If ``a`` has real values, ``imag(a)`` returns ``zeros(a.shape())``.
+- If ``a`` has complex values, the same holds for :cpp:func:`xt::imag(a) <xt::imag>`. The constness and value category of
+  :cpp:func:`xt::imag(a) <xt::imag>` is the same as that of ``a``.
+- If ``a`` has real values, :cpp:func:`xt::imag(a) <xt::imag>` returns :cpp:func:`xt::zeros(a.shape()) <xt::zeros>`.
 
 Reducers
 --------
 
 Reducers accumulate values of tensor expressions along specified axes. When no axis is specified,
-values are accumulated along all axes. Reducers are lazy, meaning that returned expressons don't
-hold any values and are computed upon access or assigmnent.
-
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.sum(a, axis=[0, 1])``                    | ``xt::sum(a, {0, 1})``                        |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.sum(a, axis=1)``                         | ``xt::sum(a, 1)``                             |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.sum(a)``                                 | ``xt::sum(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.prod(a, axis=[0, 1])``                   | ``xt::prod(a, {0, 1})``                       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.prod(a, axis=1)``                        | ``xt::prod(a, 1)``                            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.prod(a)``                                | ``xt::prod(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.mean(a, axis=[0, 1])``                   | ``xt::mean(a, {0, 1})``                       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.mean(a, axis=1)``                        | ``xt::mean(a, 1)``                            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.mean(a)``                                | ``xt::mean(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.std(a, [axis])``                         | ``xt::stddev(a, [axis])``                     |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.var(a, [axis])``                         | ``xt::variance(a, [axis])``                   |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.trapz(a, dx=2.0, axis=-1)``              | ``xt::trapz(a, 2.0, -1)``                     |
-| ``np.trapz(a, x=b, axis=-1)``                 | ``xt::trapz(a, b, -1)``                       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.count_nonzero(a, axis=[0, 1])``          | ``xt::count_nonzero(a, {0, 1})``              |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.count_nonzero(a, axis=1)``               | ``xt::count_nonzero(a, 1)``                   |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.count_nonzero(a)``                       | ``xt::count_nonzero(a)``                      |
-+-----------------------------------------------+-----------------------------------------------+
-
-More generally, one can use the ``xt::reduce(function, input, axes)`` which allows the specification
-of an arbitrary binary function for the reduction. The binary function must be cummutative and
-associative up to rounding errors.
+values are accumulated along all axes. Reducers are lazy, meaning that returned expressions don't
+hold any values and are computed upon access or assignment.
+
+.. table::
+   :widths: 50 50
+
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   |            Python 3 - NumPy                                   |                C++ 14 - xtensor                              |
+   +===============================================================+==============================================================+
+   | :any:`np.sum(a, axis=(0, 1)) <numpy.sum>`                     | :cpp:func:`xt::sum(a, {0, 1}) <xt::sum>`                     |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.sum(a, axis=1) <numpy.sum>`                          | :cpp:func:`xt::sum(a, 1) <xt::sum>`                          |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.sum(a) <numpy.sum>`                                  | :cpp:func:`xt::sum(a) <xt::sum>`                             |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.prod(a, axis=(0, 1)) <numpy.prod>`                   | :cpp:func:`xt::prod(a, {0, 1}) <xt::prod>`                   |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.prod(a, axis=1) <numpy.prod>`                        | :cpp:func:`xt::prod(a, 1) <xt::prod>`                        |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.prod(a) <numpy.prod>`                                | :cpp:func:`xt::prod(a) <xt::prod>`                           |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.mean(a, axis=(0, 1)) <numpy.mean>`                   | :cpp:func:`xt::mean(a, {0, 1}) <xt::mean>`                   |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.mean(a, axis=1) <numpy.mean>`                        | :cpp:func:`xt::mean(a, 1) <xt::mean>`                        |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.mean(a) <numpy.mean>`                                | :cpp:func:`xt::mean(a) <xt::mean>`                           |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.std(a, [axis]) <numpy.std>`                          | :cpp:func:`xt::stddev(a, [axis]) <xt::stddev>`               |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.var(a, [axis]) <numpy.var>`                          | :cpp:func:`xt::variance(a, [axis]) <xt::variance>`           |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.diff(a[, n, axis]) <numpy.diff>`                     | :cpp:func:`xt::diff(a[, n, axis]) <xt::diff>`                |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.trapz(a, dx=2.0, axis=-1) <numpy.trapz>`             | :cpp:func:`xt::trapz(a, 2.0, -1) <xt::trapz>`                |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.trapz(a, x=b, axis=-1) <numpy.trapz>`                | :cpp:func:`xt::trapz(a, b, -1) <xt::trapz>`                  |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.count_nonzero(a, axis=(0, 1)) <numpy.count_nonzero>` | :cpp:func:`xt::count_nonzero(a, {0, 1}) <xt::count_nonzero>` |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.count_nonzero(a, axis=1) <numpy.count_nonzero>`      | :cpp:func:`xt::count_nonzero(a, 1) <xt::count_nonzero>`      |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+   | :any:`np.count_nonzero(a) <numpy.count_nonzero>`              | :cpp:func:`xt::count_nonzero(a) <xt::count_nonzero>`         |
+   +---------------------------------------------------------------+--------------------------------------------------------------+
+
+More generally, one can use the :cpp:func:`xt::reduce(function, input, axes) <xt::reduce>` which allows the specification
+of an arbitrary binary function for the reduction.
+The binary function must be commutative and associative up to rounding errors.
+
+NaN functions
+-------------
+
+NaN functions allow disregarding NaNs during computation, changing the effective number of elements
+considered in reductions.
+
+.. list-table::
+   :widths: 50 50
+   :header-rows: 1
+
+   * - Python3 - NumPy
+     - C++14 - xtensor
+   * - :any:`np.nan_to_num(a) <numpy.nan_to_num>`
+     - :cpp:func:`xt::nan_to_num(a) <xt::nan_to_num>`
+   * - :any:`np.nanmin(a) <numpy.nanmin>`
+     - :cpp:func:`xt::nanmin(a) <xt::nanmin>`
+   * - :any:`np.nanmin(a, axis=(0, 1)) <numpy.nanmin>`
+     - :cpp:func:`xt::nanmin(a, {0, 1}) <xt::nanmin>`
+   * - :any:`np.nanmax(a) <numpy.nanmax>`
+     - :cpp:func:`xt::nanmax(a) <xt::nanmax>`
+   * - :any:`np.nanmax(a, axis=(0, 1)) <numpy.nanmax>`
+     - :cpp:func:`xt::nanmax(a, {0, 1}) <xt::nanmax>`
+   * - :any:`np.nansum(a) <numpy.nansum>`
+     - :cpp:func:`xt::nansum(a) <xt::nansum>`
+   * - :any:`np.nansum(a, axis=0) <numpy.nansum>`
+     - :cpp:func:`xt::nansum(a, 0) <xt::nansum>`
+   * - :any:`np.nansum(a, axis=(0, 1)) <numpy.nansum>`
+     - :cpp:func:`xt::nansum(a, {0, 1}) <xt::nansum>`
+   * - :any:`np.nanprod(a) <numpy.nanprod>`
+     - :cpp:func:`xt::nanprod(a) <xt::nanprod>`
+   * - :any:`np.nanprod(a, axis=0) <numpy.nanprod>`
+     - :cpp:func:`xt::nanprod(a, 0) <xt::nanprod>`
+   * - :any:`np.nanprod(a, axis=(0, 1)) <numpy.nanprod>`
+     - :cpp:func:`xt::nanprod(a, {0, 1}) <xt::nanprod>`
+   * - :any:`np.nancumsum(a) <numpy.nancumsum>`
+     - :cpp:func:`xt::nancumsum(a) <xt::nancumsum>`
+   * - :any:`np.nancumsum(a, axis=0) <numpy.nancumsum>`
+     - :cpp:func:`xt::nancumsum(a, 0) <xt::nancumsum>`
+   * - :any:`np.nancumprod(a) <numpy.nancumsum>`
+     - :cpp:func:`xt::nancumsum(a) <xt::nancumsum>`
+   * - :any:`np.nancumprod(a, axis=0) <numpy.nancumsum>`
+     - :cpp:func:`xt::nancumsum(a, 0) <xt::nancumsum>`
+   * - :any:`np.nanmean(a) <numpy.nanmean>`
+     - :cpp:func:`xt::nanmean(a) <xt::nanmean>`
+   * - :any:`np.nanmean(a, axis=(0, 1)) <numpy.nanmean>`
+     - :cpp:func:`xt::nanmean(a, {0, 1}) <xt::nanmean>`
+   * - :any:`np.nanvar(a) <numpy.nanvar>`
+     - :cpp:func:`xt::nanvar(a) <xt::nanvar>`
+   * - :any:`np.nanvar(a, axis=(0, 1)) <numpy.nanvar>`
+     - :cpp:func:`xt::nanvar(a, {0, 1}) <xt::nanvar>`
+   * - :any:`np.nanstd(a) <numpy.nanstd>`
+     - :cpp:func:`xt::nanstd(a) <xt::nanstd>`
+   * - :any:`np.nanstd(a, axis=(0, 1)) <numpy.nanstd>`
+     - :cpp:func:`xt::nanstd(a, {0, 1}) <xt::nanstd>`
 
 I/O
 ---
@@ -386,31 +575,37 @@ I/O
 
 These options determine the way floating point numbers, tensors and other xtensor expressions are displayed.
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.set_printoptions(precision=4)``          | ``xt::print_options::set_precision(4)``       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.set_printoptions(threshold=5)``          | ``xt::print_options::set_threshold(5)``       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.set_printoptions(edgeitems=3)``          | ``xt::print_options::set_edgeitems(3)``       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.set_printoptions(linewidth=100)``        | ``xt::print_options::set_line_width(100)``    |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +--------------------------------------------------------------------+----------------------------------------------------------------------------------------+
+   |            Python 3 - NumPy                                        |                C++ 14 - xtensor                                                        |
+   +====================================================================+========================================================================================+
+   | :any:`np.set_printoptions(precision=4) <numpy.set_printoptions>`   | :cpp:func:`xt::print_options::set_precision(4) <xt::print_options::set_precision>`     |
+   +--------------------------------------------------------------------+----------------------------------------------------------------------------------------+
+   | :any:`np.set_printoptions(threshold=5) <numpy.set_printoptions>`   | :cpp:func:`xt::print_options::set_threshold(5) <xt::print_options::set_threshold>`     |
+   +--------------------------------------------------------------------+----------------------------------------------------------------------------------------+
+   | :any:`np.set_printoptions(edgeitems=3) <numpy.set_printoptions>`   | :cpp:func:`xt::print_options::set_edgeitems(3) <xt::print_options::set_edgeitems>`     |
+   +--------------------------------------------------------------------+----------------------------------------------------------------------------------------+
+   | :any:`np.set_printoptions(linewidth=100) <numpy.set_printoptions>` | :cpp:func:`xt::print_options::set_line_width(100) <xt::print_options::set_line_width>` |
+   +--------------------------------------------------------------------+----------------------------------------------------------------------------------------+
 
 **Reading npy, csv file formats**
 
-Functions ``load_csv`` and ``dump_csv`` respectively take input and output streams as arguments.
+Functions :cpp:func:`xt::load_csv` and :cpp:func:`xt::dump_csv` respectively take input and output streams as arguments.
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.load(filename)``                         | ``xt::load_npy<double>(filename)``            |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.save(filename, arr)``                    | ``xt::dump_npy(filename, arr)``               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.load_txt(filename, delimiter=',')``      | ``xt::load_csv<double>(stream)``              |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------------------------------------------+-------------------------------------------------------------+
+   |            Python 3 - NumPy                                |                C++ 14 - xtensor                             |
+   +============================================================+=============================================================+
+   | :any:`np.load(filename) <numpy.load>`                      | :cpp:func:`xt::load_npy\<double\>(filename) <xt::load_npy>` |
+   +------------------------------------------------------------+-------------------------------------------------------------+
+   | :any:`np.save(filename, arr) <numpy.save>`                 | :cpp:func:`xt::dump_npy(filename, arr) <xt::dump_npy>`      |
+   +------------------------------------------------------------+-------------------------------------------------------------+
+   | :any:`np.loadtxt(filename, delimiter=',') <numpy.loadtxt>` | :cpp:func:`xt::load_csv\<double\>(stream) <xt::load_csv>`   |
+   +------------------------------------------------------------+-------------------------------------------------------------+
 
 Mathematical functions
 ----------------------
@@ -419,198 +614,268 @@ xtensor universal functions are provided for a large set number of mathematical
 
 **Basic functions:**
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.absolute(a)``                            | ``xt::abs(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.sign(a)``                                | ``xt::sign(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.remainder(a, b)``                        | ``xt::remainder(a, b)``                       |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.clip(a, min, max)``                      | ``xt::clip(a, min, max)``                     |
-+-----------------------------------------------+-----------------------------------------------+
-|                                               | ``xt::fma(a, b, c)``                          |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.interp(x, xp, fp, [,left, right])``      | ``xt::interp(x, xp, fp, [,left, right])``     |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   |            Python 3 - NumPy                                |                C++ 14 - xtensor                                |
+   +============================================================+================================================================+
+   | :any:`np.absolute(a) <numpy.absolute>`                     | :cpp:func:`xt::abs(a) <xt::abs>`                               |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.sign(a) <numpy.sign>`                             | :cpp:func:`xt::sign(a) <xt::sign>`                             |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.remainder(a, b) <numpy.remainder>`                | :cpp:func:`xt::remainder(a, b) <xt::remainder>`                |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.minimum(a, b) <numpy.minimum>`                    | :cpp:func:`xt::minimum(a, b) <xt::minimum>`                    |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.maximum(a, b) <numpy.maximum>`                    | :cpp:func:`xt::maximum(a, b) <xt::maximum>`                    |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.clip(a, min, max) <numpy.clip>`                   | :cpp:func:`xt::clip(a, min, max) <xt::clip>`                   |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   |                                                            | :cpp:func:`xt::fma(a, b, c) <xt::fma>`                         |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.interp(x, xp, fp, [,left, right]) <numpy.interp>` | :cpp:func:`xt::interp(x, xp, fp, [,left, right]) <xt::interp>` |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.rad2deg(a) <numpy.rad2deg>`                       | :cpp:func:`xt::rad2deg(a) <xt::rad2deg>`                       |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.degrees(a) <numpy.degrees>`                       | :cpp:func:`xt::degrees(a) <xt::degrees>`                       |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.deg2rad(a) <numpy.deg2rad>`                       | :cpp:func:`xt::deg2rad(a) <xt::deg2rad>`                       |
+   +------------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.radians(a) <numpy.radians>`                       | :cpp:func:`xt::radians(a) <xt::radians>`                       |
+   +------------------------------------------------------------+----------------------------------------------------------------+
 
 **Exponential functions:**
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.exp(a)``                                 | ``xt::exp(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.expm1(a)``                               | ``xt::expm1(a)``                              |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.log(a)``                                 | ``xt::log(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.log1p(a)``                               | ``xt::log1p(a)``                              |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +----------------------------------+--------------------------------------+
+   |            Python 3 - NumPy      |                C++ 14 - xtensor      |
+   +==================================+======================================+
+   | :any:`np.exp(a) <numpy.exp>`     | :cpp:func:`xt::exp(a) <xt::exp>`     |
+   +----------------------------------+--------------------------------------+
+   | :any:`np.expm1(a) <numpy.expm1>` | :cpp:func:`xt::expm1(a) <xt::expm1>` |
+   +----------------------------------+--------------------------------------+
+   | :any:`np.log(a) <numpy.log>`     | :cpp:func:`xt::log(a) <xt::log>`     |
+   +----------------------------------+--------------------------------------+
+   | :any:`np.log1p(a) <numpy.log1p>` | :cpp:func:`xt::log1p(a) <xt::log1p>` |
+   +----------------------------------+--------------------------------------+
 
 **Power functions:**
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.power(a, p)``                            | ``xt::pow(a, b)``                             |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.sqrt(a)``                                | ``xt::sqrt(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.square(a)``                              | ``xt::square(a)``                             |
-|                                               | ``xt::cube(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.cbrt(a)``                                | ``xt::cbrt(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-------------------------------------+----------------------------------------+
+   |            Python 3 - NumPy         |                C++ 14 - xtensor        |
+   +=====================================+========================================+
+   | :any:`np.power(a, p) <numpy.power>` | :cpp:func:`xt::pow(a, b) <xt::pow>`    |
+   +-------------------------------------+----------------------------------------+
+   | :any:`np.sqrt(a) <numpy.sqrt>`      | :cpp:func:`xt::sqrt(a) <xt::sqrt>`     |
+   +-------------------------------------+----------------------------------------+
+   | :any:`np.square(a) <numpy.square>`  | :cpp:func:`xt::square(a) <xt::square>` |
+   |                                     | :cpp:func:`xt::cube(a) <xt::cube>`     |
+   +-------------------------------------+----------------------------------------+
+   | :any:`np.cbrt(a) <numpy.cbrt>`      | :cpp:func:`xt::cbrt(a) <xt::cbrt>`     |
+   +-------------------------------------+----------------------------------------+
 
 **Trigonometric functions:**
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.sin(a)``                                 | ``xt::sin(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.cos(a)``                                 | ``xt::cos(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.tan(a)``                                 | ``xt::tan(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------------+----------------------------------+
+   |            Python 3 - NumPy  |                C++ 14 - xtensor  |
+   +==============================+==================================+
+   | :any:`np.sin(a) <numpy.sin>` | :cpp:func:`xt::sin(a) <xt::sin>` |
+   +------------------------------+----------------------------------+
+   | :any:`np.cos(a) <numpy.cos>` | :cpp:func:`xt::cos(a) <xt::cos>` |
+   +------------------------------+----------------------------------+
+   | :any:`np.tan(a) <numpy.tan>` | :cpp:func:`xt::tan(a) <xt::tan>` |
+   +------------------------------+----------------------------------+
 
 **Hyperbolic functions:**
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.sinh(a)``                                | ``xt::sinh(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.cosh(a)``                                | ``xt::cosh(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.tanh(a)``                                | ``xt::tanh(a)``                               |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +--------------------------------+------------------------------------+
+   |            Python 3 - NumPy    |                C++ 14 - xtensor    |
+   +================================+====================================+
+   | :any:`np.sinh(a) <numpy.sinh>` | :cpp:func:`xt::sinh(a) <xt::sinh>` |
+   +--------------------------------+------------------------------------+
+   | :any:`np.cosh(a) <numpy.cosh>` | :cpp:func:`xt::cosh(a) <xt::cosh>` |
+   +--------------------------------+------------------------------------+
+   | :any:`np.tanh(a) <numpy.tanh>` | :cpp:func:`xt::tanh(a) <xt::tanh>` |
+   +--------------------------------+------------------------------------+
 
 **Error and gamma functions:**
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``scipy.special.erf(a)``                      | ``xt::erf(a)``                                |
-+-----------------------------------------------+-----------------------------------------------+
-| ``scipy.special.gamma(a)``                    | ``xt::tgamma(a)``                             |
-+-----------------------------------------------+-----------------------------------------------+
-| ``scipy.special.gammaln(a)``                  | ``xt::lgamma(a)``                             |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +---------------------------------------------------------+----------------------------------------+
+   |            Python 3 - NumPy                             |                C++ 14 - xtensor        |
+   +=========================================================+========================================+
+   | :any:`scipy.special.erf(a) <scipy.special.erf>`         | :cpp:func:`xt::erf(a) <xt::erf>`       |
+   +---------------------------------------------------------+----------------------------------------+
+   | :any:`scipy.special.gamma(a) <scipy.special.gamma>`     | :cpp:func:`xt::tgamma(a) <xt::tgamma>` |
+   +---------------------------------------------------------+----------------------------------------+
+   | :any:`scipy.special.gammaln(a) <scipy.special.gammaln>` | :cpp:func:`xt::lgamma(a) <xt::lgamma>` |
+   +---------------------------------------------------------+----------------------------------------+
 
 **Classification functions:**
 
-+-----------------------------------------------+-----------------------------------------------+
-|            Python 3 - numpy                   |                C++ 14 - xtensor               |
-+===============================================+===============================================+
-| ``np.isnan(a)``                               | ``xt::isnan(a)``                              |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.isinf(a)``                               | ``xt::isinf(a)``                              |
-+-----------------------------------------------+-----------------------------------------------+
-| ``np.isfinite(a)``                            | ``xt::isfinite(a)``                           |
-+-----------------------------------------------+-----------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-----------------------------------------------------------+----------------------------------------------------------------+
+   |            Python 3 - NumPy                               |                C++ 14 - xtensor                                |
+   +===========================================================+================================================================+
+   | :any:`np.isnan(a) <numpy.isnan>`                          | :cpp:func:`xt::isnan(a) <xt::isnan>`                           |
+   +-----------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.isinf(a) <numpy.isinf>`                          | :cpp:func:`xt::isinf(a) <xt::isinf>`                           |
+   +-----------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.isfinite(a) <numpy.isfinite>`                    | :cpp:func:`xt::isfinite(a) <xt::isfinite>`                     |
+   +-----------------------------------------------------------+----------------------------------------------------------------+
+   | :any:`np.searchsorted(a, v[, side]) <numpy.searchsorted>` | :cpp:func:`xt::searchsorted(a, v[, right]) <xt::searchsorted>` |
+   +-----------------------------------------------------------+----------------------------------------------------------------+
 
 **Histogram:**
 
-+-------------------------------------------------------------------------------+--------------------------------------------------------------------------------+
-|                           Python 3 - numpy                                    |                           C++ 14 - xtensor                                     |
-+===============================================================================+================================================================================+
-| ``np.histogram(a, bins[, weights][, density])``                               | ``xt::histogram(a, bins[, weights][, density])``                               |
-+-------------------------------------------------------------------------------+--------------------------------------------------------------------------------+
-| ``np.histogram_bin_edges(a, bins[, weights][, left, right][, bins][, mode])`` | ``xt::histogram_bin_edges(a, bins[, weights][, left, right][, bins][, mode])`` |
-+-------------------------------------------------------------------------------+--------------------------------------------------------------------------------+
-| ``np.bincount(arr)``                                                          | ``xt::bincount(arr)``                                                          |
-+-------------------------------------------------------------------------------+--------------------------------------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +--------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------+
+   |                           Python 3 - NumPy                                                                   |                           C++ 14 - xtensor                                                                       |
+   +==============================================================================================================+==================================================================================================================+
+   | :any:`np.histogram(a, bins[, weights][, density]) <numpy.histogram>`                                         | :cpp:func:`xt::histogram(a, bins[, weights][, density]) <xt::histogram>`                                         |
+   +--------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------+
+   | :any:`np.histogram_bin_edges(a, bins[, weights][, left, right][, bins][, mode]) <numpy.histogram_bin_edges>` | :cpp:func:`xt::histogram_bin_edges(a, bins[, weights][, left, right][, bins][, mode]) <xt::histogram_bin_edges>` |
+   +--------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------+
+   | :any:`np.bincount(arr) <numpy.bincount>`                                                                     | :cpp:func:`xt::bincount(arr) <xt::bincount>`                                                                     |
+   +--------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------+
+   | :any:`np.digitize(data, bin_edges[, right]) <numpy.digitize>`                                                | :cpp:func:`xt::digitize(data, bin_edges[, right][, assume_sorted]) <xt::digitize>`                               |
+   +--------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------+
+
+See :ref:`histogram`.
+
+**Numerical constants:**
+
+.. table::
+   :widths: 50 50
+
+   +------------------+----------------------------------------------------------------------------+
+   | Python 3 - NumPy | C++ 14 - xtensor                                                           |
+   +==================+============================================================================+
+   | :any:`numpy.pi`  | :cpp:var:`xt::numeric_constants\<double\>::PI <xt::numeric_constants::PI>` |
+   +------------------+----------------------------------------------------------------------------+
 
 Linear algebra
 --------------
 
-Many functions found in the ``numpy.linalg`` module are implemented in `xtensor-blas`_, a seperate package offering BLAS and LAPACK bindings, as well as a convenient interface replicating the ``linalg`` module.
+Many functions found in the :any:`numpy.linalg` module are implemented in `xtensor-blas`_, a separate package offering BLAS and LAPACK bindings,
+as well as a convenient interface replicating the ``linalg`` module.
 
 Please note, however, that while we're trying to be as close to NumPy as possible, some features are not
-implemented yet. Most prominently that is broadcasting for all functions except for ``dot``.
+implemented yet. Most prominently that is broadcasting for all functions except for :cpp:func:`xt::linalg::dot`.
 
 
 **Matrix, vector and tensor products**
 
-+---------------------------------------------+---------------------------------------------------+
-|              Python 3 - numpy               |               C++ 14 - xtensor                    |
-+=============================================+===================================================+
-| ``np.dot(a, b)``                            | ``xt::linalg::dot(a, b)``                         |
-+---------------------------------------------+---------------------------------------------------+
-| ``np.vdot(a, b)``                           | ``xt::linalg::vdot(a, b)``                        |
-+---------------------------------------------+---------------------------------------------------+
-| ``np.outer(a, b)``                          | ``xt::linalg::outer(a, b)``                       |
-+---------------------------------------------+---------------------------------------------------+
-| ``np.matrix_power(a, 123)``                 | ``xt::linalg::matrix_power(a, 123)``              |
-+---------------------------------------------+---------------------------------------------------+
-| ``np.kron(a, b)``                           | ``xt::linalg::kron(a, b)``                        |
-+---------------------------------------------+---------------------------------------------------+
-| | ``np.tensordot(a, b, axes=3)``            | | ``xt::linalg::tensordot(a, b, 3)``              |
-| | ``np.tensordot(a, b, axes=((0,2),(1,3))`` | | ``xt::linalg::tensordot(a, b, {0, 2}, {1, 3})`` |
-+-------------------------------------------------------------------------------------------------+
+.. table::
+   :widths: 50 50
+
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
+   |              Python 3 - NumPy                                     |               C++ 14 - xtensor                                                  |
+   +===================================================================+=================================================================================+
+   | :any:`np.dot(a, b) <numpy.dot>`                                   | :cpp:func:`xt::linalg::dot(a, b) <xt::linalg::dot>`                             |
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
+   | :any:`np.vdot(a, b) <numpy.vdot>`                                 | :cpp:func:`xt::linalg::vdot(a, b) <xt::linalg::vdot>`                           |
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
+   | :any:`np.outer(a, b) <numpy.outer>`                               | :cpp:func:`xt::linalg::outer(a, b) <xt::linalg::outer>`                         |
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
+   | :any:`np.linalg.matrix_power(a, 123) <numpy.linalg.matrix_power>` | :cpp:func:`xt::linalg::matrix_power(a, 123) <xt::linalg::matrix_power>`         |
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
+   | :any:`np.kron(a, b) <numpy.kron>`                                 | :cpp:func:`xt::linalg::kron(a, b) <xt::linalg::kron>`                           |
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
+   | :any:`np.tensordot(a, b, axes=3) <numpy.tensordot>`               | :cpp:func:`xt::linalg::tensordot(a, b, 3) <xt::linalg::tensordot>`              |
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
+   | :any:`np.tensordot(a, b, axes=((0,2),(1,3)) <numpy.tensordot>`    | :cpp:func:`xt::linalg::tensordot(a, b, {0, 2}, {1, 3}) <xt::linalg::tensordot>` |
+   +-------------------------------------------------------------------+---------------------------------------------------------------------------------+
 
 
 **Decompositions**
 
-+-----------------------------+-----------------------------+
-|       Python 3 - numpy      |       C++ 14 - xtensor      |
-+=============================+=============================+
-| ``np.linalg.cholesky(a)``   | ``xt::linalg::cholesky(a)`` |
-+-----------------------------+-----------------------------+
-| ``np.linalg.qr(a)``         | ``xt::linalg::qr(a)``       |
-+-----------------------------+-----------------------------+
-| ``np.linalg.svd(a)``        | ``xt::linalg::svd(a)``      |
-+-----------------------------+-----------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------------------------------------+------------------------------------------------------------+
+   |       Python 3 - NumPy                               |       C++ 14 - xtensor                                     |
+   +======================================================+============================================================+
+   | :any:`np.linalg.cholesky(a) <numpy.linalg.cholesky>` | :cpp:func:`xt::linalg::cholesky(a) <xt::linalg::cholesky>` |
+   +------------------------------------------------------+------------------------------------------------------------+
+   | :any:`np.linalg.qr(a) <numpy.linalg.qr>`             | :cpp:func:`xt::linalg::qr(a) <xt::linalg::qr>`             |
+   +------------------------------------------------------+------------------------------------------------------------+
+   | :any:`np.linalg.svd(a) <numpy.linalg.svd>`           | :cpp:func:`xt::linalg::svd(a) <xt::linalg::svd>`           |
+   +------------------------------------------------------+------------------------------------------------------------+
 
 
 **Matrix eigenvalues**
 
-+-----------------------------+-----------------------------+
-|       Python 3 - numpy      |       C++ 14 - xtensor      |
-+=============================+=============================+
-| ``np.linalg.eig(a)``        | ``xt::linalg::eig(a)``      |
-+-----------------------------+-----------------------------+
-| ``np.linalg.eigvals(a)``    | ``xt::linalg::eigvals(a)``  |
-+-----------------------------+-----------------------------+
-| ``np.linalg.eigh(a)``       | ``xt::linalg::eigh(a)``     |
-+-----------------------------+-----------------------------+
-| ``np.linalg.eigvalsh(a)``   | ``xt::linalg::eigvalsh(a)`` |
-+-----------------------------+-----------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------------------------------------+------------------------------------------------------------+
+   |       Python 3 - NumPy                               |       C++ 14 - xtensor                                     |
+   +======================================================+============================================================+
+   | :any:`np.linalg.eig(a) <numpy.linalg.eig>`           | :cpp:func:`xt::linalg::eig(a) <xt::linalg::eig>`           |
+   +------------------------------------------------------+------------------------------------------------------------+
+   | :any:`np.linalg.eigvals(a) <numpy.linalg.eigvals>`   | :cpp:func:`xt::linalg::eigvals(a) <xt::linalg::eigvals>`   |
+   +------------------------------------------------------+------------------------------------------------------------+
+   | :any:`np.linalg.eigh(a) <numpy.linalg.eigh>`         | :cpp:func:`xt::linalg::eigh(a) <xt::linalg::eigh>`         |
+   +------------------------------------------------------+------------------------------------------------------------+
+   | :any:`np.linalg.eigvalsh(a) <numpy.linalg.eigvalsh>` | :cpp:func:`xt::linalg::eigvalsh(a) <xt::linalg::eigvalsh>` |
+   +------------------------------------------------------+------------------------------------------------------------+
 
 **Norms and other numbers**
 
-+--------------------------------+--------------------------------+
-|        Python 3 - numpy        |        C++ 14 - xtensor        |
-+================================+================================+
-| ``np.linalg.norm(a, order=2)`` | ``xt::linalg::norm(a, 2)``     |
-+--------------------------------+--------------------------------+
-| ``np.linalg.cond(a)``          | ``xt::linalg::cond(a)``        |
-+--------------------------------+--------------------------------+
-| ``np.linalg.det(a)``           | ``xt::linalg::det(a)``         |
-+--------------------------------+--------------------------------+
-| ``np.linalg.matrix_rank(a)``   | ``xt::linalg::matrix_rank(a)`` |
-+--------------------------------+--------------------------------+
-| ``np.linalg.slogdet(a)``       | ``xt::linalg::slogdet(a)``     |
-+--------------------------------+--------------------------------+
-| ``np.trace(a)``                | ``xt::linalg::trace(a)``       |
-+--------------------------------+--------------------------------+
+.. table::
+   :widths: 50 50
+
+   +------------------------------------------------------------+------------------------------------------------------------------+
+   |        Python 3 - NumPy                                    |        C++ 14 - xtensor                                          |
+   +============================================================+==================================================================+
+   | :any:`np.linalg.norm(a, order=2) <numpy.linalg.norm>`      | :cpp:func:`xt::linalg::norm(a, 2) <xt::linalg::norm>`            |
+   +------------------------------------------------------------+------------------------------------------------------------------+
+   | :any:`np.linalg.cond(a) <numpy.linalg.cond>`               | :cpp:func:`xt::linalg::cond(a) <xt::linalg::cond>`               |
+   +------------------------------------------------------------+------------------------------------------------------------------+
+   | :any:`np.linalg.det(a) <numpy.linalg.det>`                 | :cpp:func:`xt::linalg::det(a) <xt::linalg::det>`                 |
+   +------------------------------------------------------------+------------------------------------------------------------------+
+   | :any:`np.linalg.matrix_rank(a) <numpy.linalg.matrix_rank>` | :cpp:func:`xt::linalg::matrix_rank(a) <xt::linalg::matrix_rank>` |
+   +------------------------------------------------------------+------------------------------------------------------------------+
+   | :any:`np.linalg.slogdet(a) <numpy.linalg.slogdet>`         | :cpp:func:`xt::linalg::slogdet(a) <xt::linalg::slogdet>`         |
+   +------------------------------------------------------------+------------------------------------------------------------------+
+   | :any:`np.trace(a) <numpy.trace>`                           | :cpp:func:`xt::linalg::trace(a) <xt::linalg::trace>`             |
+   +------------------------------------------------------------+------------------------------------------------------------------+
 
 **Solving equations and inverting matrices**
 
-+--------------------------------+--------------------------------+
-|        Python 3 - numpy        |        C++ 14 - xtensor        |
-+================================+================================+
-| ``np.linalg.inv(a)``           | ``xt::linalg::inv(a)``         |
-+--------------------------------+--------------------------------+
-| ``np.linalg.pinv(a)``          | ``xt::linalg::pinv(a)``        |
-+--------------------------------+--------------------------------+
-| ``np.linalg.solve(A, b)``      | ``xt::linalg::solve(A, b)``    |
-+--------------------------------+--------------------------------+
-| ``np.linalg.lstsq(A, b)``      | ``xt::linalg::lstsq(A, b)``    |
-+--------------------------------+--------------------------------+
+.. table::
+   :widths: 50 50
+
+   +---------------------------------------------------+---------------------------------------------------------+
+   |        Python 3 - NumPy                           |        C++ 14 - xtensor                                 |
+   +===================================================+=========================================================+
+   | :any:`np.linalg.inv(a) <numpy.linalg.inv>`        | :cpp:func:`xt::linalg::inv(a) <xt::linalg::inv>`        |
+   +---------------------------------------------------+---------------------------------------------------------+
+   | :any:`np.linalg.pinv(a) <numpy.linalg.pinv>`      | :cpp:func:`xt::linalg::pinv(a) <xt::linalg::pinv>`      |
+   +---------------------------------------------------+---------------------------------------------------------+
+   | :any:`np.linalg.solve(A, b) <numpy.linalg.solve>` | :cpp:func:`xt::linalg::solve(A, b) <xt::linalg::solve>` |
+   +---------------------------------------------------+---------------------------------------------------------+
+   | :any:`np.linalg.lstsq(A, b) <numpy.linalg.lstsq>` | :cpp:func:`xt::linalg::lstsq(A, b) <xt::linalg::lstsq>` |
+   +---------------------------------------------------+---------------------------------------------------------+
 
 
-.. _`xtensor-blas`: https://github.com/QuantStack/xtensor-blas
+.. _`xtensor-blas`: https://github.com/xtensor-stack/xtensor-blas
diff --git a/docs/source/numpy.svg b/docs/source/numpy.svg
index 1ea8979f4..63b3ccf6b 100644
--- a/docs/source/numpy.svg
+++ b/docs/source/numpy.svg
@@ -4953,7 +4953,7 @@
                inkscape:connector-curvature="0"
                style="fill:#6272c3" /></g></g></g></g></switch><ns1:pgf
      id="adobe_illustrator_pgf"><![CDATA[
-	eJzsveuOJMeVJvi/gHqH2B8NiNhRjLv5XVg04B7hodWi1U2I6p5eNAZESSxJNVMXbrHYPZqn33O3
+    eJzsveuOJMeVJvi/gHqH2B8NiNhRjLv5XVg04B7hodWi1U2I6p5eNAZESSxJNVMXbrHYPZqn33O3
 Y+bmEZkZKTZFVRgzmRUZ6e52O3Yu3/nO3/0fX3718/mbD797/fPmWB1evvi7vzt9fP3q04ePvzjQ
 24dfvX37/XefPuJbP/vNF4c6HCv81Pyr8Wv55L+8/vjdmw/vf0G/O9b42wv+/c9++/HVv7/57vAv
 r77/458+fXH42fr+058+4M//5fCr978/foGf/O2bT29fw2fff//u2z+//fDHD29+/+H98dWbL+xR
@@ -5025,8 +5025,8 @@ ZErgmaIKqgzGdslbvkX/Df51hBENdY+AnxbGe2BI0zF04xha+KEiXBn+OoDsmg7h0FUHUOrwEgj2
 oPTqFfcM/rw/DjViEMfjNAb3IE+9At0fx46WFcO78HnbqQrwczi0A/3toYWLgrSPt3zMH+ld+noC
 a8r+wBB78BfhyCOEjzpNyW0e/ld6nwmWR2cPRh9tmiO6jw5VcumrH8SrLeeIhFAwww7A4atPr1+/
 PZz+/JagKIhuyN6BS04O2mCKlUo3L99MwpF8S6XbVr6RdAPJ1ppsc3KNpFrjJNpssg==
-	]]><![CDATA[
-	DCVZECcBG5+J6UmOPpVYbHiylIouAZRJ6gxQV0B0BmxcARSLPJsBWUucSRWMVMVgNWOVmFGqavQa
+    ]]><![CDATA[
+    DCVZECcBG5+J6UmOPpVYbHiylIouAZRJ6gxQV0B0BmxcARSLPJsBWUucSRWMVMVgNWOVmFGqavQa
 HQLdSiNDMSKkkSCNA3EEqJUIkEZ/RlFEJov50EucQosF99IY0Mrag4sD1UvIVGYf924tGpDPrZ5f
 V2YYTsHtGebPLz/L8fTSmZ7k7HKzbU6h6Gw4Jc6gzNFgrqA1m3VzA4EuOnv3gpv9fP5ncyJcxHlQ
 nH8wAnUNnDluKBHDkDiGVOGc3ArYrgGaf/Lyt0kEcCisgdnP+5PmVDWSYDOa6iQ6p6ugEW7NaTqj
@@ -5098,8 +5098,8 @@ wBC1SM2gaVYMTquoXsgiiVa9JVqtkmg1UKJVnZAwUPUQkL0oRhcKEHXQeyxQdyZ69JGo0X2FkQfV
 oNhUoChgLQTXYliRKUFbKGLEY0YUNRIrTRQDFxJs96GLTdjCPDRTgh4Zk74VECQZ5uWSo0d2enO9
 L2lP0gAMaBS3OX3NltoUu9qEsGrnY28t+2W0nPOEVZlyUzX3PObY++zzPP+8kIFu9TRr8vzezEHP
 UTZOV3mW9qO8YubUhis+h2s8aoJYJO/ykLalYS+2mupS1Lst7LbyS/TdjQ681aJzvQ==
-	]]><![CDATA[
-	O9fNE81dMFq+RY1/MZuA22rtEltCQg+nAiGjaoruqw0SH7eTZi73Vhw80VUjts5iVdfOxEIjsQAX
+    ]]><![CDATA[
+    O9fNE81dMFq+RY1/MZuA22rtEltCQg+nAiGjaoruqw0SH7eTZi73Vhw80VUjts5iVdfOxEIjsQAX
 DwguHhBjAmxpSUU9oc2O9M9ndg8ijjmLBQQXA+jk7FGWg1n8/OyUrAiDEAiHQJ4syy398e2a2Eis
 UsRmvz1gl+RNd831nVBo6St4m664srdrWH8ur1xtJ6LIK65eW7XpKuWXrs9BqMfVQ4o4v4WytU8u
 TnUh9EqVRaoaQgFynGo0D+pM6BajI+dVSBksqSe1t8gTR5uUeLwWhGNDPgyODCkYhGI4DAF5+cLi
@@ -5171,8 +5171,8 @@ QtcIYi2pKJsl0rHjlPXNiWr9LNFRamlZLemejFBTfNpq+LSITovYNKv29fLFpt6X19fXDJUWEWmp
 pu6QaFTFyzOOpnyjRbbRhJNtwzQKMs+4RiVBQbnZFgbw23hfXCuLnnOxbUhHmOmeePXSViqmMW3a
 WGjkv4YrDknrN60rtO3L/KJwxR0YfsK3H1uVtxwWBTaSZ+SPzYxW469dbrb5MS2pgTILgPqpL62q
 Mj6hDfsNrnjlt1bZ5RENrqjeup12C6jdNEd0j18BasdPcDQOo3UVopYDE7hjgI/fIQ==
-	]]><![CDATA[
-	EvW2rkdDV1v1RIqihQn+pvFY7fuvJZzwWinRijVW+o4lhQdkeseE9UZv2nMKeyyb27fwXj94dvjn
+    ]]><![CDATA[
+    EvW2rkdDV1v1RIqihQn+pvFY7fuvJZzwWinRijVW+o4lhQdkeseE9UZv2nMKeyyb27fwXj94dvjn
 vTA/rf3lqD10efVTw6N9DPChGoekY8Q6dXuaji1YRp4x4P6L3RvZLKfBt1/gIqoeEtjMQpsWtIqB
 zVjtfIl4UtDOL5IWbYnsEmCyyn5JSnQe4OQQZ+QHhjHQMKegypVNNdb4641FVdl9PX8qnxSO2Rcs
 z8igmvL7CkGvMfzqlp2tRaog5wqUUKlvl61aamHUGy3zp3g9srUqi6Xws0+I8nMlgWgK82goOs6Z
@@ -5244,8 +5244,8 @@ WeK1Pds1kjrhDdfKhh+wiHfvfzB++l6J83vlopcfCpW6n+d6xLafVTMIwxHs9XAYxyOahLtVD/LP
 SSVyKhyOFQmQRp9+qLqRqphbkXNo8c+H8ViBDe6LkD/1ElJ9QWuYW+kEWM2gv/sS5q18NfxZd6n2
 WHdD4wswPMfl+Ml6K9eA84JFB3otri5FB+Ca9gWTNB1DB5O8Lbpw75X4eWqt2FDLiINFAxemugij
 fcW/bupjCx30heufeAWtk8HTeWy1toX9gBMeaLCx7sVU+AEWHqyB9ogllJN6Gc91zQ==
-	]]><![CDATA[
-	0t7QftRUcqPe3Rv55x453lpPBLZy95TRzuqRVLRv8HJSJqS2fXQE/QlWMf0gHxp5t8Fl+mM9TKMv
+    ]]><![CDATA[
+    0t7QftRUcqPe3Rv55x453lpPBLZy95TRzuqRVLRv8HJSJqS2fXQE/QlWMf0gHxp5t8Fl+mM9TKMv
 fHL/pe6upFGVS2lUX8DAt66Uxm7mpJZBzqmblbb5LJTNqDjjMVTT8XGi4nAo/lHwM/UVCvsF9FRU
 hVERron26kTK70CKLyi9oPBqMUBUcwOmZnEhQEnpYjivFgGcpQRgwyUAh5UCpBxe5uByJWHl2aC3
 HFCuOtAM4OzMQ8k5hH4/jIyhozQw11MClCU+iCqtwblRataninRUMFMV+mJKtFegVX2uMoPoaS+0
@@ -5317,8 +5317,8 @@ QXPHDXMy4M9wyT5D+DzfFfPsc82/1x98zrhSO8AP+FvsaH0Ecdhih0v550++GD/VpFglGnyY6TB4
 onlgSClpcHWGc7CyzS+FnqOqzTm7CjLXfF0FlDOYnAp/SZEfzcjtqLDnYCVQtezyKslACg/vHDh8
 sOLIpF5LFrkWLY4Fx800lyKmdrRnBJ1qBqoyOUnRjQhC5jFVENJKGWeqSg6mSDLgCE0SViK54K1C
 u7ig7UzjwEVqG1OuF6IGW6m0dCD1EVXqqDzWVMgUVUehUSUlGlVoNg3YJFODjBTnlw==
-	]]><![CDATA[
-	L0CbU54lyct0DEueX+msZbmvv/Y5CixwGyQKoV8MOmZvziqg5O3X2b7OAmI+kaI3k+I3u69J8scm
+    ]]><![CDATA[
+    L0CbU54lyct0DEueX+msZbmvv/Y5CixwGyQKoV8MOmZvziqg5O3X2b7OAmI+kaI3k+I3u69J8scm
 I8FOvzrhVlDKLqXt0i+mvq42X3e8NupuLUpuzKzzai0+JwOYcHmfCarN8GxVYsFwkEjQZEFuCjCH
 awSvz9uHv+4r3jYwNJMxQsocoWZlCTy70W4f7x6tIHhvqGtFXCeMEUSvvE558UbNXBstEt5LecLW
 IuLBZQJexliAkTPaTlL2UEsejpKSy2UPuywvkHLdpJxFLFShhSlmyfjVDEHN5E0LUcR83FIRCgWy
@@ -5390,8 +5390,8 @@ kVCYaRNYnMV4PLRm64Pfgm0LcFvvh7eqgnmcJ60puBOhyFlpnb1Vgt86O+AnyUxbSl54UGSmHJuR
 ePBOeayrY7LLTHt7dZSYaRUi0wnawxA1xiVr+I8gjBtXqWmf43rKTctXiMSfUhTZX6xX/IeWR97h
 p73zUmkCfywVHWluHaGsgFVG7t5VitrnuWDOUNtj7n/K3WSksvkPNxlqn3wxZahliNAOpazWuX4o
 Qe3dF7u7MPWWoPbua90LDprKzFHw9qE+dA4eJERQs/BQXqh8YWPZkYuV0A0RzsCHVQ==
-	]]><![CDATA[
-	gkC2LEiEjLjszojiRthNfVU5isWeE+p+YqitLYtIVaSFTRdTlJjEfygaLU2SFz4TBx2z0F6EkdUb
+    ]]><![CDATA[
+    gkC2LEiEjLjszojiRthNfVU5isWeE+p+YqitLYtIVaSFTRdTlJjEfygaLU2SFz4TBx2z0F6EkdUb
 jKpQkursFOdorvgy2lJEm9haOVe6NfWSFeaYIX3Ocrk4N5oh0gg3HmNWNJUjWyTksbq8aOVJCZIn
 3xLXa2+50S47mnKjLT/65YuLULpwljRlAd712ueL/XzFH98Vk5wI5apF5RaXOC6sQHEeLw+8NOCM
 DgrrSxhfwvbEvuzV1+AkQnR4NDtOpVwigHFuILHgHBtTkuHBWYWdsDCfHA9zbUzMysV8Rl5WMa4b
@@ -5463,8 +5463,8 @@ fcPLXfPZd07ysMWTuHhmXzV9tg/7zy9frC/ZhbS+/0YcSC+LPqWvPr36+PHPh6/+55/Ro+T+hRkA
 dd2HQ2jgNjUeEzA4dYcpAnhjJJx6qlMpu/I7/6ZeXWcpu2n2tl7iH0rXpTe9g4nzECLqn85WykHg
 eax0d3S8GEWu5Dd7t3uzZ+jEH+KDWsmLZgp1N8TdikJIa1/Qo8uD4pquajiM+wb7MsmTwlOFoQbx
 27WgTlTT4S2LOFg3QzPC2/D7MHbyNoi+ccQMEFh0nb0LfwV3PGKKmn6uP8KzwM3a5g==
-	]]><![CDATA[
-	iETw8jZ0Zuwn6EAzHuGpR327lpu1Iyzlxj49YnYBPAL81QQbTy49HYeellx7HKZOH3jTvbdxwOC2
+    ]]><![CDATA[
+    iETw8jZ0Zuwn6EAzHuGpR327lpu1Iyzlxj49YnYBPAL81QQbTy49HYeellx7HKZOH3jTvbdxwOC2
 DemEPWpF6nCBv2ga+Pu6645YRFQ7g1VCQB7W3QRScmpiz0PX4KfrYz3a01Th2MOagUdvoUf6WZjp
 wO/BLrUnbI8TTDB0voNTwXUHPgfj33YgMCsbkuE4DE1Lb4+N9RJHik50eIpugOXxttjB2PehO04N
 6G91BaMFNxJvBTx1BZeZ8OI6Vn17BA1uPEw43K1MwlBjjZ7hMMJg6O36CQauPQwTTE8lfR56mBUQ
@@ -5536,8 +5536,8 @@ fLroGFgQJPVCZ1YXNLPGkOBnUCbVHOuUCYQT55VJYTOgOrufhwBP5zyLkcBEBsR7QBCwhoH6zGvk
 8ZONCXKuOX0aAiKGnECMIUwhyiEeAWTb1rWDTQ3nwasH5JzQ01QMB7cYLqmGqKeZTglZBwJDBeNQ
 RaDphY8wjGz6U2OaAq8PXYWDIbe4BtPi4JDJWRjf0NIKJEu63U3mHTJ59IG1gJJNOYCiTwoGRSXO
 05o4xI4vBmOuiDhicJzs8nGCBP4v30VOpNmR8Qf0GqP53xNTqq/gHCraBbiw0SHWOg==
-	]]><![CDATA[
-	TYXSJQ5THQxqavZkLoT/yWng2pACBZS8xcqMnljLxYHsyjoQxEOyNVlY4oxPS0w6LDeEuZpkkxti
+    ]]><![CDATA[
+    TYXSJQ5THQxqavZkLoT/yWng2pACBZS8xcqMnljLxYHsyjoQxEOyNVlY4oxPS0w6LDeEuZpkkxti
 K67JJZBnn9vTaQt6IAyHO2nhAplEL5QVVnHaCKst3nylq0COsnSSFSI8az7IKsKPbeRjVDWO4owG
 EJoCM89TSxaSCn29Lc55fYBB2apDMovT8igEFWEoNV1JCGrcL9lcl0JP40ax+86oKS5BpEJN4CXl
 oCV3ElHiiN6Thr7sa0c0BJU2zOjeYzJPo6CCeJKOUIMl5jpyEFfzS8R1It2KomqXeOvAmXcwvxuh
@@ -5609,8 +5609,8 @@ II7LrIUZs0yRWYPTQ0JYaiUl9tPRPTCThcV/TYniC5D842T8NqU4s3Ed8uw0FCMdgMJD1xpDFEBB
 7wi1xdWPtmK6D9VE0HNiy1LJEw6e/neaXShQA5dxUOZNSGhsba0DrXF2sfF/rUMuTQcFfW1LroY6
 a51xyalOJuslkDNJlC1lytfFNkMuP7SdgTKpKNaZS0pLhqACDCD3tCzvOrFPkwzd6VSRBo4cPVwU
 RkB1Y6pV7UWALgUOUi13jZihuy9xloFeMQWkD06MjIQl0oyK0KPlvLgc+5nQcrKiIg==
-	]]><![CDATA[
-	biNCahVEKz2IyqMa30y0UmcHFFLnDbPP6n16wTCo0NRoTgmrr4oEkV5IaZsVD1Gag3ShzOUDFEpF
+    ]]><![CDATA[
+    biNCahVEKz2IyqMa30y0UmcHFFLnDbPP6n16wTCo0NRoTgmrr4oEkV5IaZsVD1Gag3ShzOUDFEpF
 jtMSdQ9ZD9HzVOvHxXmjEbsC1OTfIgXDsAzZ1D/ICpTGAARWTgHp6obW6r/RknkZQm3zrt/n9XkO
 09h6Sqe0qWiNisVUBgfcY+bqFH7JgdMqTXutkgQDq+Y0hMHY1Lh+TZi5lk0eqwhLEQ1kFnLsJ2rl
 WfYOKhVSpENcs/w7F9el42xpLV6YPB1dF6dHYp/aN3gMbNdUMgYZ1yWbR4nDA9MSHgj7RpVHNwYz
@@ -5682,8 +5682,8 @@ GYo2OVDkx37Y89PE3rRaURcgCRmo7U5GKzGOhiqWrdWESnbylNdGO5K696QfMVCsnoYkHj2txlMb
 jjZqB5J26YkpWgLM4Ch2WoVrAVL2UJG8eWReoVHhl4Ht90/yEb3FZY3agaTtPfFHE0jvLxqSdPSU
 9p54OLPRieSxJ409YBWGCchiDwxYoB5RxX3oNJmzIYPa5eT3T/KVvNYljdKJJe198VcGJJKNLxNN
 PvrKW18yIGv0gOWxL7mLJT2irc6uFcpCMyKFSesxLur5TLXV30Xh1qQj+HmZHojc3g==
-	]]><![CDATA[
-	n33HUHFXTUTh7G9zQtiwlmYHIn/pj918esL9IoGuQNKFo/EJtlnEPE2JtpTR+I00SieWtPelXxmQ
+    ]]><![CDATA[
+    n33HUHFXTUTh7G9zQtiwlmYHIn/pj918esL9IoGuQNKFo/EJtlnEPE2JtpTR+I00SieWtPelXxmQ
 BEZD493el18ETxvQbHRgyZe+7H0JCs+npy2Svdw7wQjf7PwH1xfEdYiGVIde2xDkJ9VVKgqFbg1P
 ZO7o1T41cA7hZcEVHjoNW6c2OmvoT1znTFeS7/yKI9zKyWTvBUplFLwWo0WaDqebS+qgAoQEpdTi
 bNZORG3vz75TKMdwG6J09pe2/nRYS7MDUb/09xvtNHB4ud/8YAZ26rqqlG4KgPmZqjZZHVKVM1C3
@@ -5755,8 +5755,8 @@ jYO+yZW2j47VNVnLg9+QACD8x7HWOhe38COPdrI22Z3o1erJiuAMQso761OK21jkNsDLmC8zu/Jl
 4oQmvcy6CjpepUrW8BcRiITSdCyoTur1zd50PNu4rsz5ys50JbfPTXRaOzKNbl1n+3zdEO1oJ10Z
 0g7Uwa+fX+lmY7vbRXTnsQLcetPPr8D3ZLBP8wZlbjrP1zcX9Lr09vm6SXcu+t7dss1bP98X4xjn
 yYTV4LEyt80IojAsv8LGKgW8cL3BfkdWtyF/nhIh/JGmm3derevy9a0pXgZ2Gf6Vow==
-	]]><![CDATA[
-	H93O1VWS39bXgOvC3Rb4NsoT420BP2FeEF66LeCVYV9Zu/LSbSF0xNsGXKfxDuFtHx+DnMutg9mW
+    ]]><![CDATA[
+    H93O1VWS39bXgOvC3Rb4NsoT420BP2FeEF66LeCVYV9Zu/LSbSF0xNsGXKfxDuFtHx+DnMutg9mW
 24Dr0l734DqoE+eNj3zc7nAuzuvKPbcJXvnsnSPLId8+1xbbQl7ndl2F6yb+5ra8r28ifte6urOr
 K5cX4LZl183dd+dzVknlnNuJuPPY926hb5PUdYPO3hc5hO4muorEBam0Fzv0CExxleTcy18Kd1Cf
 DQt++jHRpKEEFyat5K//mL/KL//xqweF93XhfasS8Y5h4Ftmxos18h2j5dbpRRn/ex68t9nxH3TB
@@ -5828,8 +5828,8 @@ gk80P2NMfzH+z5eK11Jw3O29uSLn/kvTwnrmcbHgFzeP/+gBactpiC6jh/AlRJd5AoA3et+D4Hig
 CsA6yLF2BpJMw8CUmrQcQ6f9ZHjoWRqPHvT7Ip2RPMo99R7lezx4pd8XxBjL92VQrDQuPQgwwQNy
 ncPAQPT0n/743377p//802//+V9//rt/+x8v/xmwP4TXrdVSfv3yn/7bbwfN/NPLH/7Jn/zxTz/9
 ++tf/utv/w5tf/3yv6Dl/4r/w2MZRN5gjKI5Rtd1lRqeOmoCHzKUwLpO0ocosGWNgg==
-	]]><![CDATA[
-	8zrHxm/xMDy1JI3ndHytijWPK1Dm6OqCoOX20DYOiU6A2SvWYwpPX6T+pRUlmcjPNjJ4jjyFzkPs
+    ]]><![CDATA[
+    8zrHxm/xMDy1JI3ndHytijWPK1Dm6OqCoOX20DYOiU6A2SvWYwpPX6T+pRUlmcjPNjJ4jjyFzkPs
 X6LvMu7YaxagK05Wg57G+VExzKGHkoo0zmOZFOgV7T6E3wMhjMOjROlZb2T4IEPZs1RqkyWv2Su5
 +7m7whlwsF5+0u8XqJA1trymR9iVDGryelpzkKatdz1/vbd3lxiNXdH9CEXHn5ws8SBfJeVjBf4n
 rnH2yihq0iWORUm9TfL3SZa95zqXONp6tDgWQQ9glXlXH/r/pCl2OK5pu8cd6MI8Kr5Ez2DvepIt
@@ -5901,8 +5901,8 @@ DHOkmDMwlC5DSIiGEQxFVcgmBogfyKEtShqLdDnrCcH8Z0j+O/Jw5c7gxBPHXEbwupPAb2PRYfCS
 JC6iJTQnRxYx2holnhFgZE6mVvTW6iGvN45hoOAugqvLJCMkQb14KmxkBK2pqyyV+X0OTeZGzJuB
 qXS5yZSS8awzm/GgM858g7FqKasTTyX3sd6x600gNhyiA7FHN7zuEBb6KF6dwkz2eUaOSISBkKJL
 2hCSkxGu90GuGDJ5CoZYBaj+TQpXaHpDZYsSyUjaCOITTl57I4mcYarudBZu+eqr2w==
-	]]><![CDATA[
-	1bVfqiaa5bKkAlAE16vBu7ojawi6cORvZJrqQurwTGrUf4FcZlQdcuhKayyvAeh7VVrjkJnHMUxx
+    ]]><![CDATA[
+    1bVfqiaa5bKkAlAE16vBu7ojawi6cORvZJrqQurwTGrUf4FcZlQdcuhKayyvAeh7VVrjkJnHMUxx
 oLEbgKdZNHSY4HKJIC2s6rkPoWpjDro9WnpjtICXonClzbEDrnrF0PI3tmVpnJNubBBCxoBfrnNY
 BcYsu5g4esMERjXxJbVhkWwo+Q7JMiYgRTZ10VGSg7GFGM3p1bpJl13tIhrggL6KF0cW8SfDoGJQ
 QuSH8gqVbeAfE5PGwyzWCYrFnGw5Ps4Jhqo+2gyrhHGtKRRnCaDI01UEIGdZXAVagVcNg9GjGfgq
@@ -5974,8 +5974,8 @@ dbJp7GvsLGMw6Ug94zgf9yikH4sJrfFFzEMTOTIi1SnKJDQLAM8tGakvynRsS809DeNBb+a6E1dt
 jbNQ4papEpuZUqoVp47VqvZVlhoEKFF3Eu9ofvWWdM0orPWrwinyleFdQxN6VYLSPJ6YNYdPo5BZ
 3UU8hKVxaDWHOC9ZKuvywj05CzNdir0i5iHosqsEG7M5NqvVTo1I+lCO5sybG1Gfoq/pPV8Vrgah
 ymEVP1DM0jQLWm/RXL91tcYBLtaNuko8gFsQup64GCxzpnDcCgM1j0/MgIZZgyZn8A==
-	]]><![CDATA[
-	dbRoIkp9lg1NZgQpbDmwWTuLmi8sF2ByshKZx8tAjW1M7L4SBEEDCFDLQ0O6gtmRs6V7AyhmFGTb
+    ]]><![CDATA[
+    dbRoIkp9lg1NZgQpbDmwWTuLmi8sF2ByshKZx8tAjW1M7L4SBEEDCFDLQ0O6gtmRs6V7AyhmFGTb
 uQWDagkDgxfzdLCCjYn1OAZOD9W8+eLMYEl885ndO4bpu5KSpbCWaAVxMuv8wGVIxTmD9wuMJNya
 0SO1tgcC1UcS+3J/uBnIzXA+S7NkxxcfTdjJ+mqdgRisxl9h3ccwSEEr2iBT76JnjiPwKqOoTi9D
 J1HtGFrRnEI6DYY4S1WkeWsBq/Na0FKJ3bOCRC3pQrHl8VZKpnCAAWHwKu1m0eGwkCbtzpzV6Mx8
@@ -6047,8 +6047,8 @@ vAWgDomV0cFJMl2NRmCk1tKgRied6Ob7+b4Rd8FmgO24BX7p7WLVN3dGZW1xF0y37El4eZClpFXr
 Aid7BkB1gHdiT560A+XK7XyVHCDenKLZ3/Hgm6cIJjn05Fs3OKGI6zlCUJaKf5IzpeF1tVjXtB4S
 DZ+fEvq4D9cBF/YKnOaSYks6EH6XZewuYzuUDTwZsnyZyE8+WbvZC/SiY7tArWrMO0D3Ouhcak2S
 c3BILqRkyRmLZDXw3K7qaCNgbW/gkuV+A0UidnoiCFjF2Af3OMcrb3p5+wkRvtH5lw==
-	]]><![CDATA[
-	fZlN3WvXKMSV+NijfbFt5seWHfjvsLu4zl65IVWnjNMEudhG7snEzdMuMHDPoYy8OuffTWvmsBYw
+    ]]><![CDATA[
+    fZlN3WvXKMSV+NijfbFt5seWHfjvsLu4zl65IVWnjNMEudhG7snEzdMuMHDPoYy8OuffTWvmsBYw
 g+PkoDV4O/nIWzx1c4hcYfX98+OccQATcbEXYc9tcweedtDyaQRzrIK342mE5xAxjn6bdvSI/gm+
 AKQ3iKX7IVPtBSd7os6SB+cJFpel+G6NBgXJlIThbUGp9eQVaa8BxI+1Yea7tZ/4aTQpryZNF4Me
 Cs9raf0gfx+6GKW/YuMwwo75MHp3mpxcgQnshXLqmwjE7t172wWt/Doe6okiUybGNJpjKKU5w3Bt
@@ -6120,8 +6120,8 @@ cwo393RS74nRPYphhWwfoSFcVruVkrfwd5GF0FO4u+aPP72L/OqRRn4Mm6RklwWq8lvmdMqXEzQA
 8nOLCoR+AOyKIzd9JGKkCusJSScJGCYWhb64d9obFPj8YNiFJFqNYjQ7iDxbLgM/wpPFPQZKu5vw
 Efns3RtYoVDTMgRBR4Dm2/YS1lLnFiveQ9WLHiaV5GX2VAYOQTuvFDyM031iSi6uC3qZ4zxCHKB2
 MGMi+yIDFPBtnjCCBXnk3mQZ2Zf8sB6md4SPsdOCD38x2aMSt+Zqr3DKe2qbWJuSVw==
-	]]><![CDATA[
-	3aBcZoypDacGlCu56yRO9bXMT7MpOMRoLRT19el4YLyA61R95JykAEtjZ6uaGF3kqRMeJlkHp+73
+    ]]><![CDATA[
+    3aBcZoypDacGlCu56yRO9bXMT7MpOMRoLRT19el4YLyA61R95JykAEtjZ6uaGF3kqRMeJlkHp+73
 bfZXZCm6pa1VmNOf5bRQ8vnZhLxcN18pkj0XK8jORzW1iRtmagqKHd1OCv59X3EwXaagOur08vH5
 XTDnJeeO15xXo/TpE/vjaob8tPNcIs132LFbT35/lWKKw7iqzag0psfEbJj2lYvdoxhMXRDfpraL
 UeNLJ+OsmLFaYotaFX1fSpfpAzTLxNioraWEIHhdO8t78mv8SLz37WFz7LEuzEhOVYZYwgpqLuoq
@@ -6193,8 +6193,8 @@ YJvdaLR5GZi/WSeFbK+BaRxZIXkU0Idsp82oI/GagC1FqrET7CNZ+G9Yql5vHv2lVUSsIH9dPLtV
 Q/noiZT/dW7vadoO5wTLF6cdEhvQfFcdSzBIVk/KSZGzQ8lC9T74o6WRLfKy1grplp1LuyB33lbw
 evvB3GLa1QjFjmYUArIqeBXfRpfV3IhjcfFuacBlsPc6TPzCIfvNthzAB+we2W93/kJusYHdPDHd
 v46TfwKUnsvW6V/9iR/ZP42Tn5Nzex5fzHxO3tR9nN6GDwRxtWq0hvnTMPELg5vHsA==
-	]]><![CDATA[
-	h8kPCFnSYXEG6/Jw2wc7lirVHhSijxr1p4G51iTxPUENql0QH0j5gv58WQ8+U+qO4tCvjugmGaeS
+    ]]><![CDATA[
+    h8kPCFnSYXEG6/Jw2wc7lirVHhSijxr1p4G51iTxPUENql0QH0j5gv58WQ8+U+qO4tCvjugmGaeS
 OTroeF/Hj9vdbHNYphn1ATsaBxwcakbgwUIbTNRLvZr1RFj/oxFcIu0El//rHOLJiBNGUKJ0kvDJ
 oAk0Okxa5RPuFLAV40Fgpm4c0+muw6xlCdQPzkYzFlgVX6fwL5ndYntDmp0zyJ7odHwtjkSyv7Cm
 NVidWBsoG2aXfzK9DtYxzYBMLPnWQQt8vMviPa4H3A87nIoiIo3iIGIpNF/0sGgGj1VevEindXbj
@@ -6266,8 +6266,8 @@ yknSVqdWV+PCpzNrZQfhQen+uPIGOypBajdQBNBpkCzIYQlfzC1P+9OPctroAxrmv/NHH7t+Td+3
 G8nwsPbdP7ydWH4TOjnzzh0f1bBUvn7cm3eqNXm0M5aYzMs40bZYEo3pudExKWxgYC+YZA0sonRF
 gY7dk/3TMPkXHh44HqqksT5g36SHhVZxqVRaFeoqS17KCAeyOuqzmM/3uPjh+6Kl35LnRWgSg38A
 tmhAOYGnkGtbaJIZAEQGrZCdg+LW6z3Q3y6V/8k/pA/YzyADjCdrSk0cD1C3+sn0Hg==
-	]]><![CDATA[
-	DxjP1KmQWfnQiI5T/jSF+IKkrSOoVXeP1zsH91LsyYKFpt8OV0U8LfCEtBX9uhcgXB25co8QbreJ
+    ]]><![CDATA[
+    DxjP1KmQWfnQiI5T/jSF+IKkrSOoVXeP1zsH91LsyYKFpt8OV0U8LfCEtBX9uhcgXB25co8QbreJ
 3f76ahNNVwyyLJr6Ym552mti71VH8eOv/ejjqMdQBn8V460dXG5WIVAju5rX2kbrYdeCOcUZknTU
 RjK4GPXT1PKs43TQdAVnDfIkylrq3Zc4zfaPHwkuBu2Q88X4sD49rXJ9OYe8m0D4c0Zbguw/QI4K
 idht2AldKm8Cay/GVnAsRCnM+t6vby8OmNOL7wWN1NrRvp+n8Gt6dr2ijq6bdOyvfZClqtbYX/HN
@@ -6339,8 +6339,8 @@ EHuAXag56llCgzgZBWRCPr3Bi/vA4wENgvHm+KsoI1wnKXdOHxnssULsMoGjXCYVZ4ca8c4nGI4m
 EYtCBUDmGOcKO5O6luAfjBXD8z1I8slwpFAi3MUE9czuqAedHjcRxfFp/ArmYgibd1py7rsM6NTp
 dkTnpQyCUhwp93DWEJJMJl3FrRuQ/9aA/Vf4oHuhNgk2t62ZPCA+POQT6i/PyM98KO5Cv2oYyog8
 cYu68qprQ/scQL0DgC7GQqNDVc2I76/X5Hj3S25FEOQpZSoxigMcZo+j6+BbZ55+HQ==
-	]]><![CDATA[
-	sGLrB+isvYf4Z/9azfjwzFCR7SWNgJ1RACczxyWNKsekG1AKDF5eOGV4L2nKh2Q3wnndEsNarCWQ
+    ]]><![CDATA[
+    sGLrB+isvYf4Z/9azfjwzFCR7SWNgJ1RACczxyWNKsekG1AKDF5eOGV4L2nKh2Q3wnndEsNarCWQ
 rEieH6hRZEIlaqvo887hihCYoF28BqHIwr6PwyCVFGZqNrLYEwMk8I5EhAMPWZXH3xH2QxLZuxG/
 a+oBGD+2/yj9UJmcBmF7Ym8HH631hEt2qBeUQQGsfxidxkm27BshbKWfsgxSHHmqfnk9OH5HQSZf
 l4gZIV2+LdHIgZ3EULHkHt/LLoqDA3rmKzbtaa42s3ieXdZvM/Nt4yyWRsOCZGvUfh2yKRnnDgRw
@@ -6412,8 +6412,8 @@ gTK6KGoiBm1o9dVuqgbUsdcpbrEM8neFEDv/qWwm0Qfx+ksBOV4b+4mnwR7GR4xcsXE48vmFgOZN
 SWqKE9TI8q/MqJBzbmgxCc/JszLDSaR9JycSFyjqa0wDsajJ38bzS1B8aIO9zv/9MoU38iYubmTH
 yEo/YI/0bxvgbwxvkayQi5iRY7wEdJS6P7/k50ufACaH0PN1Cpyd1FSIaJHO9o/PRRnn04cRyCko
 36qR4hwlmIglbwkUM6mThZYEFU/NEn41BZsc2IfKJduMg7s4xdYwFkoFUimjBhCIkg==
-	]]><![CDATA[
-	xDgJ+wnqArGzg4DM4te+XRsBegbBiussiBwBKdTJwqXgFABbK3hGn27h+fuVzvsFBKxmgT9gR3rU
+    ]]><![CDATA[
+    xDgJ+wnqArGzg4DM4te+XRsBegbBiussiBwBKdTJwqXgFABbK3hGn27h+fuVzvsFBKxmgT9gR3rU
 9GaiZWmgMAWM+rrsqA+S89eB7Yf/9vf0iJm7V2waKT3RxxUpbjUic6Bx0/efRjJAAh1ixdWIEA19
 QK9zeMvknzxSE7ew2kGKqDU4N074V+j2+wGzUl7VXkqZgeG9IKH+miX0y4mRwUtqERVbVQ0F+Cqw
 TNCTOK5GiACQxMCX9pNqSBl05oFIUhljEIt4oP06g1js0u4DaF+9QZi3EpxCgQhR7D9AMKHTXozE
@@ -6485,8 +6485,8 @@ bPbCbbbacb6cszqOII4w18XIfuiuge0lNSmtmR6vVqd9BCnrMDxmk5uIbw50GGFZiJ5mwy4AsR65
 sgPJ8jyw++uKv3GRkYUvVdMtlvcXlc3FvNVhA+oSICQ8MSQQ1kHxTzSiIIZ58h0/yUAei4d0bi1J
 xDhPhH5r1Gu83DbQ5L4k4VoxcjQMqIQKolOwu4g+jDX7YHH4CB2wpaTR6vlL90A2FB/nBN6qeTFL
 +kCMeB83wRHcsdUnwf4Qrz3oJ3WhA+lM3roZMe4WO1sn8Sx3QaVQYVzdbXEPASYQHQ==
-	]]><![CDATA[
-	yboPHvvF3+vbfroHMVYqsUZAtEtay3qcvcOO6mhattcKfB7mVIxcKooMqUSwfUWZ/ZIQVX5xsTSI
+    ]]><![CDATA[
+    yboPHvvF3+vbfroHMVYqsUZAtEtay3qcvcOO6mhattcKfB7mVIxcKooMqUSwfUWZ/ZIQVX5xsTSI
 rU6FzU+uaW/HaqlRW6Xffvz3Mt1OYqAK4aPIByQ9il2shuQpAUgczcltzqNQkVO68EgSR1PIb+qK
 xbWLnym+PPmlRle093QLISWNVl4ZdUS6ZUBRs5OyIR2aOoXNANmOBrm4dCw2D8l2TbtDEpnbFS1i
 uolzBHyNqE7JdRWIukT/8qO/fzgx+DGv9W8qH8q3m96DqIVi94ajvrWzsabpmtHp+a4nZn2EhqKr
@@ -6558,8 +6558,8 @@ nkIiC1odZkxdjEECzUnmxDmjaxmmqRAEJKiC9AZw4EMPOb6x4I4Nq+sxmSW8kQ895bus8loqg1QQ
 RJBI6cooo2OKiDwmeyUlCqaI4GSviv6WPK/UrrQ4KUgEwRFuZfQFByBnFwEgseAgsVWRTugTprkH
 cVMH+kD6RhD5qlyz9fFPyKps6Mw5SRprCvJTmxd7AudbNEacfsFCQI7AGMVKHCoo/SmCAONdo8wO
 CXupeLnJYyVa6IGBOtJQIzozjPv2iaUjI9eSooxZyIBlJus+ImkbbUDkHw7KiqpaPA==
-	]]><![CDATA[
-	aj4FLnH+aDtCHFb4GN+OniOOu0UFejRa8WGGx7lSjFaNQNkyT7LS9Co9lOIgDtH24HZJWcTAtElm
+    ]]><![CDATA[
+    aj4FLnH+aDtCHFb4GN+OniOOu0UFejRa8WGGx7lSjFaNQNkyT7LS9Co9lOIgDtH24HZJWcTAtElm
 d9AccTkvEdVxfeJFh7o4eEdA96SjqzTqbnAYGMCeVWZllGFh1RUbcTB/mSIgxqxXUyZbLMRigzGe
 F63ERYOYa+YPYMpUvMawgSf2kFGhBjgRlSUdZR0EarYa4MahVsZw8r+JPocyElQIEKCPhBOZFzgr
 AFylcgQHfa8YKLlTwZWfNCbgMVqFmIPXPdlxnKt8WHNiGQPQx5qD6OeO/JnzaQIsMDTQ0oFPIWMD
@@ -6631,8 +6631,8 @@ G9FgAFlAiZcuiuhBDDk8KUIaTCRZLpHNzGcVXOUt9sD0MsClShIAS2ksBeogLScxiwBUJsnhCZgJ
 4IbXi88olDuVL8cYI1DuVelroFMSJwrOdEZAVuRCUVDmY8ALjYEuhq0SvCBFDsKtrBfHgxcu1gYD
 foG/X1ZKWEDpPC0f86vA9wvRrcbskBAPTXiNk15NyGG0HHpU0mMJmDk8CCYbr7Iec8YUrG4pXwcz
 s+cwnlhopZRFBbMrp25yUQsL5fuS5FZexL8AFz4GcBjZbADImQsgOoDlvCLNtoAZ0w==
-	]]><![CDATA[
-	JLZHXPcx7534Aka/bs4UChKJTXKPBcTCtmfOTQmVLdjOVpV2BAbSkVc2Z5+dEHzNRlvrKKfFGAr3
+    ]]><![CDATA[
+    JLZHXPcx7534Aka/bs4UChKJTXKPBcTCtmfOTQmVLdjOVpV2BAbSkVc2Z5+dEHzNRlvrKKfFGAr3
 HBFtq0p1QMCYQzU0a8ZrUGUYhT8g3JxkrEKCjtMNEbrMiZyCPs5Es5ONZUjBA5tVduCKSZFQzscA
 NLSiUTKbrNJOSA1TFRPRgMMl0WJMJMxyFBinMpYV0jKqgAKo9FERoyvBz5oT7+QU9MZk09Pjc8pl
 FscgaYly4lwJGCQkS0DJqQ/GTM7IBvdSVR0Y73kIMaVWlQq6iMVfYLqKOKKC7BVxEuh3So3Zbwv2
@@ -6704,8 +6704,8 @@ Id9SVNHFACvIrcYOU2VsCTknSHsCDrEcS5BriWgrqzpLjFrIpQyEEy6YF8iVITxWSl7bLNZIS6qG
 Y3wsDbSMghggbnaJK6PPCUSSs4uDp9DiSC3Zog9u4i7aYmRZfUTxYPiLnvI+U0k+OGlciuYvrACj
 Kqxg6iV8vIq7MJXmNs/FN0U8FcfI1kScFQyBPQQyHa02msJzaA2hZqbKOJCAyzpBKnkpy6uo6CAB
 xcqUUWaxyrrGO17VKYLYbdLageGRtceQDC8vpAQJeO9Oi0ycmGDF395F9qkS1kE/TQ==
-	]]><![CDATA[
-	NbCg/APEn0QVP4d/AMWWuEsnjgtYAISrusdgFWACILaHr1MelWOO0jfSHWNpAkueFFL1i/PsS4Af
+    ]]><![CDATA[
+    NbCg/APEn0QVP4d/AMWWuEsnjgtYAISrusdgFWACILaHr1MelWOO0jfSHWNpAkueFFL1i/PsS4Af
 3+hcAomwQAc7PpdyoJyvqmbxNmTKxAi3Mp4lHcvVo8AsBn0p7gD2QCP1D1LXXC/ikK80/t5TuCgC
 nfhdl+K/BtEnVYZhON2ZOBrIIkK35McL7hJcDNrz0pEHRGXIBrUKR1nkMRIIC06Rv06V6cHHempg
 ZiuSMRAoxoc7UcdKgQQAAmaRswxluHkDoPCuHGXPgk3lpo7BlBx8aIR79ZrO6YT0wDwQLFcZJ5tx
@@ -6777,8 +6777,8 @@ KLf08I1Y5fWd66EdnFrpj7AR96ZWTmjk3LQGYabiuPcNyKDUGj3Y2hycslae0c1xcGrn3EYOTseM
 oxpZ1pqF0TZG6G+6LNrGSY5k0ZEsOpJFR7LoSBYdyaIjWXQki65XFm2jMWEki554czs5ZNGTOP9J
 G4WY53L+k6Hd5lo6sY05zp0cod6jtC7HfaM2fr8WZdfaNrWN3bC2oo0NZatpIxEbpThF5Hf93OLi
 QOHjhMF9QxTgPUHRXVtn1oTtDi8fGb4M+wE4gFRt+Jo756am797TIdDioanp2eUj1w==
-	]]><![CDATA[
-	tNNawXNc830b6X6Pu+53xE41TPMwJnGZOIGwzBriLto6q43p8E+Ik7m+EtDXUTXaSS5Gf3y0StfN
+    ]]><![CDATA[
+    tNNawXNc830b6X6Pu+53xE41TPMwJnGZOIGwzBriLto6q43p8E+Ik7m+EtDXUTXaSS5Gf3y0StfN
 Hl6eWlieZDVfW7H18Hd8DmbSyhikhus9MxfGsqZMwW0MpE1m0T3BqXfPzq+sQTmet1HnHycx+Iqv
 S2O6snRganrmtump4RnKNi5TfR4bY0jaW6l741xIe+f2nNHqzDHNHRuCa6omeO/Bdubu6J5N89Vb
 E35pY+x4bRrdc+RLNbG4gPzMiTzPnqmsmbO8jcsrj1jLzWctW3hgRpzliLMccZbD6oBaXXr+OVUJ
@@ -6850,8 +6850,8 @@ NcAR3giMJrkyp7EF5A/2FjrqSC7x6BSmZNGrLAtLlMxG6wFY5DwqG+FEy4H0aClBbVxYs4LEnhIY
 Aa2Zn47WC4Q7xQx1ZphGApAIqqn14GMPRbTIAdjb3ral3OGk1xzxUPcQ4BgUSsZblMwp2BIVUNXM
 kMGzpe9eBmCOwp3N0yUDK4PNaSvj2oKsEo5AmWwE6ySDUOhVfYtBaau02Gf5MIDWNsusl5MT+F7W
 udbhZFjpBbISFQypWV47k2AKCyTd1E5vCuSjHu1mJpyS5F5MClybMq9dLjDZZIo0/w==
-	]]><![CDATA[
-	8RqiRrlEpU7tzuITnSprF9wD/jbI2FeoAMxGyLt04Q2wMZXEsFRIBkxypA5M0BGYrugS1XEXmtTC
+    ]]><![CDATA[
+    8RqiRrlEpU7tzuITnSprF9wD/jbI2FeoAMxGyLt04Q2wMZXEsFRIBkxypA5M0BGYrugS1XEXmtTC
 XawhOgB6m/kaSgxUK+ytLZKW3AOwuFrgxPoBsLLq+cJEYGTjkV2fkB5wvVGW8SZg8MkI1z5nOHDf
 DMzEiod2Whpw6YgDRrcAOWzh0irnWEcVWG7kx8KisYXIgc2M2GVjSUOBLHsBOgc2zAW8qpDTC7Ie
 CzpgSSWWMDA/qK4jWwIrfcK+GbharA0IskBJvKaOu6HBjE7mrzDywolkHBjuaCizMgRwDikQiwO9
@@ -6923,8 +6923,8 @@ vNX8YnuISsuOZYpRTobjefWeMXl71Q3vWp59yzgdqbeu/ND7f/i+t10Of6h9//YDP/aB75su4I/L
 blv63h/83sNvvZy+c+3kzZN7r3xOH8/uyi09XJFiZNaPAnV/sh4ahH1skApRHxuhQzSTDVGiVbij
 Y8BdDMA5G4sfuClwVb0VhISFgTPS46282llclydzAUmwOGgC372zU7hO4Rt9mhsao3czfoH+Hejd
 bAPHvXbvZnq93vzAwJ91dLvpYzgGo1rfMDZ9SBsfxmYNaXNHsu4hHaVhrGM8R3skww==
-	]]><![CDATA[
-	j+fYjGSY8RzLkQwcT3sGc+xHssp4jtdgesdzHEfStsGk4znuI2nnYI77MNLxHPcxjAZzYg1m9DP6
+    ]]><![CDATA[
+    j+fYjGSY8RzLkQwcT3sGc+xHssp4jtdgesdzHEfStsGk4znuI2nnYI77MNLxHPcxjAZzYg1m9DP6
 Gf2clD+twjOjwawymJaMp4XMVUvG057BtFluOo6D6R3J8RpPv5Ecl/G0ZzCrj+RYjmeYkRyb8Qw/
 kqM6pHUM4yiNZyMj2cQhbcowNj6kTR/GOgZ2DMZwtF89dujKdXLV6ARqe+rW004/cxu+zjz9tP4B
 CtT4tDO277jw4st2htdlF1+4Y/sZp/X9Qmh81o6LrvBvuv3b3vHt3/6Ob7v9Tf6Ki3ac9fx+vqRn
@@ -6996,8 +6996,8 @@ AuziKOap1H3yVGbd8omOqLU/qgclpxsP/Dyy+pxvuwIBzrHkTejxbYnIDD525E2okr+5FIAdD+TA
 1tsFZtsopWs9VkB4Mn25AkE3TpFvnfRY0MdOnhz/ZqlHRpi0S6ZX9Vif82pu5ld0KqfoOnkzOqBx
 zgU6Zmz4w9ha10aVNH0QTrweL2xA092ty3LcGqeT1iAf5OPGKdPbOvStyqxMW4e+tQ70KSxPT+uc
 4PXWQSAxmerpm3cyaagCjVdlb0PInm+GbOuKIEaS61/Sus9iJIckXYwBwtKu0DSItQ==
-	]]><![CDATA[
-	zg9bJ0F1rgMfYfDVz8CHUytjve2g3OYKg7/LDBcUHIGUgzc6C/POG73iIQ1rrpSpXaAIAr/QwpJD
+    ]]><![CDATA[
+    zg9bJ0F1rgMfYfDVz8CHUytjve2g3OYKg7/LDBcUHIGUgzc6C/POG73iIQ1rrpSpXaAIAr/QwpJD
 L5REwKoENrAZvjTVMea/+QLBV0xXO3zr6z0mwOoCCcjg43LTSXvEIAyVmWrD+W++QDLCpF01l6TH
 +pxpk9BeMm4LX9ZWIoKC8GyVIb5Ij+feoESNPt3xAMa/eSXgK7mvt8O3mar1mADjSkSQoccRNyU9
 GhyYS1aC/+aVkBEm7aq5JD3W57wKKuHiIwrPPQWsZFluBwSsFEXgB8cKM67LgFPSuA/rZXoqDEZn
@@ -7069,8 +7069,8 @@ lfYvprT/IepYU6XKBo0AvRNQdwpR2v8eDAr0KTD6G7cP/QRly/yMde5/kESw/3mJYH8LhFEghN8C
 8VtFmCRC/M9LxM+oPvjv+bhnI+DuVwa9xo/AyXA6lgJ58Pq3p/vb0/1lEg8chRIPCXgRBrwTMCEE
 WD7KwqUGeAWj/c7ef1Lqgf5JBRD/MZkREqhIV4SXGMG7f1kRHhieiDIcnQjAS3zi9ivp/lFi8522
 Y/lig1NbeBUCejQde2LL8NI5rWWC4LuQUlkk+RhMRuaFjn6v2zc/Gb6NZ9nb/6tMBw==
-	]]><![CDATA[
-	0hRQ6go5AW5NVW4iTgjfW6f+nxSe+L9WeGiehU43kh02zn2vyvzth6t++OlQ7jd6v33w3z74L+NP
+    ]]><![CDATA[
+    0hRQ6go5AW5NVW4iTgjfW6f+nxSe+L9WeGiehU43kh02zn2vyvzth6t++OlQ7jd6v33w3z74L+NP
 wUu+fvvgv4Yz9U+Rmd8++C8lNr+6G/XbB//tg//2wX/74H+jD46vfrruDntARk+l33cpQSmNwgIF
 jo/HGWWLVBTd4QuP+uTxvQvaE3utBw0GkgYDSUUF/jvLPX4mO9CNxbBHnEjxCZUnVCKOjj/llKfq
 E2ee0P8ensCOx5UaFsQOgQXuHjytgYXXPKNyIDbB0IILO5jov4YbcFbAzqvnWyCW8PDWEcgJRq0D
@@ -7142,8 +7142,8 @@ udujYlqWO1dc8uTmEI1SnO/KAhjB3XAoO0w8W7lp7rqR9Sqr8OBCUADNXuhgGizme3SWOuKT4EeJ
 6mJAKaE5TO/VJ2uZ+tFkauemZTQNrFdH/1Zehc/qUKd9RbsZK6umFwmpGNwa7eQ6wsV9oUnt7+Yl
 WQ5TUu1gT6MEc0RjR7WUeTmikcztR16LcMoeR/OVD7GhaAE8qvHLr/5x5uw5e1LMvR3FKfq42S7m
 2v07pEkJ41DK9oSDGx24MKke3GfL9fUDCxEADaBDOsuXPjclgOt8HyoblnpL3gzt9A==
-	]]><![CDATA[
-	Wtu1wG/hSWm01kwkQnvcqYUnexUQnOe6466AVGfkocbsrFfKer/2pORWH8zpix0oZCehg6P7IxXr
+    ]]><![CDATA[
+    Wtu1wG/hSWm01kwkQnvcqYUnexUQnOe6466AVGfkocbsrFfKer/2pORWH8zpix0oZCehg6P7IxXr
 +yPQaSx4u1ndLU1e2v3M5etRPtbl1goYwNt2WcjUT4bv6et6pVEsxM9vAZrkSYgxwIDjwKum5qJY
 fNlZ7SifU69UodXodZHW3A/fHZYy4vPqOEOlpqLertCMPWxkauHDB0wiVNMADdLUxgaR3sl+eL17
 m6nXt8IGa0RTzWlhe1B70MamHypc35ZVA7O7lX/LsJLBEGhvoQgoDQqd/JG8+2r/PPwk3ESPxfxb
@@ -7215,8 +7215,8 @@ l9MmGLTicDC5gDVe/naNq0xTTl7+ceq+dV1tfjWW0PbnunFDP7k+VyXvZDgYtjrysC+59JBYDzJD
 lXKoHxUB126k5nVX+svHHMpLYyDwqFTQ97wpwdFpTKR6Z9pvDhrd3ng2EcTzFh6Zj8o+K20wf7tv
 XW0nP7GyS0WOL5ArAvHKyJO/hvJnVS/fcxMJNGg5ve7aJzfrcrd/AuvJfMkdQmIRvNkruLSR1E5H
 wGraWy36POjBTSAUPsFS17FVKGYbmAtzEZPH7Ku614H7OgHCsVOXk8ag3ZDbRt1Mog==
-	]]><![CDATA[
-	x9+RJG76si43RiPXkiur9cm05GGzMak2fkjy2IcgQ6VAlmPOl1Imf+vGPcW2VgYtYCetMuE9shce
+    ]]><![CDATA[
+    x9+RJG76si43RiPXkiur9cm05GGzMak2fkjy2IcgQ6VAlmPOl1Imf+vGPcW2VgYtYCetMuE9shce
 xWw6Q1DBKZxtdf34Jae6fOsEvTHWOgXrHcDcQEMGEtKRAkpFawDIJ7Tu48BfHWkQGDf+hFOvMQgY
 fRXY00BjDB/rbpJ6dk40AOwhBAl+moH9GE4DI2Cg4Fm0EnYiEGoM7h1eFdM1IQoHADLt0wHgU2Ay
 hCBaUqCLylYagV7jBzynB0gUYDgWxvG01YHkVWCOvvs+0MFgbAPAJ3io5/BNR98dB6aDT3h5RdSf
@@ -7288,8 +7288,8 @@ tCQ37GFIN46aTgOPI8vx/kHYf2HdcDBHUHh7M3vyy5iEtEGbz/sngUJoFrePj1/uxtGnWYMjt0gG
 zCQCi3v/CArBOM5s1hAgV++fBEUVAQug2e2j46B55KFntI8oTWA3juAZNI5GV31++5gMeuzyQr2x
 7tBxZMGL7DIsRm5a+0+OpG+Xk+TGoOAk92MI/MzzW/dJTtzd7cI0X56wPWQkCXQyGPU1412WYXOA
 pdcxXSzsiS4fO/YsNPkQC7ydx2GeWS1VLhqxhnHgWcxf7OnDUjHZ2/Z0ka1x5rwAoA==
-	]]><![CDATA[
-	zbqI4MBNH5OsOV7i1l4IzXvtR7M3Hvv4ATR2Y++4upRkCmCaOJvfYVpVMI/mS9RNoK3QHKb9netO
+    ]]><![CDATA[
+    zbqI4MBNH5OsOV7i1l4IzXvtR7M3Hvv4ATR2Y++4upRkCmCaOJvfYVpVMI/mS9RNoK3QHKb9netO
 X5NYGJci3MjyKRYu6SJz2i7FnwyIgYcyDqh0b/y+Ghmcv6yGr58Lq5EM+wwr+ArutXwr8KCZZZTz
 udfyraCipSWU87nX8gE0yynnc6/lW7GULs5dzudeywfQLKecz72WDweFSyjnc6/lg71ZSjmfDaup
 lm/FVro4Zzmfey3fil6Ft1g5n3st34qxsniRcj7VbSXX8rklU2Yq53Ov5TPnoV03QLsU4NW2i+6R
@@ -7361,8 +7361,8 @@ ohAWaxvFOa94sCmb4tIi6UbRpmzmX0OHtX8uzpcSGdr2dTplYAC/LGsEs+T4FKaZMzDcl21Hwmdc
 XmR3uSmSBv26dV5jnK2gzX6Px9xHMbRLfqupDMrG+Wa/mY5iINKE7U275JZz9nTVTTQRKwRUP23W
 usTPjZlqS/HCilNdotcN0L7HkLBfYAFojtdAG32BGaB5XSRkBWXcOGaDZrEyCzLNs5rIfzedVkDn
 Y5rnlUKzMa3KPTpAs1UxO7qNqB5RWfSatyTRbz0iuf7Gd0mit5vttCV+ppJEVzVdJg==
-	]]><![CDATA[
-	5KHnK0n0W4+48sfmIiWJfusRLT70HAV4vuoR9YX8uUoS/dYjrvgr83HkiM96xBXn49v9lCT6rUeE
+    ]]><![CDATA[
+    5KHnK0n0W4+48sfmIiWJfusRLT70HAV4vuoR9YX8uUoS/dYjrvgr83HkiM96xBXn49v9lCT6rUeE
 DtQCJYkmmpzrEdMratGSfaSXeVnhitcldcu5rBAJdJMt+1dic11WqKYfvvmywhXyJXXLvqzQUact
 97LCFcOhDN94WaHqDn7zZYWGXUPfeVmhsy+w2GWFZppstVHm8z4QRV4Vy4RVb9tth6TCmLkuPJy3
 oGzGCw/dbzv02nDp+8LDpZxq5X3hoa89UItfeJhyve1wZYZTrVwvPJzhVKtFLjw0iqD7qVYLXXjo
@@ -7434,8 +7434,8 @@ wMM468ILMteIYgC+SoBusXwiyotxWnsYpwCZAphvurywDMughgmBi6tybu45ZjodyJOmUJ80Mxym
 EHGuEWdlEYzmlTLQ5jlPktj8ItPNNLOQyAJBgTxnOQb0ho27sJTEfBvM71ATVhJVunlaQA95Pi44
 jzqpLzaQ36TdBDgpwC+gEZpTvuUEEkYLcahKBDClKFHjtgmkL7JVuphEnGITyACpWk6nXqATAgU7
 J2K1gbtgJaJPImIW+beD/Db9bBWQ/gxqAX4tArWDvubiFK9JjQnkd9EeF6MMD0QNTA==
-	]]><![CDATA[
-	LYCRElS+m6yDk+ok6lgbxG9jO0lkfGtCNi5AaIDMOCCT4RcQGZ5JcFCwWZVKCs9eYw8EMB8Y5HbB
+    ]]><![CDATA[
+    LYCRElS+m6yDk+ok6lgbxG9jO0lkfGtCNi5AaIDMOCCT4RcQGZ5JcFCwWZVKCs9eYw8EMB8Y5HbB
 mcEozLeQ0HeajfP36hvlRqQYGo0yIyq024beQUaIBtsO8hs0JQAtJBgO4RBZkUVm1rdPYSexR4Lp
 h+65fXXgOADFAnQH6BdQpcBX6pOHnSjMRL1uB/m9Yu/XXJH9Hxux85ureeSexH2/dspnh77Z1JK6
 QKTMv96crwszTl2CsiTJwgJd+UYHwWzi+75jBIVMluaBKmI5EOtxNNlt+CaWA6WE2JugaVqL1XyF
@@ -7507,8 +7507,8 @@ lOxjVOh6TOpbFc+hDSpAI2bgPkBozHZ/C0FZ9Fn3qDkOMxxi8vel/EmbxyKHBacp0yKnqnBHm25X
 vmsjNFIrnt/vJmWMiE+DaED46Ymgei6ZUCI+GM+hBn/e09O8wcXkUfANC11O48Ibvv6O2RxHv+Tk
 z01ohNUQH0M1yUX8Ri9zO75S1b8j7nXdfy948PJh5INgiLm+LzC5crATxBALUDCIuOsPorGmEMme
 pQ6IhjNaOLE6kGWsNB2kIV8nB59s5q8FxDlL/ezseRo/qKX+PKYmtV8mGp0Ene5N3w==
-	]]><![CDATA[
-	cS9FbBdyO1kcPtiC07xxkNtrds5eo58qx9Uee3R246j3GLSDoPqlXQflSuhKDFJ6M/C1xojSL51M
+    ]]><![CDATA[
+    cS9FbBdyO1kcPtiC07xxkNtrds5eo58qx9Uee3R246j3GLSDoPqlXQflSuhKDFJ6M/C1xojSL51M
 X+7f1gxPeVRF6DYNzLepeN6mgfmu5GgaPO/KpENumPz2jnid4w2Yb+C3LX8IzPeQjvi0Fpi15NTd
 MscKpjXB6cB9lPvawDQTBEvnw8e6lmfhZl/w8VYAnZVaSbEc0D3CrSDkNih2oo87ELHgPcGpJ0+y
 7iLiFSrIPa+zexLTcCBaV9H6jjxHBVe555QLNbn4tLHBu2ICXM7Jw8YpJIRyt+7I8ufy2rTaGXht
@@ -7580,8 +7580,8 @@ TQMZQ/pdU37uc2O+7ayAD8bxVCy7D1CO57xckLpa7o9snXhKrZhuT81zmM0Q4S9sVhXoHreFfweg
 /KTPPCftfZ950fBJEkel4XJ/VxL3Djw5s/zbwt43nZsPUTSeeuMuXSecRXYreY2N6R/Gcec/yGak
 mLLzjiyns+dHz4Mqz/hgPIf5mqPWtp5+Vepf5XRyhDr9HAfY6UoMUnoz8NYTka6E0i+dzJdyfzc6
 uV4GJg+1DBpdaaJA63naoaA9F1on0CScZlh0O/bMpQCUn3LIvZhNozt1yX96a9v7NQ==
-	]]><![CDATA[
-	B1+oxKfdXQHK8bnTvZA/GzI+GDzJO5MOuWXy21vbMkd3o7Wd/GtKXUlT/O/WdvV3qY5EIAxT2qtz
+    ]]><![CDATA[
+    B1+oxKfdXQHK8bnTvZA/GzI+GDzJO5MOuWXy21vbMkd3o7Wd/GtKXUlT/O/WdvV3qY5EIAxT2qtz
 ifSAb5xSAokwOZlQkGRtAdSc54za9sioWAILFlJyYFz5KnlkOaAT4JYsg/cpZ3J+qeDD+DyNTTCt
 ZhdQWhSQOsT5iUwtENaJaMwTQrZlOSq5AhQY2loYSJ7B3djoXTlnlNshCHHyO6Bjy3KQyl+1K1JH
 PHmbxl0D0BALHvWU7xjBJmKIrr8OR5aDpBYYudXnhye3jtVy+06KFSw8iOjW1e9iNzwHt4yUEBsT
@@ -7653,8 +7653,8 @@ zEZifsQDFtOy13unKnnlEx+M5UA/0+hs6+iWdiuSlDi9jd8GX2C3jwzH6LsZ9lI3RWmWTeRLob8X
 CpXon0hDDYKGU5ob0GyT1re0YKclJS3YaEpON2HHUHYs1BOOmMdoGsupG/7j0VGszRdqrHfPVzN9
 LB/EKvWzpa4v1CcHTn3l8Mu73zLBG73vZQ75AtQf0fsegRaOGxcLtj8CuCtw4cmv5Usa+AQoIE2P
 fF3GGPloGz/WOTyv/kzxryRL8nb5sRPNckCzCDcyAfWEsiYCjrhcWJpXSJhCuFnsfg==
-	]]><![CDATA[
-	4UQun0Dsed4vz1g8YgCanV6ANRqWoxIpPFAPRCoMJMBWGxu9K2ciCi4diMba/eJ7y/PHoiSMxeJy
+    ]]><![CDATA[
+    4UQun0Dsed4vz1g8YgCanV6ANRqWoxIpPFAPRCoMJMBWGxu9K2ciCi4diMba/eJ7y/PHoiSMxeJy
 LD5ephBgdwvCc1VCtCYLCaIxqxjGHMqdpaWge9mwfvjF+Z0IMCgrz8cXoJBEtFMwmbiG2NdGT2/a
 EFx+2gP2u7h12Yl42hpnDpKo+1/Ki3MgShfjwab+Eif1JtrY3uhtIrrb2L78IcxwtbcKfERMZiNJ
 nDwV0tcpUb5iOcJPHCWsYuO6P4iLNe7LVddzUTzH+Dc5LWpxEdCXV71O20nyBgAEgGLlWtiDcRxb
@@ -7726,8 +7726,8 @@ t8Blju4OHgquzuADwh/RAm/b33dT8HZXAZpKLhUhwFiXrdHJ830TIPOmj7WcYRKkUdwlTd7lYwFq
 QyFONjmrfMIpFCy3I88BjaNpKUCuEdluPqAqRLzVl3wh0rOniD4Fdsgd/Lyjkk8BN2QTcVqWHbGt
 5TkqqQJiVMTZpDRQvb6uR+/KmYhBUK9ALNeSNc9hGaH/8AhLbrYfu9rbobtC4jFFdERTOEqG5Qty
 Z8NwmM5TBT8JsJTJYGxbz6ap9Schp2SX4nBD6d8ploPrt4MIGxOhu1NPzepU8X89vQ==
-	]]><![CDATA[
-	EqBZQVpLg6dl3p8lkLMAcBPJXeQKPxbQNqSJYjaFKO+kCBG7AERcC8Me9y7skEYgGrzALcQ134sS
+    ]]><![CDATA[
+    EqBZQVpLg6dl3p8lkLMAcBPJXeQKPxbQNqSJYjaFKO+kCBG7AERcC8Me9y7skEYgGrzALcQ134sS
 ok3VFJyUvOXyydxCJSK7dvIOesmUlDrrXzaO77Pj+LTiy1+GVQZKFaUr8HBqdxRi0mPMxCnsf9nq
 c5CHbZxpgV0Pq13+8iZ+WO9yi1Xpt+t2Fc8Rch9FrHKnghW0WL5fKlPpTkVxHNsw4K4KCIZwHN7M
 H7M1ph9+6fa/56suW0wr4vaeiA/Gc1h8aC1k+8JCWrdTpJxQ1OLX9Z7zkePAeJzRMlP49OVIzSGm
@@ -7799,8 +7799,8 @@ uaQ8JxPTvxd4cHyEKh+ehRgzzS9P0OQMIwfiVLqgauYviRDEFXw8fCa1sVz/xZd7RK9QHpEprAVX
 ys9AqMtPkovPQq6HT6ep4g5VAy3LN3qpb0CSH+awdSTjc6CzPbIc0JycVrlcklLhFCrmUIGm7YJP
 uSl+1/fTO3bCLOrIclSDCeBnyejzQCbuINnN4H27ZztEsRyk8Ua7InbK+QKeVE/hO7hgv9iFbB0U
 zxFyH0Wscns4hZSLTJPp+wk2FcVxkLZn+FGPYL+uFaD5pGsx04eJgn7okhsuHRzFcw==
-	]]><![CDATA[
-	bHtAC7ExIa75TMVz2C49WMh2JZLg/XngG8JCEs91N5tXjqMkD+HDBrkWCmBDW7XeOoiuK6Fh+chy
+    ]]><![CDATA[
+    bHtAC7ExIa75TMVz2C49WMh2JZLg/XngG8JCEs91N5tXjqMkD+HDBrkWCmBDW7XeOoiuK6Fh+chy
 lOjUYk7HTgBCZkjHNcirM/cN5j4q+UGErbcZ789qoN1kjFAssrFrxR1tVr5rIjTHUywHeMo0xrzO
 TtRj4hJ37NdzaagS8cF4npH7DVhyl4FMvTfJ0MxS0U2Py06Nmbp1zXKY1TDZzzt5lkHfk/0+EtTp
 UHtK2PuR9qLdE09DhWFSf5+jeQOanFnObWHvG8695KCN79vpmrLI7iQX9uaZ7Sueg2xGIn4a2AUz
@@ -7872,8 +7872,8 @@ oCGcMQJB/2AcHz8J0KZE3zoiMdHpFBXH708ocE81X6hcUy5cIWITbbar0MJUMYSJdTAzUhwHJXCC
 AIfHLexqk7hh2UV/HfwLW1ebQnMcpO9Gt0XqycFK3JoW2sy9nce3qGI5RuxWwiq2XZJf8tgm+bBR
 1zkoL6JYnhH7Fnj2Ui7+rTjLsOyyp0QoyOgTMBAvOBrNcZChNAJu7wj4YByH7cyjXWwXggZ+LWh1
 +PU0r7tTaVkOK8QBbjqjlvJZWxtzDN24SiOw4nnR0s8DfrtsHshWV59hH6ktnI2emg==
-	]]><![CDATA[
-	40BvrjbpfSnvb9J7GPEZLXdBmVVqcrXmXetgiZxiOaCVgDHQe086k+83FXDzVKapBHwQjufM/DIQ
+    ]]><![CDATA[
+    40BvrjbpfSnvb9J7GPEZLXdBmVVqcrXmXetgiZxiOaCVgDHQe086k+83FXDzVKapBHwQjufM/DIQ
 rk2rhBQ5VR3SFds6dkotgHpBzXOYrRDhL8Qimh7fEv4WUvnpkHROzttB6RbiNzMbKudpF3PTbC5u
 U+LTqSrfmczATKCN5dvZSrGod5Vs19mazGuOg1QOMGFoFxBctZA7V5gfveCDcBzoXhqNbT3V0uYD
 pAReMqSUioItwiB9N+Nea48clUun8qXY34vFT9aAicOMgoVQmgzQnJIWsKwepyUjLcho4k03YcdQ
@@ -7945,8 +7945,8 @@ tkuPJrJdCScCMWhF1/Yj7KSW47BKHcEXX2pMuWm9MRfRDbg0NCuep4S/C0IAyER5lEFerTH51Do1
 6vPBVfMcZTrM7t+R8yftXvA2XSnLnMua16vftROa7CmeA3oO0tHGIZ80RoUmupCPKhEfjOcwpbsP
 Oeeaam8B292Ytz6fcD0IyxEqJ5tUjdsV8Bv36H1QomMw6kbZUzp+MJZjgywznXf0fdl0vhtU2EmW
 OPu0Ufxc4XPzLUG/57YitwSuGedK19wVY9uV+h4azWgSTasCmrfSrJDG/GNu8Mkm/g==
-	]]><![CDATA[
-	Wn6e2mefnQSPRg66z36++mS2yySjc6A77Z7bu5cevq5hff/lH7YVHmyxScI4yF03e6bW+ufaOGp3
+    ]]><![CDATA[
+    Wn6e2mefnQSPRg66z36++mS2yySjc6A77Z7bu5cevq5hff/lH7YVHmyxScI4yF03e6bW+ufaOGp3
 PTr7cNhLGMozMOXSZtXRhdBVGKPyZtxr3TSlXDaVvtS/rR2OzvYimgHqlMmnWAtESXbBy/566Ss5
 vpKfTDrkhslv74PLHAlayQn4b/MRJ6+Bw39FH/yIc/KdZ8ABn5TiV3bjYcpPYwimUnSo3pJH9AV2
 ATCh3uWrr8bMO6q2PB/g1qUe7tQsBzSMbMyH+qWqmeOOQ7zK/ZLkyOvzIhBwlm+Udn8pQ4j4Ngmi
@@ -8008,4 +8008,4 @@ jSn91aWoXPEcpPJm4GttE6VfOpkv5f5eXG+2DEweahk0oNLcgCaarLaltTqtJmmxxlJxuhV7xlJg
 vU/54W6oo0GROeM/veMNBRRE7rWB9Q4H8mdDTv+nwe+evyS3TH57xxtzjOZOx9uueWP+5o735/+U
 /sv/+D+H//0//Of/4/Nf/r9//bd//+8T4d/9r//yn/71f/u3f/m/Hv/6b//9f/ef/uu//D//+te/
 /Of//F/+27/8t3/9v9N/+us//du//tf/9l/+7V//+q//53/5f0HBj/Yf/Lt/9x/+l7TT/n/XwEN4
-	]]></ns1:pgf></svg>
\ No newline at end of file
+    ]]></ns1:pgf></svg>
diff --git a/docs/source/operator.rst b/docs/source/operator.rst
index 982dc8ae0..7323ed5a3 100644
--- a/docs/source/operator.rst
+++ b/docs/source/operator.rst
@@ -10,23 +10,23 @@ Operators and functions
 Arithmetic operators
 --------------------
 
-`xtensor` provides overloads of traditional arithmetic operators for
-``xexpression`` objects:
+*xtensor* provides overloads of traditional arithmetic operators for
+:cpp:type:`xt::xexpression` objects:
 
-- unary ``operator+``
-- unary ``operator-``
-- ``operator+``
-- ``operator-``
-- ``operator*``
-- ``operator/``
-- ``operator%``
+- unary :cpp:func:`~xt::xexpression::operator+`
+- unary :cpp:func:`~xt::xexpression::operator-`
+- :cpp:func:`~xt::xexpression::operator+`
+- :cpp:func:`~xt::xexpression::operator-`
+- :cpp:func:`~xt::xexpression::operator*`
+- :cpp:func:`~xt::xexpression::operator/`
+- :cpp:func:`~xt::xexpression::operator%`
 
 All these operators are element-wise operators and apply the lazy broadcasting
 rules explained in a previous section.
 
 .. code::
 
-    #incude "xtensor/xarray.hpp"
+    #incude "xtensor/containers/xarray.hpp"
 
     xt::xarray<int> a = {{1, 2}, {3, 4}};
     xt::xarray<int> b = {1, 2};
@@ -37,28 +37,28 @@ rules explained in a previous section.
 Logical operators
 -----------------
 
-`xtensor` also provides overloads of the logical operators:
+*xtensor* also provides overloads of the logical operators:
 
-- ``operator!``
-- ``operator||``
-- ``operator&&``
+- :cpp:func:`~xt::xexpression::operator!`
+- :cpp:func:`~xt::xexpression::operator||`
+- :cpp:func:`~xt::xexpression::operator&&`
 
 Like arithmetic operators, these logical operators are element-wise operators
 and apply the lazy broadcasting rules. In addition to these element-wise
-logical operators, `xtensor` provides two reducing boolean functions:
+logical operators, *xtensor* provides two reducing boolean functions:
 
-- ``any(E&& e)`` returns ``true`` if any of ``e`` elements is truthy, ``false`` otherwise.
-- ``all(E&& e)`` returns ``true`` if all alements of ``e`` are truthy, ``false`` otherwise.
+- :cpp:func:`xt::any(E&& e) <xt::any>` returns ``true`` if any of ``e`` elements is truthy, ``false`` otherwise.
+- :cpp:func:`xt::all(E&& e) <xt::all>` returns ``true`` if all elements of ``e`` are truthy, ``false`` otherwise.
 
 and an element-wise ternary function (similar to the ``: ?`` ternary operator):
 
-- ``where(E&& b, E1&& e&, E2&& e2)`` returns an ``xexpression`` whose elements
-  are those of ``e1`` when corresponding elements of ``b`` are thruthy, and
+- :cpp:func:`xt::where(E&& b, E1&& e1, E2&& e2) <xt::where>` returns an :cpp:type:`xt::xexpression` whose elements
+  are those of ``e1`` when corresponding elements of ``b`` are truthy, and
   those of ``e2`` otherwise.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<bool> b = { false, true, true, false };
     xt::xarray<int> a1 = { 1,   2,  3,  4 };
@@ -67,26 +67,26 @@ and an element-wise ternary function (similar to the ``: ?`` ternary operator):
     xt::xarray<int> res = xt::where(b, a1, a2);
     // => res = { 11, 2, 3, 14 }
 
-Unlike in ``numpy.where``, ``xt::where`` takes full advantage of the lazyness
-of `xtensor`.
+Unlike in :any:`numpy.where`, :cpp:func:`xt::where` takes full advantage of the lazyness
+of *xtensor*.
 
 Comparison operators
 --------------------
 
-`xtensor` provides overloads of the inequality operators:
+*xtensor* provides overloads of the inequality operators:
 
-- ``operator<``
-- ``operator<=``
-- ``operator>``
-- ``operator>=``
+- :cpp:func:`~xt::xexpression::operator\<`
+- :cpp:func:`~xt::xexpression::operator\<=`
+- :cpp:func:`~xt::xexpression::operator\>`
+- :cpp:func:`~xt::xexpression::operator\>=`
 
 These overloads of inequality operators are quite different from the standard
 C++ inequality operators: they are element-wise operators returning boolean
-``xexpression``:
+:cpp:type:`xexpression`:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<int> a1 = {  1, 12,  3, 14 };
     xt::xarray<int> a2 = { 11,  2, 13, 4  };
@@ -95,15 +95,17 @@ C++ inequality operators: they are element-wise operators returning boolean
 
 However, equality operators are similar to the traditional ones in C++:
 
-- ``operator==(const E1& e1, const E2& e2)`` returns ``true`` if ``e1`` and ``e2`` hold the same elements.
-- ``operator!=(const E1& e1, const E2& e2)`` returns ``true`` if ``e1`` and ``e2`` don't hold the same elements.
+- :cpp:func:`operator==(const E1& e1, const E2& e2) <xt::xexpression::operator==>` returns ``true`` if ``e1``
+  and ``e2`` hold the same elements.
+- :cpp:func:`operator!=(const E1& e1, const E2& e2) <xt::xexpression::operator!=>` returns ``true`` if ``e1``
+  and ``e2`` don't hold the same elements.
 
-Element-wise equality comparison can be achieved through the ``xt::equal``
+Element-wise equality comparison can be achieved through the :cpp:func:`xt::equal`
 function.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<int> a1 = {  1,  2, 3, 4};
     xt::xarray<int> a2 = { 11, 12, 3, 4};
@@ -117,26 +119,26 @@ function.
 Bitwise operators
 -----------------
 
-`xtensor` also contains the following bitwise operators:
+*xtensor* also contains the following bitwise operators:
 
-- Bitwise and: ``operator&``
-- Bitwise or: ``operator|``
-- Bitwise xor: ``operator^``
-- Bitwise not: ``operator~``
-- Bitwise left/right shift: ``left_shift``, ``right_shift``
+- Bitwise and: :cpp:func:`~xt::xexpression::operator&`
+- Bitwise or: :cpp:func:`~xt::xexpression::operator|`
+- Bitwise xor: :cpp:func:`~xt::xexpression::operator^`
+- Bitwise not: :cpp:func:`~xt::xexpression::operator~`
+- Bitwise left/right shift: :cpp:func:`~xt::xexpression::left_shift`, :cpp:func:`~xt::xexpression::right_shift`
 
 Mathematical functions
 ----------------------
 
-`xtensor` provides overloads for many of the standard mathematical functions:
+*xtensor* provides overloads for many of the standard mathematical functions:
 
-- basic functions: ``abs``, ``remainder``, ``fma``, ...
-- exponential functions: ``exp``, ``expm1``, ``log``, ``log1p``, ...
-- power functions: ``pow``, ``sqrt``, ``cbrt``, ...
-- trigonometric functions: ``sin``, ``cos``, ``tan``, ...
-- hyperbolic functions: ``sinh``, ``cosh``, ``tanh``, ...
-- Error and gamma functions: ``erf``, ``erfc``, ``tgamma``, ``lgamma``, ....
-- Nearest integer floating point operations: ``ceil``, ``floor``, ``trunc``, ...
+- basic functions: :cpp:func:`xt::abs`, :cpp:func:`xt::remainder`, :cpp:func:`xt::fma`, ...
+- exponential functions: :cpp:func:`xt::exp`, :cpp:func:`xt::expm1`, :cpp:func:`xt::log`, :cpp:func:`xt::log1p`, ...
+- power functions: :cpp:func:`xt::pow`, :cpp:func:`xt::sqrt`, :cpp:func:`xt::cbrt`, ...
+- trigonometric functions: :cpp:func:`xt::sin`, :cpp:func:`xt::cos`, :cpp:func:`xt::tan`, ...
+- hyperbolic functions: :cpp:func:`xt::sinh`, :cpp:func:`xt::cosh`, :cpp:func:`xt::tanh`, ...
+- Error and gamma functions: :cpp:func:`xt::erf`, :cpp:func:`xt::erfc`, :cpp:func:`xt::tgamma`, :cpp:func:`xt::lgamma`, ....
+- Nearest integer floating point operations: :cpp:func:`xt::ceil`, :cpp:func:`xt::floor`, :cpp:func:`xt::trunc`, ...
 
 See the API reference for a comprehensive list of available functions. Like
 operators, the mathematical functions are element-wise functions and apply the
@@ -145,13 +147,13 @@ lazy broadcasting rules.
 Casting
 -------
 
-`xtensor` will implicitly promote and/or cast tensor expression elements as
+*xtensor* will implicitly promote and/or cast tensor expression elements as
 needed, which suffices for most use-cases. But explicit casting can be
-performed via ``cast``, which performs an element-wise ``static_cast``.
+performed via :cpp:func:`xt::cast`, which performs an element-wise ``static_cast``.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<int> a = { 3, 5, 7 };
 
@@ -164,46 +166,106 @@ performed via ``cast``, which performs an element-wise ``static_cast``.
 Reducers
 --------
 
-`xtensor` provides reducers, that is, means for accumulating values of tensor
+*xtensor* provides reducers, that is, means for accumulating values of tensor
 expressions over prescribed axes. The return value of a reducer is an
-``xexpression`` with the same shape as the input expression, with the specified
+:cpp:type:`xt::xexpression` with the same shape as the input expression, with the specified
 axes removed.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xmath.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/core/xmath.hpp>
 
     xt::xarray<double> a = xt::ones<double>({3, 2, 4, 6, 5});
     xt::xarray<double> res = xt::sum(a, {1, 3});
     // => res.shape() = { 3, 4, 5 };
     // => res(0, 0, 0) = 12
 
-You can also call the ``reduce`` generator with your own reducing function:
+You can also call the :cpp:func:`xt::reduce` generator with your own reducing function:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xreducer.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xreducer.hpp>
 
     xt::xarray<double> arr = some_init_function({3, 2, 4, 6, 5});
     xt::xarray<double> res = xt::reduce([](double a, double b) { return a*a + b*b; },
                                         arr,
                                         {1, 3});
 
+The reduce generator also accepts a :cpp:type:`xt::xreducer_functors` object, a tuple of three functions
+(one for reducing, one for initialization and one for merging).
+A generator is provided to build the :cpp:type:`xt::xreducer_functors` object, the last function can be omitted:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xreducer.hpp>
+
+    xt::xarray<double> arr = some_init_function({3, 2, 4, 6, 5});
+    xt::xarray<double> res = xt::reduce(xt::make_xreducer_functor([](double a, double b) { return a*a + b*b; },
+                                                                  [](double a) { return a * 2; })
+                                        arr,
+                                        {1, 3});
+
+If no axes are provided, the reduction is performed over all the axes, and the result is a 0-D expression.
+Since *xtensor*'s expressions are lazy evaluated, you need to explicitely call the access operator to trigger
+the evaluation and get the result:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xreducer.hpp>
+
+    xt::xarray<double> arr = some_init_function({3, 2, 4, 6, 5});
+    double res = xt::reduce([](double a, double b) { return a*a + b*b; }, arr)();
+
+The ``value_type`` of a reducer is the traditional result type of the reducing operation.
+For instance, the ``value_type`` of the reducer for the sum is:
+
+- ``int`` if the underlying expression holds ``int`` values
+- ``int`` if the underlying expression holds ``short`` values, because ``short + short`` = ``int``
+
+You can pass a template argument to the reducer functions to specify the type of the initial value of
+the reduction. This allows you to "promote" the value type of the reducer and limit overflows in
+computation:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xreducer.hpp>
+
+    xt::xarray<int> arr = some_init_function({3, 2, 4, 6, 5});
+    auto s1 = xt::sum<short>(arr); // No effect, short + int = int
+    auto s2 = xt::sum<long int>(arr); // The value_type of s2 is long int
+
+When you write generic code and you want to limit overflows, you can use :cpp:any:`xt::big_promote_value_type_t`
+as shown below:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xreducer.hpp>
+
+    template <class E>
+    void my_computation(E&& e)
+    {
+        auto s = xt::sum<xt::big_promote_value_type_t<E>>(e);
+    }
+
 Accumulators
 ------------
 
-Similar to reducers, `xtensor` provides accumulators which are used to
-implement cumulative functions such as ``cumsum`` or ``cumprod``. Accumulators
+Similar to reducers, *xtensor* provides accumulators which are used to
+implement cumulative functions such as :cpp:func:`xt::cumsum` or :cpp:func:`xt::cumprod`. Accumulators
 can currently only work on a single axis. Additionally, the accumulators are
-not lazy and do not return an xexpression, but rather an evaluated ``xarray``
-or ``xtensor``.
+not lazy and do not return an xexpression, but rather an evaluated :cpp:type:`xt::xarray`
+or :cpp:type:`xt::xtensor`.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xmath.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/core/xmath.hpp>
 
     xt::xarray<double> a = xt::ones<double>({5, 8, 3});
     xt::xarray<double> res = xt::cumsum(a, 1);
@@ -211,23 +273,38 @@ or ``xtensor``.
     // => res(0, 0, 0) = 1
     // => res(0, 7, 0) = 8
 
-You can also call the ``accumumulate`` generator with your own accumulating
+You can also call the :cpp:func:`xt::accumulate` generator with your own accumulating
 function. For example, the implementation of cumsum is as follows:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xaccumulator.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xaccumulator.hpp>
 
     xt::xarray<double> arr = some_init_function({5, 5, 5});
     xt::xarray<double> res = xt::accumulate([](double a, double b) { return a + b; },
                                             arr,
                                             1);
 
+Like reducers, accumulators accept a template parameter to specify the ``value_type``
+of the initial value of the accumulation. The ``value_type`` of the result is computed
+with the same rules as those for reducers:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xaccumulator.hpp>
+
+    xt::xarray<int> arr = some_init_function({5, 5, 5});
+    auto r1 = xt::cumsum<short>(a, 1);
+    // r1 holds int values
+    auto r2 = xt::cumsum<long int>(a, 1);
+    // r2 hols long int values
+
 Evaluation strategy
 -------------------
 
-Generally, `xtensor` implements a :ref:`lazy execution model <lazy-evaluation>`,
+Generally, *xtensor* implements a :ref:`lazy execution model <lazy-evaluation>`,
 but under certain circumstances, a *greedy* execution model with immediate
 execution can be favorable. For example, reusing (and recomputing) the same
 values of a reducer over and over again if you use them in a loop can cost a
@@ -235,9 +312,10 @@ lot of CPU cycles. Additionally, *greedy* execution can benefit from SIMD
 acceleration over reduction axes and is faster when the entire result needs to
 be computed.
 
-Therefore, xtensor allows to select an ``evaluation_strategy``. Currently, two
-evaluation strategies are implemented: ``evaluation_strategy::immediate`` and
-``evaluation_strategy::lazy``. When ``immediate`` evaluation is selected, the
+Therefore, xtensor allows to select an :cpp:enum:`xt::evaluation_strategy`. Currently, two
+evaluation strategies are implemented: :cpp:enumerator:`xt::evaluation_strategy::immediate` and
+:cpp:enumerator:`xt::evaluation_strategy::lazy`.
+When :cpp:enumerator:`~xt::evaluation_strategy::immediate` evaluation is selected, the
 return value is not an xexpression, but an in-memory datastructure such as a
 xarray or xtensor (depending on the input values).
 
@@ -245,36 +323,36 @@ Choosing an evaluation_strategy is straightforward. For reducers:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xreducer.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/reducers/xreducer.hpp>
 
     xt::xarray<double> a = xt::ones<double>({3, 2, 4, 6, 5});
-    auto res = xt::sum(a, {1, 3}, xt::evaluation_strategy::immediate());
+    auto res = xt::sum(a, {1, 3}, xt::evaluation_strategy::immediate);
     // or select the default:
-    // auto res = xt::sum(a, {1, 3}, xt::evaluation_strategy::lazy());
+    // auto res = xt::sum(a, {1, 3}, xt::evaluation_strategy::lazy);
 
-Note: for accumulators, only the ``immediate`` evaluation strategy is currently
-implemented.
+Note: for accumulators, only the :cpp:enumerator:`~xt::evaluation_strategy::immediate` evaluation
+strategy is currently implemented.
 
 Universal functions and vectorization
 -------------------------------------
 
-`xtensor` provides utilities to **vectorize any scalar function** (taking
+*xtensor* provides 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 described in a
-previous section. These functions are called ``xfunction`` s. They are
-`xtensor`'s counterpart to numpy's universal functions.
+:cpp:type:`xt::xexpression` s, applying the lazy broadcasting rules which we described in a
+previous section. These functions are called :cpp:type:`xt::xfunction` s.
+They are *xtensor*'s counterpart to numpy's universal functions.
 
 Actually, all arithmetic and logical operators, inequality operator and
-mathematical functions we described before are ``xfunction`` s.
+mathematical functions we described before are :cpp:type:`xt::xfunction` s.
 
 The following snippet shows how to vectorize a scalar function taking two
 arguments:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xvectorize.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/core/xvectorize.hpp>
 
     int f(int a, int b)
     {
diff --git a/docs/source/pitfall.rst b/docs/source/pitfall.rst
new file mode 100644
index 000000000..b9e40a2a3
--- /dev/null
+++ b/docs/source/pitfall.rst
@@ -0,0 +1,214 @@
+.. 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.
+
+Common pitfalls
+===============
+
+xarray initialization
+---------------------
+
+.. code::
+
+    xt::xarray<double> a({1, 3, 4, 2});
+
+does not initialize a 4D-array, but a 1D-array containing the values ``1``, ``3``,
+``4``, and ``2``.
+It is strictly equivalent to
+
+.. code::
+
+    xt::xarray<double> a = {1, 3, 4, 2};
+
+To initialize a 4D-array with the given shape, use the :cpp:func:`xt::xarray::from_shape` static method:
+
+.. code::
+
+    auto a = xt::xarray<double>::from_shape({1, 3, 4, 2});
+
+The confusion often comes from the way :cpp:type:`xt::xtensor` can be initialized:
+
+.. code::
+
+    xt::xtensor<double, 4> a = {1, 3, 4, 2};
+
+In this case, a 4D-tensor with shape ``(1, 3, 4, 2)`` is initialized.
+
+Intermediate result
+-------------------
+
+Consider the following function:
+
+.. code::
+
+    template <class C>
+    auto func(const C& c)
+    {
+        return (1 - func_tmp(c)) / (1 + func_tmp(c));
+    }
+
+where ``func_tmp`` is another unary function accepting an xtensor expression. You may
+be tempted to simplify it a bit:
+
+.. code::
+
+    template <class C>
+    auto func(const C& c)
+    {
+        auto tmp = func_tmp(c);
+        return (1 - tmp) / (1 + tmp);
+    }
+
+Unfortunately, you introduced a bug; indeed, expressions in *xtensor* are not evaluated
+immediately, they capture their arguments by reference or copy depending on their nature,
+for future evaluation. Since ``tmp`` is an lvalue, it is captured by reference in the last
+statement; when the function returns, ``tmp`` is destroyed, leading to a dangling reference
+in the returned expression.
+
+Replacing ``auto tmp`` with ``xt::xarray<double> tmp`` does not change anything, ``tmp``
+is still an lvalue and thus captured by reference.
+
+.. warning::
+
+    This issue is particularly subtle with reducer functions like :cpp:func:`xt::amax`,
+    :cpp:func:`xt::sum`, etc. Consider the following function:
+
+    .. code::
+
+        template <typename T>
+        xt::xtensor<T, 2> logSoftmax(const xt::xtensor<T, 2> &matrix)
+        {
+            xt::xtensor<T, 2> maxVals = xt::amax(matrix, {1}, xt::keep_dims);
+            auto shifted = matrix - maxVals;
+            auto expVals = xt::exp(shifted);
+            auto sumExp = xt::sum(expVals, {1}, xt::keep_dims);
+            return shifted - xt::log(sumExp);
+        }
+
+    This function may produce incorrect results or crash, especially in optimized builds.
+    The issue is that ``shifted``, ``expVals``, and ``sumExp`` are all lazy expressions
+    that hold references to local variables. When the function returns, these local
+    variables are destroyed, and the returned expression contains dangling references.
+
+    The fix is to evaluate reducer results and the returned expression explicitly.
+    Element-wise lazy expressions (like ``shifted`` and ``expVals``) are safe to
+    leave as ``auto``, but reducer results (like ``sumExp``) must be materialized
+    before being used in a subsequent element-wise expression:
+
+    .. code::
+
+        template <typename T>
+        xt::xtensor<T, 2> logSoftmax(const xt::xtensor<T, 2> &matrix)
+        {
+            xt::xtensor<T, 2> maxVals = xt::amax(matrix, {1}, xt::keep_dims);
+            auto shifted = matrix - maxVals;
+            auto expVals = xt::exp(shifted);
+            xt::xtensor<T, 2> sumExp = xt::sum(expVals, {1}, xt::keep_dims);
+            return xt::xtensor<T, 2>(shifted - xt::log(sumExp));
+        }
+
+Random numbers not consistent
+-----------------------------
+
+Using a random number function from xtensor actually returns a lazy
+generator. That means, accessing the same element of a random number
+generator does not give the same random number if called twice.
+
+.. code::
+
+    auto gen = xt::random::rand<double>({10, 10});
+    auto a0 = gen(0, 0);
+    auto a1 = gen(0, 0);
+
+    // a0 != a1 !!!
+
+You need to explicitly assign or eval a random number generator, like so:
+
+.. code::
+
+    xt::xarray<double> xr = xt::random::rand<double>({10, 10});
+    auto xr2 = xt::eval(xt::random::rand<double>({10, 10}));
+
+    // now xr(0, 0) == xr(0, 0) is true.
+
+variance arguments
+------------------
+
+When :cpp:func:`xt::variance` is passed an expression and an integer parameter, this latter
+is not the axis along which the variance must be computed, but the degree of freedom:
+
+.. code::
+
+    xt::xtensor<double, 2> a = {{1., 2., 3.}, {4., 5., 6.}};
+    std::cout << xt::variance(a, 1) << std::endl;
+    // Outputs 3.5
+
+If you want to specify an axis, you need to pass an initializer list:
+
+.. code::
+
+    xt::xtensor<double, 2> a = {{1., 2., 3.}, {4., 5., 6.}};
+    std::cout << xt::variance(a, {1}) << std::endl;
+    .. Outputs { 0.666667, 0.666667 }
+
+fixed_shape on Windows
+----------------------
+
+Builder functions such as :cpp:func:`xt::empty` or :cpp:func:`xt::ones` accept an initializer list
+as argument. If the elements of this list do not have the same type, a
+curious compilation error may occur on Windows:
+
+.. code::
+
+    size_t N = 10ull;
+    xt::xarray<int> ages = xt::empty<int>({N, 4ul});
+
+    // error: cannot convert argument 1 from 'initializer list'
+    // to 'const xt::fixed_shape<> &'
+
+To avoid this compiler bug (for which we don't have a workaround), ensure
+all the elements in the initializer list have the same type.
+
+Alignment of fixed-size members
+-------------------------------
+
+.. note::
+
+    If you are using ``C++ >= 17`` you should not have to worry about this.
+
+When building with *xsimd* (see :ref:`external-dependencies`), if you define a structure
+having members of fixed-size xtensor types, you must ensure that the buffers properly
+aligned. For this you can use the macro ``XTENSOR_FIXED_ALIGN`` available in
+``xtensor/core/xtensor_config.hpp``.
+Consider the following example:
+
+.. code-block:: cpp
+
+    template <typename T>
+    class alignas(XTENSOR_FIXED_ALIGN) Foo
+    {
+    public:
+
+        using allocator_type = std::conditional_t<XTENSOR_FIXED_ALIGN != 0,
+                                                  xt_simd::aligned_allocator<T, XTENSOR_FIXED_ALIGN>,
+                                                  std::allocator<T>>;
+
+        Foo(T fac) : m_fac(fac)
+        {
+            m_bar.fill(fac);
+        }
+
+        auto get() const
+        {
+            return m_bar;
+        }
+
+    private:
+
+        xt::xtensor_fixed<T, xt::xshape<10, 10>> m_bar;
+        T m_fac;
+    };
+
+Whereby it is important to store the fixed-sized xtensor type (in this case ``xt::xtensor_fixed<T, xt::xshape<10, 10>>``) as first member.
diff --git a/docs/source/quantstack-white.svg b/docs/source/quantstack-white.svg
index d527db199..1f03ebb42 100644
--- a/docs/source/quantstack-white.svg
+++ b/docs/source/quantstack-white.svg
@@ -49,4 +49,4 @@
      d="m 85.3,16 c 1.2,0.6 2.4,1.3 3.4,2.2 l 0,22.2 c 0,9.2 -1.8,19.7 -14.2,19.7 l -1.9,0 C 60.1,60.1 58.4,49.6 58.4,40.4 l 0,-22.2 c 1,-0.9 2.2,-1.6 3.4,-2.2 l 0,23.4 c 0,10.4 1.5,17.7 11.4,17.7 l 0.9,0 c 9.8,0 11.4,-7.3 11.4,-17.7 L 85.5,16 Z M 133,38.1 c 0,15 -5.1,22.1 -18.1,22.1 -0.1,0 -0.6,0 -0.7,0 -11,0 -14.2,-5.1 -14.2,-12.4 0,-10.2 9.7,-12.6 29.5,-13.4 -0.6,-9.3 -3.7,-15.2 -14.6,-15.2 -3,0 -5.8,0.5 -8.6,1.8 l -1.5,-2.9 c 3.3,-1.7 6.7,-2.1 10.1,-2.1 13,0 18.1,7 18.1,22.1 z m -3.4,-0.7 c -16.6,0.8 -26.1,2.2 -26.1,10.5 0,2.8 0.5,4.9 1.9,6.4 0.4,0.5 1,0.9 1.7,1.2 2.6,1.1 5.2,1.5 7.9,1.5 12.2,0 14.7,-7.4 14.7,-18.9 -0.1,-0.3 -0.1,-0.5 -0.1,-0.7 z m 201.7,0.7 c 0,15 -5.1,22.1 -18.1,22.1 -0.1,0 -0.6,0 -0.7,0 -11,0 -14.2,-5.1 -14.2,-12.4 0,-10.2 9.7,-12.6 29.5,-13.4 -0.6,-9.3 -3.7,-15.2 -14.6,-15.2 -3,0 -5.8,0.5 -8.6,1.8 l -1.5,-2.9 c 3.3,-1.7 6.7,-2.1 10.1,-2.1 13,0 18.1,7 18.1,22.1 z m -3.4,-0.7 c -16.6,0.8 -26.1,2.2 -26.1,10.5 0,2.8 0.5,4.9 1.9,6.4 0.4,0.5 1,0.9 1.7,1.2 2.6,1.1 5.2,1.5 7.9,1.5 12.2,0 14.7,-7.4 14.7,-18.9 -0.1,-0.3 -0.1,-0.5 -0.1,-0.7 z M 57.2,82.2 c -0.9,0.9 -1.8,1.7 -2.9,2.3 C 45,79.7 38.3,71.4 34.9,60.6 31.7,62.2 27.8,63 23.1,63 6.5,63 0,53.3 0,32.3 0,11.4 6.5,1.6 23.1,1.6 c 16.6,0 23.1,9.7 23.1,30.7 0,13 -2.5,21.6 -8.4,26.4 3.2,10.9 10,19 19.4,23.5 z M 42.7,32.3 C 42.7,15.9 39.4,4.8 23,4.8 6.6,4.8 3.3,15.8 3.3,32.3 c 0,16.4 3.3,27.5 19.7,27.5 16.4,0 19.7,-11 19.7,-27.5 z m 366,-10.4 C 408,21 407.2,20.2 406.3,19.5 l -18.3,18.2 0,-22 -0.4,0 c -1.1,0.2 -2,0.5 -3,0.8 l 0,42.6 c 1.1,0.4 2.2,0.6 3.4,0.9 l 0,-21.3 17.8,17.8 c 0.9,-0.7 1.7,-1.4 2.5,-2.3 l -16,-16 16.4,-16.3 z M 360.6,57 c -12.2,0 -14.7,-7.4 -14.7,-18.9 0,-11.5 2.5,-18.9 14.7,-18.9 3.1,0 6,0.5 8.8,1.9 l 1.5,-2.9 c -3.4,-1.7 -6.9,-2.1 -10.2,-2.1 -13,0 -18.1,7 -18.1,22.1 0,15 5.1,22.1 18.1,22.1 3.4,0 6.9,-0.4 10.3,-2.1 l -1.5,-2.9 c -3,1.2 -5.9,1.7 -8.9,1.7 z m -198,-41.1 -1.9,0 c -12.5,0 -14.2,10.5 -14.2,19.7 l 0,22.2 c 1,0.9 2.2,1.6 3.4,2.2 l 0,-23.3 c 0,-10.4 1.5,-17.7 11.4,-17.7 l 0.9,0 c 9.8,0 11.4,7.3 11.4,17.7 l 0,23.4 c 1.2,-0.6 2.4,-1.3 3.4,-2.2 l 0,-22.2 c -0.2,-9.3 -2,-19.8 -14.4,-19.8 z m 127.7,4.3 -1.6,-3.1 -10.4,0 0,-10.9 -3.3,0 0,10.8 -10.5,0 -1.6,3.1 12.1,0 c 0,0 0,22.4 0,23.7 l 0,0 c -0.1,2.6 0.3,5.1 1.2,7.3 0,0.1 1,2.2 2.6,4.1 0.8,0.9 2.4,2.3 4.6,3.8 l 1.5,-3.1 c -1.7,-1.2 -2.9,-2.2 -3.5,-2.9 -1.3,-1.5 -2,-3.2 -2,-3.2 -0.7,-1.6 -1,-3.3 -1,-5 0,-1.2 0,-24.7 0,-24.7 l 11.9,0 z M 197.8,6 l -3.3,0 0,10.8 -12,0 1.6,3.1 10.4,0 c 0,0 0,12.2 0,13.5 l 0,0 c -0.1,2.6 0.3,5.1 1.2,7.3 0,0.1 1,2.2 2.6,4.1 0.8,0.9 2.3,2.2 4.4,3.7 l 1.6,-3.1 c -1.7,-1.2 -2.9,-2.2 -3.4,-2.9 -1.3,-1.5 -2,-3.2 -2,-3.2 -0.7,-1.6 -1,-3.3 -1,-5 0,-1.2 0,-14.5 0,-14.5 l 10.4,0 1.6,-3.1 -12.1,0 0,-10.7 z m 40.3,22.2 c -1.9,-0.7 -3.6,-1.3 -5.3,-2.1 l 0,0 c -5.1,-2.1 -8.7,-4.8 -8.7,-10.8 0,-9.2 6.4,-12.1 14.5,-12.1 3.8,0 7.5,0.4 11.2,1.7 L 251.3,2 c -4,-1.5 -8.3,-2 -12.8,-2 -9.4,0 -17.7,4.1 -17.7,15.4 0,6.7 3.4,10.4 8.6,12.9 l 0,0 c 0.8,0.3 1.4,0.6 2.1,0.9 0,0 0,0 0,0 l 0,0 c 1.9,0.8 3.3,1.4 5.1,2 8.4,3 12.3,3.5 15.1,6.6 0.2,0.2 4.1,4.8 3.1,10.4 -0.5,2.9 -2.2,5.5 -4.9,7.8 -6.2,5.1 -15.9,4 -25.2,0.9 l -1.6,3.1 c 5.1,1.8 10.4,3 15.4,3 5.1,0 9.7,-1.2 13.5,-4.3 4.2,-3.5 5.7,-7.2 6.1,-9.8 1.3,-7.1 -3.3,-12.6 -3.8,-13.2 -2.7,-2.9 -7.6,-4.4 -16.2,-7.5 z"
      id="path3"
      inkscape:connector-curvature="0"
-     style="fill:#ffffff" /></svg>
\ No newline at end of file
+     style="fill:#ffffff" /></svg>
diff --git a/docs/source/quickref/basic.rst b/docs/source/quickref/basic.rst
new file mode 100644
index 000000000..2cd4b0d2b
--- /dev/null
+++ b/docs/source/quickref/basic.rst
@@ -0,0 +1,247 @@
+.. 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.
+
+Basics
+======
+
+Tensor types
+------------
+
+- ``xarray<T>``: tensor that can be reshaped to any number of dimensions.
+- ``xtensor<T, N>``: tensor with a number of dimensions set to ``N`` at compile time.
+- ``xtensor_fixed<T, xshape<I, J, K>``: tensor whose shape is fixed at compile time.
+- ``xchunked_array<CS>``: chunked array using the ``CS`` chunk storage.
+
+.. note::
+
+   Except if mentioned otherwise, the methods described below are available for the
+   three kinds of containers, even if the examples show :cpp:type:`xt::xarray` usage only.
+
+Initialization
+--------------
+
+Tensor with dynamic shape:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+
+    xt::xarray<double>::shape_type shape = {2, 3};
+    xt::xarray<double> a0(shape);
+    xt::xarray<double> a1(shape, 2.5);
+    xt::xarray<double> a2 = {{1., 2., 3.}, {4., 5., 6.}};
+    auto a3 = xt::xarray<double>::from_shape(shape);
+
+Tensor with static number of dimensions:
+
+.. code::
+
+    #include <xtensor/containers/xtensor.hpp>
+
+    xt::xtensor<double, 2>::shape_type shape = {2, 3};
+    xt::xtensor<double, 2> a0(shape);
+    xt::xtensor<double, 2> a1(shape, 2.5);
+    xt::xtensor<double, 2> a2 = {{1., 2., 3.}, {4., 5., 6.}};
+    auto a3 = xt::xtensor<double, 2>::from_shape(shape);
+
+Tensor with fixed shape:
+
+.. code::
+
+    #include <xtensor/containers/xfixed.hpp>
+
+    xt::xtensor_fixed<double, xt::xshape<2, 3>> = {{1., 2., 3.}, {4., 5., 6.}};
+
+In-memory chunked tensor with dynamic shape:
+
+.. code::
+
+    #include <xtensor/chunk/xchunked_array.hpp>
+
+    std::vector<std::size_t> shape = {10, 10, 10};
+    std::vector<std::size_t> chunk_shape = {2, 3, 4};
+    auto a = xt::chunked_array<double>(shape, chunk_shape);
+
+Output
+------
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/containers/xfixed.hpp>
+    #include <xtensor/io/xio.hpp>
+    #include <xtensor/containers/xtensor.hpp>
+
+    xt::xarray<double> a = {{1., 2.}, {3., 4.}};
+    std::cout << a << std::endl;
+
+    xt::xtensor<double, 2> b = {{1., 2.}, {3., 4.}};
+    std::cout << b << std::endl;
+
+    xt::xtensor_fixed<double, xt::xshape<2, 2>> c = {{1., 2.}, {3., 4.}};
+    std::cout << c << std::endl;
+
+Shape - dimension - size
+------------------------
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    auto size = a.size();     // size = 6
+    auto dim = a.dimension(); // dim = 2
+    auto shape = a.shape();   // shape = {2, 3}
+    auto sh1 = a.shape(1);    // sh1 = 3
+
+Print the shape
+---------------
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    auto shape = a.shape();
+    std::cout << xt::adapt(shape) << std::endl;
+
+Reshape
+-------
+
+The number of elements of an :cpp:type:`xt::xarray` must remain the same:
+
+.. code::
+
+    xt::xarray<double> a0 = {1., 2., 3., 4., 5., 6.};
+    a0.reshape({2, 3});
+    std::cout << a0 << std::endl;
+    // outputs {{1., 2., 3.}, {4., 5., 6. }}
+
+For :cpp:type:`xt::xtensor` the number of elements and the number of dimensions
+must remain the same:
+
+.. code::
+
+    xt::xtensor<double, 2> a1 = {{1., 2.}, {3., 4.}, {5., 6.}};
+    a1.reshape({2, 3});
+    std::cout << a1 << std::endl;
+    // outputs {{1., 2., 3.}, {4., 5., 6. }}
+
+One value in the shape can be -1. In this case, the value is inferred from the
+length of the underlying buffer and remaining dimensions:
+
+.. code::
+
+    xt::xarray<double> a0 = {1., 2., 3., 4., 5., 6.};
+    a0.reshape({2, -1});
+    std::cout << a0 << std::endl;
+    // outputs {{1., 2., 3.}, {4., 5., 6. }}
+
+    xt::xtensor<double, 2> a1 = {{1., 2.}, {3., 4.}, {5., 6.}};
+    a1.reshape({-1, 3});
+    std::cout << a1 << std::endl;
+    // outputs {{1., 2., 3.}, {4., 5., 6. }}
+
+``reshape`` is not defined for ``xtensor_fixed``.
+
+Resize
+------
+
+.. code::
+
+    xt::xarray<double> a0 = {1., 2., 3, 4.};
+    a0.resize({2, 3});
+
+When resizing an :cpp:type:`xt::xtensor` object, the number of dimensions must remain
+the same:
+
+.. code::
+
+    xt::xtensor<double, 2> a1 = {{1., 2.}, {3., 4.}};
+    a1.resize({2, 3});
+
+``resize`` is not defined for ``xtensor_fixed``.
+
+.. warning::
+
+    Contrary to STL containers like std::vector, resize do NOT
+    preserve elements.
+
+Element access
+--------------
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    double d0 = a(0, 2);   // d0 is 3.
+    double d1 = a(2);      // d1 is a(0, 2)
+    double d2 = a[{0, 2}]; // d2 is a(0, 2)
+
+The same operators are used for writing values:
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    a(0, 2)   = 8.;
+    a(2)      = 8.;
+    a[{0, 2}] = 8.;
+
+The ``at`` method is an access operator with bound checking:
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    double d0 = a.at(0, 3);   // throws
+    double d1 = a.at(3);      // throws
+
+The ``periodic`` method is an access operator that applies periodicity
+to its arguments:
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    double d0 = a.periodic(2, -1); // d0 is 3
+
+Fill
+----
+
+.. code::
+
+    auto a = xt::xarray<double>::from_shape({2, 3});
+    a.fill(2.);
+    std::cout << a << std::endl;
+    // Outputs {{2., 2., 2.}, {2., 2., 2.}}
+
+Iterators
+---------
+
+*xtensor* containers provide iterators compatible with algorithms from the STL:
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    xt::xarray<double> b(a.shape());
+    std::transform(a.cbegin(), a.cend(), b.begin(), [](auto&& v) { return v + 1; });
+    std::cout << b << std::endl;
+    // Outputs {{2., 3., 4.}, {5., 6., 7.}}
+
+Reverse iterators are also available:
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    xt::xarray<double> b(a.shape());
+    std::copy(a.crbegin(), a.crend(), b.begin());
+    std::cout << b << std::endl;
+    // Outputs {{6., 5., 4.}, {3., 2., 1.}}
+
+Data buffer
+-----------
+
+The underlying 1D data buffer can be accessed with the ``data`` method:
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    a.data()[4] = 8.;
+    std::cout << a << std::endl;
+    // Outputs {{1., 2., 3.}, {8., 5., 6.}}
diff --git a/docs/source/quickref/builder.rst b/docs/source/quickref/builder.rst
new file mode 100644
index 000000000..573233074
--- /dev/null
+++ b/docs/source/quickref/builder.rst
@@ -0,0 +1,246 @@
+.. 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.
+
+Builders
+========
+
+Most of *xtensor* builders return unevaluated expressions (see :ref:`lazy-evaluation`
+for more details) that can be assigned to any kind of *xtensor* container.
+
+Ones
+----
+
+.. code::
+
+    // Lazy version
+    auto e = xt::ones<double>({2, 3});
+    std::cout << e < std::endl;
+    // Outputs {{1., 1., 1.}, {1., 1., 1.}}
+
+    // Evaluated versions
+    using fixed_tensor = xt::xtensor_fixed<double, xt::xshape<2, 3>>;
+    xt::xarray<double>     a0 = xt::ones<double>({2, 3});
+    xt::xtensor<double, 2> a1 = xt::ones<double>({2, 3});
+    fixed_tensor           a2 = xt::ones<double>({2, 3});
+
+Zeros
+-----
+
+.. code::
+
+    // Lazy version
+    auto e = xt::zeros<double>({2, 3});
+    std::cout << e << std::endl;
+    // Outputs {{0., 0., 0.}, {0., 0., 0.}}
+
+    // Evaluated versions
+    using fixed_tensor = xt::xtensor_fixed<double, xt::xshape<2, 3>>;
+    xt::xarray<double>     a0 = xt::zeros<double>({2, 3});
+    xt::xtensor<double, 2> a1 = xt::zeros<double>({2, 3});
+    fixed_tensor           a2 = xt::zeros<double>({2, 3});
+
+Empty
+-----
+
+``xt::empty`` creates a container of uninitialized values. It selects the best container
+match from the supplied shape:
+
+.. code::
+
+    xt::xarray<double>::shape_type sh0 = {2, 3};
+    auto a0 = xt::empty<double>(sh0);
+    // a0 is xt::xarray<double>
+
+    xt::xtensor<double, 2>::shape_type sh1 = {2, 3};
+    auto a1 = xt::empty<double>(sh1);
+    // a1 is xt::xtensor<double, 2>
+
+    xt::xshape<2, 3> sh2;
+    auto a2 = xt::empty<double>(sh2);
+    // a2 is xt::xtensor_fixed<double, xt::xshape<2, 3>>
+
+Full like
+---------
+
+``xt::full_like`` returns a container with the same shape as the input expression, and
+filled with the specified value:
+
+.. code::
+
+    xt::xarray<double> a0 = {{1., 2., 3.}, {4., 5., 6.}};
+    auto b0 = xt::full_like(a0, 3.);
+    std::cout << b0 << std::endl;
+    // Outputs {{3., 3., 3.}, {3., 3., 3.}}
+    // b0 is an xt::xarray<double>
+
+    xt::xtensor<double, 2> a1 = {{1., 2., 3.}, {4., 5., 6.}};
+    auto b1 = xt::full_like(a1, 3.);
+    std::cout << b1 << std::endl;
+    // Outputs {{3., 3., 3.}, {3., 3., 3.}}
+    // b1 is an xt::xtensor<double, 2>
+
+    xt::xtensor_fixed<double, xt::xshape<2, 3>> a2 = {{1., 2., 3.}, {4., 5., 6.}};
+    auto b2 = xt::full_like(a2, 3.);
+    std::cout << b2 << std::endl;
+    // Outputs {{3., 3., 3.}, {3., 3., 3.}}
+    // b2 is an xt::xtensor_fixed<double, xt::xshape<2, 3>>
+
+Ones like
+---------
+
+``ones_like(e)`` is equivalent to ``full_like(e, 1.)``.
+
+Zeros like
+----------
+
+``zeros_like(e)`` is equivalent to ``full_like(e, 0.)``.
+
+Eye
+---
+
+Generates an array with ones on the specified diagonal:
+
+.. code::
+
+    auto a = xt::eye<double>({2, 3}, 1);
+    std::cout << a << std::endl;
+    // Outputs {{O, 1, 0}, {0, 0, 1}}
+
+    auto b = xt::eye<double>({3, 2}, -1);
+    std::cout << b << std::endl;
+    // Outputs {{0, 0}, {1, 0}, {0, 1}}
+
+    aut c = xt::eye<double>(3, 1);
+    std::cout << c << std::endl;
+    // Outputs {{O, 1, 0}, {0, 0, 1}, {0, 0, 0}}
+
+Arange
+------
+
+Generates evenly spaced numbers:
+
+.. code::
+
+    auto e = xt::arange<double>(0., 10., 2);
+    std::cout << e << std::endl;
+    // Outputs {0., 2., 4., 6., 8.}
+
+A common pattern is to use ``arange`` followed by reshape to initialize
+a tensor with an arbitrary number of dimensions:
+
+.. code::
+
+    xt::xarray<double> a = xt::arange<double>(0., 6.).reshape({2, 3});
+    std::cout << a << std::endl;
+    // Outputs {{0., 1., 2.}, {3., 4., 5.}}
+
+Linspace
+--------
+
+.. code::
+
+    auto a = xt::linspace<double>(0., 10., 5);
+    std::cout << a << std::endl;
+    // Outputs {0., 2.5, 5., 7.5, 10.}
+
+Logspace
+--------
+
+Similar to ``linspace`` but numbers are evenly space on a log scale.
+
+Concatenate
+-----------
+
+.. code::
+
+    xt::xarray<double> a = {{1, 2, 3}};
+    xt::xarray<double> b = {{2, 3, 4}};
+
+    auto c0 = xt::concatenate(xt::xtuple(a, b));
+    std::cout << c0 << std::endl;
+    // Outputs {{1, 2, 3}, {2, 3, 4}}
+
+    auto c1 = xt::concatenate(xt::xtuple(a, b), 1);
+    std::cout << c1 << std::endl;
+    // Outputs {1, 2, 3, 2, 3, 4}
+
+Stack
+-----
+
+``stack`` always creates a new dimension along which elements are stacked:
+
+.. code::
+
+    xt::xarray<double> a = {1, 2, 3};
+    xt::xarray<double> b = {5, 6, 7};
+
+    auto s0 = xt::stack(xt::xtuple(a, b));
+    std::cout << s0 << std::endl;
+    // Outputs {{1, 2, 3}, {5, 6, 7}}
+
+    auto s1 = xt::stack(xt::xtuple(a, b), 1);
+    std::cout << s1 << std::endl;
+    // Outputs {{1, 5}, {2, 6}, {3, 7}}
+
+HStack
+------
+
+.. code::
+
+    xt::xarray<double> a0 = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<double> b0 = {{7, 8}, {9, 10}};
+    auto c0 = xt::hstack(xt::xtuple(a0, b0));
+    std::cout << c0 << std:endl;
+    // Outputs {{1, 2, 3, 7, 8}, {4, 5, 6, 0, 10}}
+
+    xt::xarray<double> a1 = {1, 2, 3};
+    xt::xarray<double> b1 = {2, 3 ,4};
+    auto c1 = xt::hstack(xt::xtuple(a1, b1));
+    std::cout << c1 << std::endl;
+    // Outputs {1, 2, 3, 2, 3, 4}
+
+VStack
+------
+
+.. code::
+
+    xt::xarray<double> a0 = {1, 2, 3};
+    xt::xarray<double> b0 = {2, 3, 4};
+    auto c0 = xt::vstack(xt::xtuple(a0, b0));
+    std::cout << c0 << std::endl;
+    // Outputs {{1, 2, 3}, {2, 3 ,4}}
+
+    xt::xarray<double> a1 = {{1, 2, 3}, {4, 5 ,6}, {7, 8, 9}};
+    xt::xarray<double> b1 = {{10, 11, 12}};
+    auto c1 = xt::vstack(xt::xtuple(a1, b1));
+    std::cout << c1 << std::endl;
+    // Outputs {{1, 2, 3}, {4, 5 ,6}, {7, 8, 9}, {10, 11, 12}}
+
+Diag
+----
+
+Returns a 2D-expression using the input value as its diagonal:
+
+.. code::
+
+    xt::xarray<double> a = {1, 5, 7};
+    auto b = xt::diag(a);
+    std::cout << b << std::endl;
+    // Outputs {{1, 0, 0} {0, 5, 0}, {0, 0, 7}}
+
+Diagonal
+--------
+
+Returns the elements on the diagonal of the expression
+
+.. code::
+
+    xt::xarray<double> a = {{1, 2, 3},
+                            {4, 5, 6},
+                            {7, 8, 9}};
+    auto d = xt::diagonal(a);
+    std::cout << d << std::endl;
+    // Outputs {1, 5, 9}
diff --git a/docs/source/quickref/chunked_arrays.rst b/docs/source/quickref/chunked_arrays.rst
new file mode 100644
index 000000000..e645cea73
--- /dev/null
+++ b/docs/source/quickref/chunked_arrays.rst
@@ -0,0 +1,69 @@
+.. 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.
+
+Chunked arrays
+==============
+
+Motivation
+----------
+
+Arrays can be very large and may not fit in memory. In this case, you may not be
+able to use an in-memory array such as an :cpp:type:`xt::xarray`. A solution to this problem
+is to cut up the large array into many small arrays, called chunks. Not only do
+the chunks fit comfortably in memory, but this also allows to process them in
+parallel, including in a distributed environment (although this is not supported
+yet).
+
+Formats for the storage of arrays such as `Zarr <https://zarr.readthedocs.io/en/stable/>`_
+specifically target chunked arrays. Such formats are becoming increasingly
+popular in the field of big data, since the chunks can be stored in the cloud.
+
+In-memory chunked arrays
+------------------------
+
+This may not look very useful at first sight, since each chunk (and thus the
+whole array) is held in memory. It means that it cannot work with very large
+arrays, but it may be used to parallelize an algorithm, by processing several
+chunks at the same time.
+
+An in-memory chunked array has the following type:
+
+.. code::
+
+    #include <xtensor/chunk/xchunked_array.hpp>
+
+    using data_type = double;
+    // don't use this code:
+    using inmemory_chunked_array = xt::xchunked_array<xarray<xarray<data_type>>>;
+
+But you should not directly use this type to create a chunked array. Instead,
+use the ``chunked_array`` factory function:
+
+.. code::
+
+    #include <xtensor/chunk/xchunked_array.hpp>
+
+    std::vector<std::size_t> shape = {10, 10, 10};
+    std::vector<std::size_t> chunk_shape = {2, 3, 4};
+    auto a = xt::chunked_array<double>(shape, chunk_shape);
+    // a is an in-memory chunked array
+    // each chunk is an xarray<double>, and chunks are hold in an xarray
+    // thus a is an xarray of xarray<double> elements
+    a(3, 9, 2) = 1.;  // this will address the chunk of index (1, 3, 0)
+                      // and in this chunk, the element of index (1, 0, 2)
+
+Chunked arrays implement the full semantic of :cpp:type:`xt::xarray`, including lazy
+evaluation.
+
+Stored chunked arrays
+---------------------
+
+These are arrays whose chunks are stored on a file system, allowing for
+persistence of data. In particular, they are used as a building block for the
+`xtensor-zarr <https://github.com/xtensor-stack/xtensor-zarr>`_ library.
+
+For further details, please refer to the documentation
+of `xtensor-io <https://xtensor-io.readthedocs.io/en/latest/>`_.
diff --git a/docs/source/quickref/iterator.rst b/docs/source/quickref/iterator.rst
new file mode 100644
index 000000000..6937aa371
--- /dev/null
+++ b/docs/source/quickref/iterator.rst
@@ -0,0 +1,257 @@
+.. 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
+=========
+
+Default iteration
+-----------------
+
+.. code::
+
+    #include <iostream>
+    #include <iterator>
+    #include <xtensor/containers/xarray.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, ", "));
+    // Prints 1, 2, 3, 4, 5, 6,
+
+Specified traversal order
+-------------------------
+
+.. code::
+
+    #include <iostream>
+    #include <iterator>
+    #include <xtensor/containers/xarray.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    std::copy(a.begin<layout_type::row_major>(),
+              a.end<layout_type::row_major>(),
+              std::ostream_iterator<int>(std::cout, ", "));
+    // Prints 1, 2, 3, 4, 5, 6,
+
+    std::copy(a.begin<layout_type::column_major>(),
+              a.end<layout_type>::column_major>(),
+              std::ostream_iterator<int>(std::cout, ", "));
+    // Prints 1, 4, 2, 5, 3, 6,
+
+Broacasting iteration
+---------------------
+
+.. code::
+
+    #include <iostream>
+    #include <iterator>
+    #include <xtensor/containers/xarray.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    using shape_type = xt::dynamic_shape<std::size_t>;
+    shape_type s = {2, 2, 3};
+
+    std::copy(a.begin(s), a.end(s), std::ostream_iterator<int>(std::cout, ", "));
+    // Prints 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6,
+
+    std::copy(a.begin<layout_type::row_major>(s),
+              a.end<layout_type::row_major>(s),
+              std::ostream_iterator<int>(std::cout, ", "));
+    // Prints 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6,
+
+    std::copy(a.begin<layout_type::column_major>(s),
+              a.end<layout_type>::column_major>(s),
+              std::ostream_iterator<int>(std::cout, ", "));
+    // Prints 1, 4, 2, 5, 3, 6, 1, 4, 2, 5, 3, 6,
+
+1-D slice iteration
+-------------------
+
+Iterating over axis 0:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xaxis_slice_iterator.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    xarray<int> a = {{{1, 2, 3, 4},
+                      {5, 6, 7, 8},
+                      {9, 10, 11, 12}},
+                     {{13, 14, 15, 16},
+                      {17, 18, 19, 20},
+                      {21, 22, 23, 24}}};
+
+    auto iter = axis_slice_begin(a, 0);
+    auto end = axis_slice_end(a, 0);
+    while(iter != end)
+    {
+        std::cout << *iter++ << std::endl;
+    }
+    // Prints:
+    // { 1, 13 }
+    // { 2, 14 }
+    // { 3, 15 }
+    // { 4, 16 }
+    // { 5, 17 }
+    // { 6, 18 }
+    // { 7, 19 }
+    // { 8, 20 }
+    // { 9, 21 }
+    // { 10, 22 }
+    // { 11, 23 }
+    // { 12, 24 }
+
+Iterating over axis 1:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xaxis_slice_iterator.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    xarray<int> a = {{{1, 2, 3, 4},
+                      {5, 6, 7, 8},
+                      {9, 10, 11, 12}},
+                     {{13, 14, 15, 16},
+                      {17, 18, 19, 20},
+                      {21, 22, 23, 24}}};
+
+    auto iter = axis_slice_begin(a, 1u);
+    auto end = axis_slice_end(a, 1u);
+    while(iter != end)
+    {
+        std::cout << *iter++ << std::endl;
+    }
+    // Prints:
+    // { 1, 5, 9 }
+    // { 2, 6, 10 }
+    // { 3, 7, 11 }
+    // { 4, 8, 12 }
+    // { 13, 17, 21 }
+    // { 14, 18, 22 }
+    // { 15, 19, 23 }
+    // { 16, 20, 24 }
+
+Iterating over axis 2:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xaxis_slice_iterator.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    xarray<int> a = {{{1, 2, 3, 4},
+                      {5, 6, 7, 8},
+                      {9, 10, 11, 12}},
+                     {{13, 14, 15, 16},
+                      {17, 18, 19, 20},
+                      {21, 22, 23, 24}}};
+
+    auto iter = axis_slice_begin(a, 2u);
+    auto end = axis_slice_end(a, 2u);
+    while(iter != end)
+    {
+        std::cout << *iter++ << std::endl;
+    }
+    // Prints:
+    // { 1, 2, 3, 4 }
+    // { 5, 6, 7, 8 }
+    // { 9, 10, 11, 12 }
+    // { 13, 14, 15, 16 }
+    // { 17, 18, 19, 20 }
+    // { 21, 22, 23, 24 }
+
+(N-1)-dimensional iteration
+---------------------------
+
+Iterating over axis 0:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xaxis_iterator.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    xarray<int> a = {{{1, 2, 3, 4},
+                      {5, 6, 7, 8},
+                      {9, 10, 11, 12}},
+                     {{13, 14, 15, 16},
+                      {17, 18, 19, 20},
+                      {21, 22, 23, 24}}};
+
+    auto iter = axis_begin(a, 0);
+    auto end = axis_end(a, 0);
+    while(iter != end)
+    {
+        std::cout << *iter++ << std::endl;
+    }
+    // Prints:
+    // {{ 1,  2,  3,  4 },
+    //  { 5,  6,  7,  9 },
+    //  { 9, 10, 11, 12 }}
+    // {{ 13, 14, 15, 16 },
+    //  { 17, 18, 19, 20 },
+    //  { 21, 22, 23, 24 }}
+
+Iterating over axis 1:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xaxis_iterator.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    xarray<int> a = {{{1, 2, 3, 4},
+                      {5, 6, 7, 8},
+                      {9, 10, 11, 12}},
+                     {{13, 14, 15, 16},
+                      {17, 18, 19, 20},
+                      {21, 22, 23, 24}}};
+
+    auto iter = axis_begin(a, 1u);
+    auto end = axis_end(a, 1u);
+    while(iter != end)
+    {
+        std::cout << *iter++ << std::endl;
+    }
+    // Prints:
+    // {{  1,  2,  3,  4 },
+    //  { 13, 14, 15, 16 }}
+    // {{  5,  6,  7,  8 },
+    //  { 17, 18, 19, 20 }}
+    // {{  9, 10, 11, 12 },
+    //  { 21, 22, 23, 24 }}
+
+Iterating over axis 2:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xaxis_iterator.hpp>
+    #include <xtensor/io/xio.hpp>
+
+    xarray<int> a = {{{1, 2, 3, 4},
+                      {5, 6, 7, 8},
+                      {9, 10, 11, 12}},
+                     {{13, 14, 15, 16},
+                      {17, 18, 19, 20},
+                      {21, 22, 23, 24}}};
+
+    auto iter = axis_begin(a, 2u);
+    auto end = axis_end(a, 2u);
+    while(iter != end)
+    {
+        std::cout << *iter++ << std::endl;
+    }
+    // Prints:
+    // {{  1,  5,  9 }
+    //  { 13, 17, 21 }}
+    // {{  2,  6, 10 },
+    //  { 14, 18, 22 }}
+    // {{  3,  7, 11 },
+    //  { 15, 19, 23 }}
+    // {{  4,  8, 12 },
+    //  { 16, 20, 24 }}
diff --git a/docs/source/quickref/manipulation.rst b/docs/source/quickref/manipulation.rst
new file mode 100644
index 000000000..d020d1fac
--- /dev/null
+++ b/docs/source/quickref/manipulation.rst
@@ -0,0 +1,136 @@
+.. 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.
+
+Manipulation
+============
+
+atleast_Nd
+----------
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a0 = 123;
+    auto r1 = xt::atleast_1d(a0);
+
+    xt::xarray<int> a1 = { 1, 2, 3 };
+    auto r2 = xt::atleast_2d(a1);
+    auto r3 = xt::atleast_3d(a1);
+    auto r4 = xt::atleast_Nd<4>(a1);
+
+expand_dims
+-----------
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    auto r0 = xt::expand_dims(a, 0);
+    auto r1 = xt::expand_dims(a, 1);
+    auto r2 = xt::expand_dims(a, 2);
+
+flip
+----
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    auto f0 = xt::flip(a, 0);
+    auto f1 = xt::flip(a, 1);
+
+repeat
+------
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2}, {3, 4}};
+    auto r0 = xt::repeat(a, 3, 1);
+    auto r1 = xt::repeat(a, {1, 2}, 0);
+
+roll
+----
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    auto t0 = xt::roll(a, 2);
+    auto t1 = xt::roll(a, 2, 1);
+
+rot90
+-----
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    auto r0 = xt::rot90<1>(a);
+    auto r1 = xt::rot90<-2>(a);
+    auto r2 = xt::rot90(a);
+    auto r4 = xt::rot90(a, {-2, -1});
+
+split
+-----
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    auto s0 = xt::split(a, 3);
+    auto s1 = xt::split(a, 3, 1);
+
+hsplit
+------
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+    auto res = xt::hsplit(a, 2);
+
+vsplit
+------
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
+    auto res = xt::vsplit(a, 2);
+
+squeeze
+-------
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    auto b = xt::xarray<double>::from_shape({3, 3, 1, 1, 2, 1, 3});
+    auto sq0 = xt::xqueeze(b);
+    auto sq1 = squeeze(b, {2, 3}, check_policy::full());
+    auto sq2 = squeeze(b, 2);
+
+trim_zeros
+----------
+
+.. code::
+
+    #include <xtensor/misc/xmanipulation.hpp>
+
+    xt::xarray<int> a = {0, 0, 0, 1, 3, 0};
+    auto t0 = xt::trim_zeros(a);
+    auto t1 = xt::trim_zeros(a, "b");
+    auto t2 = xt::trim_zeros(a, "f");
diff --git a/docs/source/quickref/math.rst b/docs/source/quickref/math.rst
new file mode 100644
index 000000000..0b5d5f61a
--- /dev/null
+++ b/docs/source/quickref/math.rst
@@ -0,0 +1,119 @@
+.. 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.
+
+Mathematical functions
+======================
+
+Operations and functions of *xtensor* are not evaluated until they are assigned.
+In the following, ``e1``, ``e2`` and ``e3`` can be arbitrary tensor expressions.
+The results of operations and functions are assigned to :cpp:type:`xt::xarray` in the examples,
+but that could be any other container (or even views). To keep an unevaluated
+operator / function, assign to an ``auto`` variable:
+
+.. code::
+
+    auto res = e1 + e2;
+
+See :ref:`lazy-evaluation` for more details on unevaluated expressions.
+
+Basic functions
+---------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::abs(e1);
+    xt::xarray<double> res1 = xt::fabs(e1);
+    xt::xarray<double> res2 = xt::fmod(e1, e2);
+    xt::xarray<double> res3 = xt::remainder(e1, e2);
+    xt::xarray<double> res4 = xt::fma(e1, e2, e3);
+    xt::xarray<double> res5 = xt::maximum(e1, e2);
+    xt::xarray<double> res6 = xt::minimum(e2, e2);
+    xt::xarray<double> res7 = xt::fmax(e1, e2);
+    xt::xarray<double> res8 = xt::fmin(e1, e2);
+    xt::xarray<double> res9 = xt::fdim(e1, e2);
+    xt::xarray<double> res10 = xt::clip(e1, e2, e3);
+    xt::xarray<double> res11 = xt::sign(e1);
+
+Exponential functions
+---------------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::exp(e1);
+    xt::xarray<double> res2 = xt::exp2(e1);
+    xt::xarray<double> res3 = xt::expm1(e1);
+    xt::xarray<double> res4 = xt::log(e1);
+    xt::xarray<double> res5 = xt::log2(e1);
+    xt::xarray<double> res6 = xt::log10(e1);
+    xt::xarray<double> res7 = xt::log1p(e1);
+
+Power functions
+---------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::pow(e1, e2);
+    xt::xarray<double> res1 = xt::sqrt(e1);
+    xt::xarray<double> res2 = xt::cbrt(e1);
+    xt::xarray<double> res3 = xt::hypot(e1, e2);
+
+Trigonometric functions
+-----------------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::cos(e1);
+    xt::xarray<double> res1 = xt::sin(e1);
+    xt::xarray<double> res2 = xt::tan(e1);
+    xt::xarray<double> res3 = xt::acos(e2);
+    xt::xarray<double> res4 = xt::asin(e2);
+    xt::xarray<double> res5 = xt::atan(e2);
+    xt::xarray<double> res6 = xt::atan2(e2, e3);
+
+Hyperbolic functions
+--------------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::cosh(e1);
+    xt::xarray<double> res1 = xt::sinh(e1);
+    xt::xarray<double> res2 = xt::tanh(e1);
+    xt::xarray<double> res3 = xt::acosh(e2);
+    xt::xarray<double> res4 = xt::asinh(e2);
+    xt::xarray<double> res5 = xt::atanh(e2);
+
+Error and gamma functions
+-------------------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::erf(e1);
+    xt::xarray<double> res1 = xt::erfc(e1);
+    xt::xarray<double> res2 = xt::tgamma(e1);
+    xt::xarray<double> res3 = xt::lgamma(e1);
+
+Nearest integer operations
+--------------------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::ceil(e1);
+    xt::xarray<double> res1 = xt::floor(e1);
+    xt::xarray<double> res2 = xt::trunc(e1);
+    xt::xarray<double> res3 = xt::round(e1);
+    xt::xarray<double> res4 = xt::nearbyint(e1);
+    xt::xarray<double> res5 = xt::rint(e1);
+
+Classification functions
+------------------------
+
+.. code::
+
+    xt::xarray<double> res0 = xt::isfinite(e1);
+    xt::xarray<double> res1 = xt::isinf(e1);
+    xt::xarray<double> res2 = xt::isnan(e1);
+    xt::xarray<double> res3 = xt::isclose(e1, e2);
+    bool res4 = xt::allclose(e1, e2);
diff --git a/docs/source/quickref/operator.rst b/docs/source/quickref/operator.rst
new file mode 100644
index 000000000..3690ce088
--- /dev/null
+++ b/docs/source/quickref/operator.rst
@@ -0,0 +1,86 @@
+.. 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
+=========
+
+Operations and functions of *xtensor* are not evaluated until they are assigned.
+In the following, ``e1``, ``e2`` and ``e3`` can be arbitrary tensor expressions.
+The results of operations and functions are assigned to :cpp:type:`xt::xarray` in the examples,
+but that could be any other container (or even views). To keep an unevaluated
+operator / function, assign to an ``auto`` variable:
+
+.. code::
+
+    auto res = e1 + e2;
+
+See :ref:`lazy-evaluation` for more details on unevaluated expressions.
+
+Arithmetic operators
+--------------------
+
+.. code::
+
+    xt::xarray<double> res0 = -e1;
+    xt::xarray<double> res1 = e1 + e2;
+    xt::xarray<double> res2 = e1 - e2;
+    xt::xarray<double> res3 = e1 * e2;
+    xt::xarray<double> res4 = e1 / e2;
+    xt::xarray<double> res5 = e1 % e2;
+
+    res1 += e2;
+    res2 -= e2;
+    res3 *= e2;
+    res4 /= e2;
+    res5 %= e2;
+
+Bitwise operators
+-----------------
+
+.. code::
+
+    xt::xarray<double> res0 = e1 & e2;
+    xt::xarray<double> res1 = e1 | e2;
+    xt::xarray<double> res2 = e1 ^ e2;
+    xt::xarray<double> res3 = ~e1;
+
+    res0 &= e2;
+    res1 |= e2;
+
+Logical operators
+-----------------
+
+.. code::
+
+    xt::xarray<double> res0 = e1 && e2;
+    xt::xarray<double> res1 = e1 || e2;
+    xt::xarray<double> res2 = !e1;
+    bool res3 = any(e1);
+    bool res4 = all(e1);
+    xt::xarray<double> res5 = where(e1, e2, e3);
+
+Comparison operators
+--------------------
+
+Comparison operators return expressions performing element-wise
+comparison:
+
+.. code::
+
+    xt::xarray<double> res0 = e1 < e2;
+    xt::xarray<double> res1 = e1 > e2;
+    xt::xarray<double> res2 = e1 <= e2;
+    xt::xarray<double> res3 = e1 >= e2;
+    xt::xarray<double> res4 = xt::equal(e1, e2);
+    xt::xarray<double> res5 = xt::not_equal(e1, e2);
+
+Except for equality and inequality operators which performs traditional
+comparison and return a boolean:
+
+.. code::
+
+    bool res0 = e1 == e2; // true if all elements in e1 equal those in e2
+    bool res1 = e1 != e2;
diff --git a/docs/source/quickref/reducer.rst b/docs/source/quickref/reducer.rst
new file mode 100644
index 000000000..064bb0261
--- /dev/null
+++ b/docs/source/quickref/reducer.rst
@@ -0,0 +1,146 @@
+.. 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.
+
+Reductions
+==========
+
+Sum
+---
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<int> r0 = xt::sum(a, {1});
+    std::cout << r0 << std::endl;
+    // Outputs {6, 15}
+
+    xt::xarray<int> r1 = xt::sum(a);
+    std::cout << r1 << std::endl;
+    // Outputs {21}, i.e. r1 is a 0D-tensor
+
+    int r2 = xt::sum(a)();
+    std::cout << r2 << std::endl;
+    // Outputs 21
+
+    auto r3 = xt::sum(a, {1});
+    std::cout << r3 << std::endl;
+    // Outputs {6, 15}, but r3 is an unevaluated expression
+    // the values are computed upon each access
+
+    auto r4 = xt::sum<long int>(a, {1});
+    // r4 holds long int values
+
+    auto r5 = xt::sum<short>(a, {1});
+    // r5 holds int values
+
+    auto r6 = xt::sum<xt::big_promote_value_type_t<decltype(a)>>(a, {1});
+    // r6 holds long long int values
+
+Prod
+----
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2}, {3, 4}};
+    xt::xarray<int> r0 = xt::prod(a, {1});
+    xt::xarray<int> r1 = xt::prod(a);
+    int r2 = xt::prod(a)();
+    auto r3 = xt::prod(a, {0});
+    auro r4 = xt::prod<long int>(a, {0});
+    auto r5 = xt::prod<xt::big_promote_value_type_t<decltype(a)>>(a, {1});
+
+Mean
+----
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<int> r0 = xt::mean(a, {1});
+    xt::xarray<int> r1 = xt::mean(a);
+    int r2 = xt::mean(a)();
+    auto r3 = xt::mean(a, {0});
+
+Variance
+--------
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<int> r0 = xt::variance(a, {1});
+    xt::xarray<int> r1 = xt::variance(a);
+    int r2 = xt::variance(a)();
+    auto r3 = xt::variance(a, {0});
+
+Standard deviation
+------------------
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<int> r0 = xt::stddev(a, {1});
+    xt::xarray<int> r1 = xt::stddev(a);
+    int r2 = xt::stddev(a)();
+    auto r3 = xt::stddev(a, {0});
+
+Diff
+----
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<int> r0 = xt::diff(a, 1, {0});
+    std::cout << r0 << std::endl;
+    // Outputs {{1, 1}, {1, 1}}
+
+Amax
+----
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<int> r0 = xt::amax(a, {1});
+    std::cout << r0 << std::endl;
+    // Outputs {3, 6}
+
+Amin
+----
+
+.. code::
+
+    xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+    xt::xarray<int> r0 = xt::amin(a, {0});
+    std::cout << r0 << std::endl;
+    // Outputs {1, 2, 3}
+
+Norms
+-----
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    xt::xarray<double> b0 = xt::norm_l0(a, {1});
+    xt::xarray<double> b1 = xt::norm_l1(a, {1});
+    xt::xarray<double> b2 = xt::norm_sq(a, {1});
+    xt::xarray<double> b3 = xt::norm_l2(a, {1});
+    xt::xarray<double> b4 = xt::norm_linf(a, {1});
+    xt::xarray<double> b5 = xt::norm_lp_to_p(a, {1});
+    xt::xarray<double> b6 = xt::norm_lp(a, {1});
+    xt::xarray<double> b7 = xt::norm_induced_l1(a, {1});
+    xt::xarray<double> b8 = xt::norm_induced_linf(a, {1});
+
+Accumulating functions
+----------------------
+
+.. code::
+
+    xt::xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+    xt::xarray<double> b0 = xt::cumsum(a, {1});
+    std::cout << b0 << std::endl;
+    // Outputs {{1., 3., 6.}, {4., 9., 15.}}
+
+    xt::xarray<double> b1 = xt::cumprod(a, {1});
+    std::cout << b1 << std::endl;
+    // Outputs {{1., 2., 6.}, {4., 20., 120.}}
diff --git a/docs/source/random.rst b/docs/source/random.rst
new file mode 100644
index 000000000..c0f555664
--- /dev/null
+++ b/docs/source/random.rst
@@ -0,0 +1,128 @@
+.. 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.
+
+.. _random:
+
+******
+Random
+******
+
+:cpp:func:`xt::random::seed`
+============================
+
+Set seed for random number generator. A common practice to get a 'real' random number is to use:
+
+.. code-block:: cpp
+
+    #include <ctime>
+
+    ...
+
+    xt::random::seed(time(NULL));
+
+:cpp:func:`xt::random::rand`
+============================
+
+:cpp:func:`xt::random::randint`
+===============================
+
+:cpp:func:`xt::random::randn`
+=============================
+
+:cpp:func:`xt::random::binomial`
+================================
+
+:cpp:func:`xt::random::geometric`
+=================================
+
+:cpp:func:`xt::random::negative_binomial`
+=========================================
+
+:cpp:func:`xt::random::poisson`
+===============================
+
+:cpp:func:`xt::random::exponential`
+===================================
+
+:cpp:func:`xt::random::gamma`
+=============================
+
+Produces (an array of) random positive floating-point values,
+distributed according to the probability density:
+
+.. math::
+
+    P(x) = x^{\alpha-1} \frac{e^{-x / \beta}}{\beta^\alpha \; \Gamma(\alpha)}
+
+where :math:`\alpha` is the shape (also known as :math:`k`) and :math:`\beta` the scale
+(also known as :math:`\theta`), and :math:`\Gamma` is the Gamma function.
+
+.. note::
+
+    Different from NumPy, the first argument is the shape of the output array.
+
+.. seealso::
+
+    *   :any:`numpy.random.gamma`
+    *   `std::gamma_distribution <https://en.cppreference.com/w/cpp/numeric/random/gamma_distribution.html>`_
+    *   `Weisstein, Eric W. "Gamma Distribution." From MathWorld – A Wolfram Web Resource. <https://mathworld.wolfram.com/GammaDistribution.html>`_
+    *   `Wikipedia, "Gamma distribution". <https://en.wikipedia.org/wiki/Gamma_distribution>`_
+
+:cpp:func:`xt::random::weibull`
+===============================
+
+Produces (an array of) random positive floating-point values,
+distributed according to the probability density:
+
+.. math::
+
+    P(x) = \frac{a}{b} \left( \frac{x}{b} \right)^{a - 1} e^{-(x / b)^a}
+
+where :math:`a > 0` is the shape parameter and :math:`b > 0` the scale parameter.
+In particular, a random variable is produced as
+
+.. math::
+
+    X = b (- \ln (U))^{1/a}
+
+where :math:`U` is drawn from the uniform distribution (0, 1].
+
+By default both the shape :math:`a = 1` and the scale :math:`b = 1`.
+Note that you can specify only :math:`a` while choosing the default for :math:`b`.
+
+.. note::
+
+    Different from NumPy, the first argument is the shape of the output array.
+
+.. seealso::
+
+    *   :any:`numpy.random.weibull`
+    *   `std::weibull_distribution <https://en.cppreference.com/w/cpp/numeric/random/weibull_distribution.html>`_
+    *   `Wikipedia, "Weibull distribution". <https://en.wikipedia.org/wiki/Weibull_distribution>`_
+
+:cpp:func:`xt::random::extreme_value`
+=====================================
+
+:cpp:func:`xt::random::lognormal`
+=================================
+
+:cpp:func:`xt::random::cauchy`
+==============================
+
+:cpp:func:`xt::random::fisher_f`
+================================
+
+:cpp:func:`xt::random::student_t`
+=================================
+
+:cpp:func:`xt::random::choice`
+==============================
+
+:cpp:func:`xt::random::shuffle`
+===============================
+
+:cpp:func:`xt::random::permutation`
+===================================
diff --git a/docs/source/rank.rst b/docs/source/rank.rst
new file mode 100644
index 000000000..8456dc1e4
--- /dev/null
+++ b/docs/source/rank.rst
@@ -0,0 +1,116 @@
+.. 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.
+
+.. _rank:
+
+Tensor Rank
+===========
+
+Rank overload
+-------------
+
+All *xtensor*'s classes have a member ``rank`` that can be used
+to overload based on rank using *SFINAE*.
+Consider the following example:
+
+.. code-block:: cpp
+
+    template <class E, std::enable_if_t<!xt::has_rank_t<E, 2>::value, int> = 0>
+    inline E foo(E&& a)
+    {
+        ... // act on object of flexible rank, or fixed rank != 2
+    }
+
+    template <class E, std::enable_if_t<xt::has_rank_t<E, 2>::value, int> = 0>
+    inline E foo(E&& a)
+    {
+        ... // act on object of fixed rank == 2
+    }
+
+    int main()
+    {
+        xt::xarray<size_t> a = {{9, 9}, {9, 9}};
+        xt::xtensor<size_t, 1> b = {9, 9};
+        xt::xtensor<size_t, 2> c = {{9, 9}, {9, 9}};
+
+        foo(a); // flexible rank -> first overload
+        foo(b); // fixed rank == 2 -> first overload
+        foo(c); // fixed rank == 2 -> second overload
+
+        return 0;
+    }
+
+.. note::
+
+    If one wants to test for more than a single value for ``rank``,
+    one can use the default value ``SIZE_MAX`` used for flexible rank objects.
+    For example, one could have the following overloads:
+
+    .. code-block:: cpp
+
+        // flexible rank
+        template <class E, std::enable_if_t<!xt::has_fixed_rank_t<E>::value, int> = 0>
+        inline E foo(E&& a);
+
+        // fixed rank == 1
+        template <class E, std::enable_if_t<xt::has_rank_t<E, 1>::value, int> = 0>
+        inline E foo(E&& a);
+
+        // fixed rank == 2
+        template <class E, std::enable_if_t<xt::has_rank_t<E, 2>::value, int> = 0>
+        inline E foo(E&& a);
+
+    Note that fixed ranks other than 1 and 2 will raise a compiler error.
+
+    Of course, if one wants a more limited scope, one could also do the following:
+
+    .. code-block:: cpp
+
+        // flexible rank
+        inline void foo(xt::xarray<double>& a);
+
+        // fixed rank == 1
+        inline void foo(xt::xtensor<double,1>& a);
+
+        // fixed rank == 2
+        inline void foo(xt::xtensor<double,2>& a);
+
+Rank as member
+--------------
+
+If you want to use the rank as a member of your own class you can use
+:cpp:type:`xt::get_rank\<E\> <xt::get_rank>`.
+Consider the following example:
+
+.. code-block:: cpp
+
+    template <class T>
+    struct Foo
+    {
+        static const size_t rank = xt::get_rank<T>::value;
+
+        static size_t value()
+        {
+            return rank;
+        }
+    };
+
+    int main()
+    {
+        xt::xtensor<double, 1> A = xt::zeros<double>({2});
+        xt::xtensor<double, 2> B = xt::zeros<double>({2, 2});
+        xt::xarray<double> C = xt::zeros<double>({2, 2});
+
+        assert(Foo<decltype(A)>::value() == 1);
+        assert(Foo<decltype(B)>::value() == 2);
+        assert(Foo<decltype(C)>::value() == SIZE_MAX);
+
+        return 0;
+    }
+
+``xt::get_rank`` 'returns' the rank of the *xtensor* object if its rank is fixed.
+In all other cases it 'returns' ``SIZE_MAX``.
+Indeed ``xt::get_rank<xt::array<double>>::value`` is equal to ``SIZE_MAX``, but equally so is ``xt::get_rank<double>::value``.
diff --git a/docs/source/related.rst b/docs/source/related.rst
index ad2cbb8c5..60c640272 100644
--- a/docs/source/related.rst
+++ b/docs/source/related.rst
@@ -12,6 +12,8 @@
    }
    </style>
 
+.. _related-projects:
+
 Related projects
 ================
 
@@ -22,11 +24,11 @@ xtensor-python
    :alt: xtensor-python
 
 The xtensor-python_ project provides the implementation of container types
-compatible with ``xtensor``'s expression system, ``pyarray`` and ``pytensor``
-which effectively wrap numpy arrays, allowing operating on numpy arrays
+compatible with *xtensor*'s expression system, ``pyarray`` and ``pytensor``
+which effectively wrap NumPy arrays, allowing operating on NumPy arrays
 in-place.
 
-Example 1: Use an algorithm of the C++ library on a numpy array in-place
+Example 1: Use an algorithm of the C++ library on a NumPy array in-place
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 **C++ code**
@@ -34,10 +36,10 @@ Example 1: Use an algorithm of the C++ library on a numpy array in-place
 .. code::
 
     #include <numeric>                        // Standard library import for std::accumulate
-    #include "pybind11/pybind11.h"            // Pybind11 import to define Python bindings
-    #include "xtensor/xmath.hpp"              // xtensor import for the C++ universal functions
-    #define FORCE_IMPORT_ARRAY                // numpy C api loading
-    #include "xtensor-python/pyarray.hpp"     // Numpy bindings
+    #include <pybind11/pybind11.h>            // Pybind11 import to define Python bindings
+    #include <xtensor/core/xmath.hpp>         // xtensor import for the C++ universal functions
+    #define FORCE_IMPORT_ARRAY                // NumPy C api loading
+    #include <xtensor-python/pyarray.hpp>     // NumPy bindings
 
     double sum_of_sines(xt::pyarray<double> &m)
     {
@@ -61,8 +63,6 @@ Example 1: Use an algorithm of the C++ library on a numpy array in-place
 
 .. code::
 
-    Python Code
-
     import numpy as np
     import xtensor_python_test as xt
 
@@ -84,9 +84,9 @@ Example 2: Create a universal function from a C++ scalar function
 
 .. code::
 
-    #include "pybind11/pybind11.h"
+    #include <pybind11/pybind11.h>
     #define FORCE_IMPORT_ARRAY
-    #include "xtensor-python/pyvectorize.hpp"
+    #include <xtensor-python/pyvectorize.hpp>
     #include <numeric>
     #include <cmath>
 
@@ -135,7 +135,7 @@ xtensor-python-cookiecutter
    :width: 50%
 
 The xtensor-python-cookiecutter_ project helps extension authors create Python
-extension modules making use of `xtensor`.
+extension modules making use of *xtensor*.
 
 It takes care of the initial work of generating a project skeleton with
 
@@ -144,7 +144,7 @@ It takes care of the initial work of generating a project skeleton with
 A few examples included in the resulting project including
 
 - A universal function defined from C++
-- A function making use of an algorithm from the STL on a numpy array
+- A function making use of an algorithm from the STL on a NumPy array
 - Unit tests
 - The generation of the HTML documentation with sphinx
 
@@ -155,7 +155,7 @@ xtensor-julia
    :alt: xtensor-julia
 
 The xtensor-julia_ project provides the implementation of container types
-compatible with ``xtensor``'s expression system, ``jlarray`` and ``jltensor``
+compatible with *xtensor*'s expression system, ``jlarray`` and ``jltensor``
 which effectively wrap Julia arrays, allowing operating on Julia arrays
 in-place.
 
@@ -168,8 +168,8 @@ Example 1: Use an algorithm of the C++ library with a Julia array
 
     #include <numeric>                        // Standard library import for std::accumulate
     #include <cxx_wrap.hpp>                   // CxxWrap import to define Julia bindings
-    #include "xtensor-julia/jltensor.hpp"     // Import the jltensor container definition
-    #include "xtensor/xmath.hpp"              // xtensor import for the C++ universal functions
+    #include <xtensor-julia/jltensor.hpp>     // Import the jltensor container definition
+    #include <xtensor/core/xmath.hpp>         // xtensor import for the C++ universal functions
 
     double sum_of_sines(xt::jltensor<double, 2> m)
     {
@@ -200,7 +200,7 @@ Example 1: Use an algorithm of the C++ library with a Julia array
 
    1.2853996391883833
 
-Example 2: Create a numpy-style universal function from a C++ scalar function
+Example 2: Create a NumPy-style universal function from a C++ scalar function
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 **C++ code**
@@ -208,7 +208,7 @@ Example 2: Create a numpy-style universal function from a C++ scalar function
 .. code::
 
     #include <cxx_wrap.hpp>
-    #include "xtensor-julia/jlvectorize.hpp"
+    #include <xtensor-julia/jlvectorize.hpp>
 
     double scalar_func(double i, double j)
     {
@@ -249,7 +249,7 @@ xtensor-julia-cookiecutter
    :width: 50%
 
 The xtensor-julia-cookiecutter_ project helps extension authors create Julia
-extension modules making use of `xtensor`.
+extension modules making use of *xtensor*.
 
 It takes care of the initial work of generating a project skeleton with
 
@@ -257,8 +257,8 @@ It takes care of the initial work of generating a project skeleton with
 
 A few examples included in the resulting project including
 
-- A numpy-style universal function defined from C++
-- A function making use of an algorithm from the STL on a numpy array
+- A NumPy-style universal function defined from C++
+- A function making use of an algorithm from the STL on a NumPy array
 - Unit tests
 - The generation of the HTML documentation with sphinx
 
@@ -269,7 +269,7 @@ xtensor-r
    :alt: xtensor-r
 
 The xtensor-r_ project provides the implementation of container types
-compatible with ``xtensor``'s expression system, ``rarray`` and ``rtensor``
+compatible with *xtensor*'s expression system, ``rarray`` and ``rtensor``
 which effectively wrap R arrays, allowing operating on R arrays in-place.
 
 Example 1: Use an algorithm of the C++ library on a R array in-place
@@ -280,8 +280,8 @@ Example 1: Use an algorithm of the C++ library on a R array in-place
 .. code::
 
     #include <numeric>                    // Standard library import for std::accumulate
-    #include "xtensor/xmath.hpp"          // xtensor import for the C++ universal functions
-    #include "xtensor-r/rarray.hpp"       // R bindings
+    #include <xtensor/core/xmath.hpp>     // xtensor import for the C++ universal functions
+    #include <xtensor-r/rarray.hpp>       // R bindings
     #include <Rcpp.h>
 
     using namespace Rcpp;
@@ -318,7 +318,7 @@ xtensor-blas
 The xtensor-blas_ project is an extension to the xtensor library, offering
 bindings to BLAS and LAPACK libraries through cxxblas and cxxlapack from the
 FLENS project. ``xtensor-blas`` powers the ``xt::linalg`` functionalities,
-which are the counterpart to numpy's ``linalg`` module.
+which are the counterpart to NumPy's ``linalg`` module.
 
 xtensor-fftw
 ------------
@@ -328,7 +328,7 @@ xtensor-fftw
 
 The xtensor-fftw_ project is an extension to the xtensor library, offering
 bindings to the fftw library.  ``xtensor-fftw`` powers the ``xt::fftw``
-functionalities, which are the counterpart to numpy's ``fft`` module.
+functionalities, which are the counterpart to NumPy's ``fft`` module.
 
 Example 1: Calculate a derivative in Fourier space
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -339,13 +339,13 @@ Calculate the derivative of a (discretized) field in Fourier space, e.g. a sine
 
 .. code::
 
-    #include <xtensor-fftw/basic.hpp>   // rfft, irfft
-    #include <xtensor-fftw/helper.hpp>  // rfftscale 
-    #include <xtensor/xarray.hpp>
-    #include <xtensor/xbuilder.hpp>     // xt::arange
-    #include <xtensor/xmath.hpp>        // xt::sin, cos
+    #include <xtensor-fftw/basic.hpp>          // rfft, irfft
+    #include <xtensor-fftw/helper.hpp>         // rfftscale
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/generators/xbuilder.hpp> // xt::arange
+    #include <xtensor/core/xmath.hpp>          // xt::sin, cos
     #include <complex>
-    #include <xtensor/xio.hpp>
+    #include <xtensor/io/xio.hpp>
 
     // generate a sinusoid field
     double dx = M_PI / 100;
@@ -406,7 +406,7 @@ The xsimd_ project provides a unified API for making use of the SIMD features
 of modern preprocessors for C++ library authors. It also provides accelerated
 implementation of common mathematical functions operating on batches.
 
-xsimd_ is an optional dependency to ``xtensor`` which enable SIMD vectorization
+xsimd_ is an optional dependency to *xtensor* which enable SIMD vectorization
 of xtensor operations. This feature is enabled with the ``XTENSOR_USE_XSIMD``
 compilation flag, which is set to ``false`` by default.
 
@@ -416,18 +416,49 @@ xtl
 .. image:: xtl.svg
    :alt: xtl
 
-The xtl_ project, the only dependency of ``xtensor`` is a C++ template library
-holding the implementation of basic tools used accross the libraries in the
-QuantStack ecosystem.
-
-.. _xtensor-python: https://github.com/QuantStack/xtensor-python
-.. _xtensor-python-cookiecutter: https://github.com/QuantStack/xtensor-python-cookiecutter
-.. _xtensor-julia: https://github.com/QuantStack/xtensor-julia
-.. _xtensor-julia-cookiecutter: https://github.com/QuantStack/xtensor-julia-cookiecutter
-.. _xtensor-r: https://github.com/QuantStack/xtensor-r
-.. _xtensor-blas: https://github.com/QuantStack/xtensor-blas
-.. _xtensor-io: https://github.com/QuantStack/xtensor-io
-.. _xtensor-fftw: https://github.com/egpbos/xtensor-fftw
-.. _xtensor-ros: https://github.com/wolfv/xtensor_ros
-.. _xsimd: https://github.com/QuantStack/xsimd
-.. _xtl: https://github.com/QuantStack/xtl
+The xtl_ project, the only dependency of *xtensor* is a C++ template library
+holding the implementation of basic tools used across the libraries in the ecosystem.
+
+xframe
+------
+
+.. image:: xframe.svg
+   :alt: xframe
+
+The xframe_ project provides multi-dimensional labeled arrays and a data frame for C++,
+based on *xtensor* and *xtl*.
+
+`xframe` provides
+
+- an extensible expression system enabling lazy broadcasting.
+- an API following the idioms of the C++ standard library.
+- tools to manipulate n-dimensional labeled tensor expressions.
+
+The API of xframe is inspired by xarray_, a Python package implementing labelled multi-dimensional arrays and datasets.
+
+z5
+--
+
+The z5_ project implements the zarr_ and n5_ storage specifications in C++.
+Both specifications describe chunked nd-array storage similar to HDF5, but
+use the filesystem to store chunks. This design allows for parallel write access
+and efficient cloud based storage, crucial requirements in modern big data applications.
+The project uses *xtensor* to represent arrays in memory
+and also provides a python wrapper based on ``xtensor-python``.
+
+.. _xtensor-python: https://github.com/xtensor-stack/xtensor-python
+.. _xtensor-python-cookiecutter: https://github.com/xtensor-stack/xtensor-python-cookiecutter
+.. _xtensor-julia: https://github.com/xtensor-stack/xtensor-julia
+.. _xtensor-julia-cookiecutter: https://github.com/xtensor-stack/xtensor-julia-cookiecutter
+.. _xtensor-r: https://github.com/xtensor-stack/xtensor-r
+.. _xtensor-blas: https://github.com/xtensor-stack/xtensor-blas
+.. _xtensor-io: https://github.com/xtensor-stack/xtensor-io
+.. _xtensor-fftw: https://github.com/xtensor-stack/xtensor-fftw
+.. _xtensor-ros: https://github.com/RoboStack/xtensor-ros
+.. _xsimd: https://github.com/xtensor-stack/xsimd
+.. _xtl: https://github.com/xtensor-stack/xtl
+.. _xframe: https://github.com/xtensor-stack/xframe
+.. _z5: https://github.com/constantinpape/z5
+.. _zarr: https://github.com/zarr-developers/zarr-python
+.. _n5: https://github.com/saalfeldlab/n5
+.. _xarray: https://docs.xarray.dev/en/stable/
diff --git a/docs/source/releasing.rst b/docs/source/releasing.rst
index c56bddaa9..b7fd4c608 100644
--- a/docs/source/releasing.rst
+++ b/docs/source/releasing.rst
@@ -13,7 +13,7 @@ Releasing a new version
 From the master branch of xtensor
 
 - Make sure that you are in sync with the master branch of the upstream remote.
-- Update the `changelog <https://github.com/QuantStack/xtensor/blob/master/docs/source/changelog.rst>`_.
+- Update the `changelog <https://github.com/xtensor-stack/xtensor/blob/master/docs/source/changelog.rst>`_.
 - In file ``xtensor_config.hpp``, set the macros for ``XTENSOR_VERSION_MAJOR``, ``XTENSOR_VERSION_MINOR`` and ``XTENSOR_VERSION_PATCH`` to the desired values.
 - In file ``CMakeLists.txt``, update the version of the dependencies and the corresponding variables, e.g. ``xtl_REQUIRED_VERSION``.
 - In file ``environment.yml``, update the version of the dependencies including ``xtensor``.
diff --git a/docs/source/scalar.rst b/docs/source/scalar.rst
index c0b1bf436..8d74dc8a5 100644
--- a/docs/source/scalar.rst
+++ b/docs/source/scalar.rst
@@ -10,13 +10,13 @@ Scalars and 0-D expressions
 Assignment
 ----------
 
-In ``xtensor``, scalars are handled as if they were 0-dimensional expressions. This means that when assigning
-a scalar value to an ``xarray``, this last one is **not filled** with that value, but resized to become a 0-D
-array containing the scalar value:
+In *xtensor*, scalars are handled as if they were 0-dimensional expressions.
+This means that when assigning a scalar value to an :cpp:type:`xt::xarray`, the array is **not filled** with that value,
+but resized to become a 0-D array containing the scalar value:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<double> a = {{0., 1., 2.}, {3., 4., 5.}};
     double s = 1.2;
@@ -36,7 +36,7 @@ Assuming that the scalar assignment does not resize the array, we have the follo
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<double> a = {{0., 1., 2.}, {3., 4., 5.}};
     double s = 1.2;
@@ -48,18 +48,18 @@ This is not consistent with the behavior of the copy constructor from a scalar:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<double> a(1.2);
     std::cout << a << std::endl;
     // prints 1.2 (a is a 0-D array)
 
 A way to fix this is to disable copy construction from scalar, and provide a constructor taking a shape and
-a scalar: 
+a scalar:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
+    #include <xtensor/containers/xarray.hpp>
 
     xt::xarray<double> a = {{0., 1., 2.}, {3., 4., 5.}};
     a = 1.2;
@@ -92,11 +92,12 @@ Then, somewhere in your program:
     // ...
     // later
     eval_mean(a, b);
-    // Now b is a 0-D container holding 21.
+    // Now b is a 0-D container holding 3.5.
 
-After that, ``b`` is a 0-dimensional array containing the mean of the elements of ``a``. Indeed, ``sum(a) / e1.size()`` is a
-0-D expression, thus when assigned to ``b``, this latter is resized. Later, you realize that you also need the sum of the elements
-of ``a``. Since the ``eval_mean`` function already computes it, you decide to return it from that function:
+After that, ``b`` is a 0-dimensional array containing the mean of the elements of ``a``.
+Indeed, ``sum(a) / e1.size()`` is a 0-D expression, thus when assigned to ``b``, this latter is resized.
+Later, you realize that you also need the sum of the elements of ``a``.
+Since the ``eval_mean()`` function already computes it, you decide to return it from that function:
 
 .. code::
 
@@ -120,11 +121,11 @@ And then you change the client code:
     double s = eval_mean(a, b);
     // Now b is a 2-D container!
 
-After that, ``b`` has become a 2-dimensional array! Indeed, since assigning a scalar to an expression does not resize it, the change in
-``eval_mean`` implementation now assigns the mean of ``a`` to each elements of ``b``.
+After that, ``b`` has become a 2-dimensional array!
+Indeed, since assigning a scalar to an expression does not resize it, the change in ``eval_mean()``
+implementation now assigns the mean of ``a`` to each elements of ``b``.
 
 This simple example shows that without consistency between scalars and 0-D expressions, refactoring the code to cache the result
 of some 0-D computation actually *silently* changes the shape of the expressions that this result is assigned to.
 
 The only way to avoid that behavior and the bugs it leads to is to handle scalars as if they were 0-dimensional expressions.
-
diff --git a/docs/source/view.rst b/docs/source/view.rst
index 4a8db5614..95b6365b8 100644
--- a/docs/source/view.rst
+++ b/docs/source/view.rst
@@ -4,34 +4,37 @@
 
    The full license is in the file LICENSE, distributed with this software.
 
+.. _view-description:
+
 Views
 =====
 
-Views are used to adapt the shape of an ``xexpression`` without changing it, nor copying it. `xtensor`
-provides many kinds of views.
+Views are used to adapt the shape of an :cpp:type:`xt::xexpression` without changing it, nor copying it. Views are
+convenient tools for assigning parts of an expression: since they do not copy the underlying expression,
+assigning to the view actually assigns to the underlying expression. *xtensor* provides many kinds of views.
 
 Sliced views
 ------------
 
-Sliced views consist of the combination of the ``xexpression`` to adapt, and a list of ``slice`` that specify how
-the shape must be adapted. Sliced views are implemented by the ``xview`` class. Objects of this type should not be
-instantiated directly, but though the ``view`` helper function.
+Sliced views consist of the combination of the :cpp:type:`xt::xexpression` to adapt, and a list of ``slice`` that specify how
+the shape must be adapted. Sliced views are implemented by the :cpp:type:`xt::xview` class. Objects of this type should not be
+instantiated directly, but though the :cpp:func:`xt::view` helper function.
 
 Slices can be specified in the following ways:
 
 - selection in a dimension by specifying an index (unsigned integer)
-- ``range(min, max)``, a slice representing an interval
-- ``range(min, max, step)``, a slice representing a stepped interval
-- ``all()``, a slice representing all the elements of a dimension
-- ``newaxis()``, a slice representing an additional dimension of length one
-- ``keep(i0, i1, i2, ...)`` a slice selecting non-contiguous indices to keep on the underlying expression
-- ``drop(i0, i1, i2, ...)`` a slice selecting non-contiguous indices to drop on the underlying expression
+- :cpp:func:`xt::range(min, max) <xt::range>`, a slice representing the interval [min, max)
+- :cpp:func:`xt::range(min, max, step) <xt::range>`, a slice representing the stepped interval [min, max)
+- :cpp:func:`xt::all`, a slice representing all the elements of a dimension
+- :cpp:func:`xt::newaxis`, a slice representing an additional dimension of length one
+- :cpp:func:`xt::keep(i0, i1, i2, ...) <xt::keep>` a slice selecting non-contiguous indices to keep on the underlying expression
+- :cpp:func:`xt::drop(i0, i1, i2, ...) <xt::drop>` a slice selecting non-contiguous indices to drop on the underlying expression
 
 .. code::
 
     #include <vector>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xview.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xview.hpp>
 
     std::vector<size_t> shape = {3, 2, 4};
     xt::xarray<int> a(shape);
@@ -59,28 +62,33 @@ Slices can be specified in the following ways:
     // => v4(0, 0, 0) = a(1, 0, 0)
     // => v4(1, 1, 1) = a(2, 1, 3)
 
+    // View built with negative index
+    auto v5 = xt::view(a, -2, xt::all(), xt::range(0, 4, 2));
+    // => v5 == v2
+
 The range function supports the placeholder ``_`` syntax:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xview.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xview.hpp>
 
-    using namespace xt::placeholders;  // required for `_` to work
+    using namespace xt::placeholders;  // required for ``_`` to work
 
     auto a = xt::xarray<int>::from_shape({3, 2, 4});
     auto v1 = xt::view(a, xt::range(_, 2), xt::all(), xt::range(1, _));
     // The previous line is equivalent to
     auto v2 = xt::view(a, xt::range(0, 2), xt::all(), xt::range(1, 4));
 
-``xview`` does not perform a copy of the underlying expression. This means if you modify an element of the ``xview``,
+:cpp:type:`xt::xview` does not perform a copy of the underlying expression.
+This means if you modify an element of the :cpp:type:`xt::xview`,
 you are actually also altering the underlying expression.
 
 .. code::
 
     #include <vector>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xview.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xview.hpp>
 
     std::vector<size_t> shape = {3, 2, 4};
     xt::xarray<int> a(shape, 0);
@@ -89,19 +97,36 @@ you are actually also altering the underlying expression.
     v1(0, 0) = 1;
     // => a(1, 0, 1) = 1
 
+The convenient methods :cpp:func:`xt::row` and :cpp:func:`xt::col` are available for 2-D expressions:
+
+.. code::
+
+    #include <vector>
+    #include <xtensor/containers/xtensor.hpp>
+    #include <xtensor/views/xview.hpp>
+
+    xt::xtensor<double, 2> a = {{1, 2}, {3, 4}};
+    auto r = xt::row(a, 0);
+    // => r = {1, 2}
+    auto c = xt::col(a, -1);
+    // => c = { 2, 4 }
 
 Strided views
 -------------
 
-While the ``xt::view`` is a compile-time static expression, xtensor also contains a dynamic strided view in ``xstrided_view.hpp``.
-The strided view and the slice vector allow to dynamically push_back slices, so when the dimension is unknown at compile time, the slice
-vector can be built dynamically at runtime. Note that the slice vector is actually a type-alias for a ``std::vector`` of a ``variant`` for
-all the slice types. The strided view does not support the slices returned by the ``keep`` and ``drop`` functions.
+While the :cpp:func:`xt::view` is a compile-time static expression, xtensor also contains a dynamic
+strided view in ``xstrided_view.hpp``.
+The strided view and the slice vector allow to dynamically push_back slices, so when the dimension
+is unknown at compile time, the slice vector can be built dynamically at runtime.
+Note that the slice vector is actually a type-alias for a ``std::vector`` of a ``variant`` for
+all the slice types.
+The strided view does not support the slices returned by the :cpp:func:`xt::keep` and
+:cpp:func:`xt::drop` functions.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xstrided_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xstrided_view.hpp>
 
     auto a = xt::xarray<int>::from_shape({3, 2, 3, 4, 5});
 
@@ -124,8 +149,8 @@ Since ``xtensor 0.16.3``, a new range syntax can be used with strided views:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xstrided_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xstrided_view.hpp>
 
     using namespace xt::placeholders;
 
@@ -134,18 +159,20 @@ Since ``xtensor 0.16.3``, a new range syntax can be used with strided views:
     // The previous line is equivalent to
     auto v2 = xt::strided_view(a, {xt::range(0, 1), 1, xt::range(_, 2), xt::range(_, _, -1)});
 
-The ``xstrided_view`` is very efficient on contigous memory (e.g. ``xtensor`` or ``xarray``) but less efficient on xexpressions.
+The :cpp:type:`xt::xstrided_view` type is very efficient on contigous memory
+(e.g. :cpp:type:`xt::xtensor` or :cpp:type:`xt::xarray`) but less efficient on
+generic :cpp:type:`xt::xexpression` objects.
 
 Transposed views
 ----------------
 
-``xtensor`` provides a lazy transposed view on any expression, whose layout is either row major order or column major order. Trying to build
-a transposed view on a expression with a dynamic layout throws an exception.
+*xtensor* provides a lazy transposed view on any expression, whose layout is either row-major order or column major order.
+Trying to build a transposed view on a expression with a dynamic layout throws an exception.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xstrided_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xstrided_view.hpp>
 
     xt::xarray<int> a = { {0, 1, 2}, {3, 4, 5} };
     auto tr = xt::transpose(a);
@@ -155,19 +182,20 @@ a transposed view on a expression with a dynamic layout throws an exception.
     auto tr2 = xt::transpose(b);
     // => throw transpose_error
 
-Like the strided view, the transposed view is built upon the ``xstrided_view``.
+Like the strided view, the transposed view is built upon the :cpp:type:`xt::xstrided_view`.
 
 Flatten views
 -------------
 
-It is sometimes useful to have a one-dimensional view of all the elements of an expression. ``xtensor`` provides two functions
-for that, ``ravel`` and ``flatten``. The former one let you specify the order used to read the elements while the latter one
+It is sometimes useful to have a one-dimensional view of all the elements of an expression.
+*xtensor* provides two functions for that, :cpp:func:`xt::ravel` and :cpp:func:`xt::flatten`.
+The former one lets you specify the order used to read the elements while the latter one
 uses the layout of the expression.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xstrided_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xstrided_view.hpp>
 
     xt::xarray<int> a = { {0, 1, 2}, {3, 4, 5} };
     auto flc = xt::ravel<layout_type::column_major>(a);
@@ -178,19 +206,19 @@ uses the layout of the expression.
     std::cout << fl << std::endl;
     // => prints { 0, 1, 2, 3, 4, 5 }
 
-Like the strided view and the transposed view, the flatten view is built upon the ``xstrided_view``.
+Like the strided view and the transposed view, the flatten view is built upon the :cpp:type:`xt::xstrided_view`.
 
 Reshape views
 -------------
 
 The reshape view allows to handle an expression as if it was given a new shape, however no additional memory allocation occurs,
 the original expression keeps its shape. Like any view, the underlying expression is not copied, thus assigning a value through
-the view modifies the underlying exression.
+the view modifies the underlying expression.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xstrided_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xstrided_view.hpp>
 
     auto a = xt::xarray<int>::from_shape({3, 2, 4});
     auto v = xt::reshape_view(a, { 4, 2, 3 });
@@ -200,19 +228,20 @@ the view modifies the underlying exression.
     v(0, 2, 0) = 4;
     // a(0, 1, 2) == 4
 
-Like the strided view and the transposed view, the reshape view is built upon the ``xstrided_view``.
+Like the strided view and the transposed view, the reshape view is built upon the :cpp:type:`xt::xstrided_view`.
 
 Dynamic views
 -------------
 
-The dynamic view is like the strided view, but with support of the slices returned by the ``keep`` and ``drop`` functions.
-However, this support has a cost and the dynamic view is slower than the strided view, even when no keeping or dropping
-slice is involved.
+The dynamic view is like the strided view, but with support of the slices returned by the
+:cpp:func:`xt::keep` and :cpp:func:`xt::drop` functions.
+However, this support has a cost and the dynamic view is slower than the strided view, even when no
+keeping or dropping of a slice is involved.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xdynamic_view.hpp
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/xdynamic_view.hp>
 
     auto a = xt::xarray<int>::from_shape({3, 2, 3, 4, 5});
     xt::xdynamic_slice_vector sv({xt::range(0, 1), xt::newaxis()});
@@ -230,14 +259,15 @@ slice is involved.
 Index views
 -----------
 
-Index views are one-dimensional views of an ``xexpression``, containing the elements whose positions are specified by a list
-of indices. Like for sliced views, the elements of the underlying ``xexpression`` are not copied. Index views should be built
-with the ``index_view`` helper function.
+Index views are one-dimensional views of an :cpp:type:`xt::xexpression`, containing the elements
+whose positions are specified by a list of indices.
+Like for sliced views, the elements of the underlying :cpp:type:`xt::xexpression` are not copied.
+Index views should be built with the :cpp:func:`xt::index_view` helper function.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xindex_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xindex_view.hpp>
 
     xt::xarray<double> a = {{1, 5, 3}, {4, 5, 6}};
     auto b = xt::index_view(a, {{0,0}, {1, 0}, {0, 1}});
@@ -245,16 +275,33 @@ with the ``index_view`` helper function.
     b += 100;
     // => a = {{101, 5, 3}, {104, 105, 6}}
 
+The type used for representing indices can be any 1-D container providing an ``std::vector``-like API.
+The same stands for the type of the list of indices:
+
+.. code::
+
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xindex_view.hpp>
+
+    xt::xarray<double> a = {{1, 5, 3}, {4, 5, 6}};
+    using index_type = std::array<std::size_t, 2>;
+    std::vector<index_type> indices = {{0, 0}, {1, 0}, {0, 1}};
+    auto b = xt::index_view(a, indices);
+    // => b = { 1, 4, 5 }
+    b += 100;
+    // => a = {{101, 5, 3}, {104, 105, 6}}
+
 Filter views
 ------------
 
-Filters are one-dimensional views holding elements of an ``xexpression`` that verify a given condition. Like for other views,
-the elements of the underlying ``xexpression`` are not copied. Filters should be built with the ``filter`` helper function.
+Filters are one-dimensional views holding elements of an :cpp:type:`xt::xexpression` that verify a given condition.
+Like for other views, the elements of the underlying :cpp:type:`xt::xexpression` are not copied.
+Filters should be built with the :cpp:func:`xt::filter` helper function.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xindex_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xindex_view.hpp>
 
     xt::xarray<double> a = {{1, 5, 3}, {4, 5, 6}};
     auto v = xt::filter(a, a >= 5);
@@ -265,15 +312,16 @@ the elements of the underlying ``xexpression`` are not copied. Filters should be
 Filtration
 ----------
 
-Sometimes, the only thing you want to do with a filter is to assign it a scalar. Though this can be done as shown
-in the previous section, this is not the *optimal* way to do it. `xtensor` provides a specially optimized mechanism
-for that, called filtration. A filtration IS NOT an ``xexpression``, the only methods it provides are scalar and
+Sometimes, the only thing you want to do with a filter is to assign it a scalar.
+Though this can be done as shown in the previous section, this is not the *optimal* way to do it.
+*xtensor* provides a specially optimized mechanism for that, called filtration.
+A filtration IS NOT an :cpp:type:`xt::xexpression`, the only methods it provides are scalar and
 computed scalar assignments.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xindex_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xindex_view.hpp>
 
     xt::xarray<double> a = {{1, 5, 3}, {4, 5, 6}};
     filtration(a, a >= 5) += 100;
@@ -282,12 +330,12 @@ computed scalar assignments.
 Masked view
 -----------
 
-Masked views are multidimensional views that apply a mask on an ``xexpression``.
+Masked views are multidimensional views that apply a mask on an :cpp:type:`xt::xexpression`.
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xmasked_view.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xmasked_view.hpp>
 
     xt::xarray<double> a = {{1, 5, 3}, {4, 5, 6}};
     xt::xarray<bool> mask = {{true, false, false}, {false, true, false}};
@@ -301,15 +349,16 @@ Masked views are multidimensional views that apply a mask on an ``xexpression``.
 Broadcasting views
 ------------------
 
-Another type of view provided by `xtensor` is *broadcasting view*. Such a view broadcast an expression to the specified
-shape. As long as the view is not assigned to an array, no memory allocation or copy occurs. Broadcasting views should be
-built with the ``broadcast`` helper function.
+Another type of view provided by *xtensor* is *broadcasting view*.
+Such a view broadcasts an expression to the specified shape.
+As long as the view is not assigned to an array, no memory allocation or copy occurs.
+Broadcasting views should be built with the :cpp:func:`xt::broadcast` helper function.
 
 .. code::
 
     #include <vector>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xbroadcast.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xbroadcast.hpp>
 
     std::vector<size_t> s1 = { 2, 3 };
     std::vector<size_t> s2 = { 3, 2, 3 };
@@ -321,22 +370,28 @@ built with the ``broadcast`` helper function.
 Complex views
 -------------
 
-In the case of tensor containing complex numbers, `xtensor` provides views returning ``xexpression`` corresponding to the real
-and imaginary parts of the complex numbers. Like for other views, the elements of the underlying ``xexpression`` are not copied.
+In the case of a tensor containing complex numbers, *xtensor* provides views returning
+:cpp:type:`xt::xexpression` corresponding to the real and imaginary parts of the complex numbers.
+Like for other views, the elements of the underlying :cpp:type:`xt::xexpression` are not copied.
 
-Functions ``xt::real`` and ``xt::imag`` respectively return views on the real and imaginary part of a complex expression.
+Functions :cpp:func:`xt::real` and :cpp:func:`xt::imag` respectively return views on the real and
+imaginary part of a complex expression.
 The returned value is an expression holding a closure on the passed argument.
 
-- The constness and value category (rvalue / lvalue) of ``real(a)`` is the same as that of ``a``. Hence, if ``a`` is a non-const lvalue,
-  ``real(a)`` is an non-const lvalue reference, to which one can assign a real expression.
-- If ``a`` has complex values, the same holds for ``imag(a)``. The constness and value category of ``imag(a)`` is the same as that of ``a``.
-- If ``a`` has real values, ``imag(a)`` returns ``zeros(a.shape())``.
+- The constness and value category (rvalue / lvalue) of :cpp:func:`xt::real(a) <xt::real>` is the same
+  as that of ``a``.
+  Hence, if ``a`` is a non-const lvalue, :cpp:func:`xt::real(a) <xt::real>` is an non-const lvalue
+  reference, to which one can assign a real expression.
+- If ``a`` has complex values, the same holds for :cpp:func:`xt::imag(a) <xt::imag>`.
+  The constness and value category of :cpp:func:`xt::imag(a) <xt::imag>` is the same as that of ``a``.
+- If ``a`` has real values, :cpp:func:`xt::imag(a) <xt::imag>` returns
+  :cpp:func:`xt::zeros(a.shape()) <xt::zeros>`.
 
 .. code::
 
     #include <complex>
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xcomplex.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/misc/xcomplex.hpp>
 
     using namespace std::complex_literals;
 
@@ -350,13 +405,14 @@ The returned value is an expression holding a closure on the passed argument.
 Assigning to a view
 -------------------
 
-When assigning an expression ``rhs`` to a container such as ``xarray``, this last one is resized so its shape is the same as the one
-of ``RHS``. However, since views *cannot be resized*, when assigning an expression to a view, broadcasting rules are applied:
+When assigning an expression ``rhs`` to a container such as :cpp:type:`xt::xarray`, the container
+is resized so its shape is the same as the one of ``rhs``.
+However, since views *cannot be resized*, when assigning an expression to a view, broadcasting rules are applied:
 
 .. code::
 
-    #include "xtensor/xarray.hpp"
-    #include "xtensor/xview.hpp"
+    #include <xtensor/containers/xarray.hpp>
+    #include <xtensor/views/xview.hpp>
 
     xarray<double> a = {{0., 1., 2.}, {3., 4., 5.}};
     double b = 1.2;
diff --git a/docs/source/xeus-cling-screenshot.png b/docs/source/xeus-cling-screenshot.png
new file mode 100644
index 000000000..543a2447a
Binary files /dev/null and b/docs/source/xeus-cling-screenshot.png differ
diff --git a/docs/source/xfft.rst b/docs/source/xfft.rst
new file mode 100644
index 000000000..20eed9619
--- /dev/null
+++ b/docs/source/xfft.rst
@@ -0,0 +1,17 @@
+.. 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``
+
+.. doxygenclass:: xt::fft::convolve
+   :project: xtensor
+   :members:
+
+.. doxygentypedef:: xt::fft::fft
+   :project: xtensor
+
+.. doxygentypedef:: xt::fft::ifft
+   :project: xtensor
diff --git a/docs/source/xframe.svg b/docs/source/xframe.svg
new file mode 100644
index 000000000..4fa903af1
--- /dev/null
+++ b/docs/source/xframe.svg
@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Adobe Illustrator 21.0.2, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   version="1.1"
+   id="Calque_1"
+   x="0px"
+   y="0px"
+   viewBox="0 0 216.9 46.800001"
+   width="695.1923"
+   height="150"
+   xml:space="preserve"
+   inkscape:version="0.91 r13725"
+   sodipodi:docname="xframe.svg"><metadata
+     id="metadata13"><rdf:RDF><cc:Work
+         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
+     id="defs11" /><sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="981"
+     inkscape:window-height="480"
+     id="namedview9"
+     showgrid="false"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0"
+     inkscape:zoom="0.51604429"
+     inkscape:cx="305.20636"
+     inkscape:cy="75.000007"
+     inkscape:window-x="0"
+     inkscape:window-y="23"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="Calque_1" /><style
+     type="text/css"
+     id="style3">
+    .st0{opacity:0.28;fill:#97D23D;enable-background:new    ;}
+    .st1{fill:#97D23D;}
+</style><path
+     class="st0"
+     d="m 25.5,23.4 c -0.6,0.8 -1.3,1.9 -2.1,3.1 3.4,5.1 8.2,12.3 8.6,13 1.2,2 2.9,3.8 4.9,5.1 0,0.1 2.1,1.3 4.6,2.1 0.2,0 0.4,0.1 0.5,0.1 l 4.8,0 0,-2.2 c -1.8,-0.2 -3.2,-0.4 -4,-0.7 -2,-0.6 -3.5,-1.6 -3.5,-1.6 -1.5,-0.9 -2.7,-2.1 -3.5,-3.4 -0.4,-0.7 -6.6,-10 -10.1,-15.3 l 0,0 c -0.1,0 -0.1,-0.1 -0.2,-0.2 M 4.8,0 0,0 0,2.2 c 1.8,0.2 3.2,0.4 4,0.7 2,0.6 3.5,1.6 3.5,1.6 1.5,1 2.7,2.2 3.5,3.5 0.4,0.7 6.6,10 10.1,15.3 l 0,0 c 0,0.1 0.1,0.1 0.1,0.2 0.6,-0.8 1.3,-1.9 2.1,-3.1 C 19.9,15.3 15.1,8.1 14.7,7.4 13.5,5.4 11.8,3.6 9.8,2.3 9.8,2.2 7.7,1 5.2,0.2 5.2,0.1 5,0.1 4.8,0"
+     id="path5"
+     inkscape:connector-curvature="0"
+     style="opacity:0.28000004;fill:#97d23d;enable-background:new" /><path
+     class="st1"
+     d="m 36.8,44.6 c -2,-1.3 -3.6,-3.1 -4.9,-5.1 -0.4,-0.7 -5.2,-7.8 -8.6,-12.9 -3.3,5.1 -8.1,12.2 -8.5,12.9 -1.2,2 -2.9,3.8 -4.9,5.1 0,0.1 -2.1,1.3 -4.6,2.1 -0.2,0 -0.4,0.1 -0.5,0.1 l 36.9,0 c -0.1,0 -0.2,-0.1 -0.4,-0.1 -2.4,-0.8 -4.4,-2 -4.5,-2.1 z M 23.4,20.3 c -0.6,0.9 -1.2,1.8 -1.7,2.6 0.5,-0.8 1.1,-1.7 1.7,-2.6 0,0 0,0 0,0 z M 11.1,38.9 c 0.4,-0.7 6.6,-10 10.1,-15.3 0.2,-0.2 0.3,-0.5 0.5,-0.8 -0.1,0.2 -0.3,0.4 -0.4,0.6 0,-0.1 -0.1,-0.1 -0.1,-0.2 C 17.7,17.9 11.5,8.6 11.1,7.9 10.3,6.6 9.1,5.4 7.6,4.5 7.6,4.5 6.1,3.5 4.1,2.9 3.2,2.7 1.8,2.4 0,2.2 L 0,44.7 C 1.8,44.5 3.2,44.3 4,44 6,43.4 7.5,42.4 7.5,42.4 9,41.4 10.2,40.2 11.1,38.9 Z M 39.3,4.6 C 37.8,5.5 36.6,6.7 35.8,8 35.4,8.7 29.2,18 25.7,23.3 c 0,0.1 -0.1,0.2 -0.2,0.2 0.1,0 0.1,0.1 0.1,0.2 3.5,5.3 9.7,14.6 10.1,15.3 0.8,1.3 2,2.5 3.5,3.4 0,0 1.5,1 3.5,1.6 0.8,0.3 2.2,0.5 4,0.7 l 0,2.1 0.1,0 0,-44.6 c -1.8,0.2 -3.2,0.4 -4,0.7 -2,0.6 -3.5,1.7 -3.5,1.7 z M 36.9,2.2 C 36.9,2.1 39,0.9 41.5,0.1 41.7,0.1 41.9,0 42,0 L 5,0 c 0.1,0 0.2,0.1 0.3,0.1 2.5,0.8 4.5,2 4.6,2.1 2,1.3 3.6,3.1 4.9,5.1 0.4,0.7 5.2,7.8 8.6,13 3.4,-5.1 8.2,-12.3 8.6,-13 1.2,-2 2.9,-3.8 4.9,-5.1 z M 72.3,0 c -5.7,0 -7.4,3.9 -7.4,8.3 0,0.3 0,2.8 0,6.3 l -5.9,0 -1.1,2.1 7,0 c 0,10.1 0,25.8 0,26.1 0.7,0.2 1.5,0.4 2.3,0.5 0,0 0,-16.2 0,-26.6 l 6.7,0 -1.1,-2.1 -5.6,0 c 0,-3.5 0,-6 0,-6.3 0,-4.6 2,-6.1 5,-6.1 1,0 2.2,0.1 3.3,0.5 l 0,0 -1.1,-2.4 C 73.7,0.1 73,0 72.3,0 Z m 101.6,12.3 -1.3,0 c -5.1,0 -7.6,2.5 -8.9,5.8 -1.3,-3.4 -3.8,-5.8 -8.9,-5.8 l -1.3,0 c -8.8,0 -10,7.4 -10,13.8 l 0,15.6 c 0.7,0.6 1.5,1.1 2.4,1.5 l 0,-16.3 c 0,-7.3 1.1,-12.4 8,-12.4 l 0.6,0 c 6.9,0 8,5.1 8,12.4 l 0,14.7 2.5,-0.1 0,-14.6 c 0,-7.3 1.1,-12.4 8,-12.4 l 0.6,0 c 6.9,0 8,5.1 8,12.4 l 0,16.4 c 0.8,-0.4 1.7,-0.9 2.4,-1.5 l 0,-15.6 c -0.1,-6.5 -1.4,-13.9 -10.1,-13.9 z m 31.7,0 c -5.4,0 -11.8,2 -11.8,15.6 0,12.6 5.5,15.5 12.3,15.5 3.7,0 6.8,-0.7 9.6,-2.3 l -0.9,-2 c -2.8,1.6 -5.4,2.2 -8.7,2.2 -5.4,0 -9.6,-1.9 -10,-11.5 l 0,-1.2 20.8,0 0,0 0,-0.8 c 0,-11.7 -4.3,-15.5 -11.3,-15.5 z M 196,26.4 c 0.2,-10.2 4.7,-12 9.5,-12 5.3,0 9,2.8 9,12 l -18.5,0 z M 118.7,12.1 c -2.4,0 -4.8,0.3 -7.1,1.5 l 1.1,2 c 1.9,-0.9 3.9,-1.3 6.1,-1.3 7.7,0 9.9,4.2 10.3,10.7 -14,0.6 -20.8,2.3 -20.8,9.5 0,5.2 2.3,8.8 10,8.8 l 0.5,0 c 9.2,0 12.8,-5 12.8,-15.6 -0.1,-10.6 -3.7,-15.6 -12.9,-15.6 z m 10.5,15.6 c 0,8.1 -1.8,13.4 -10.4,13.4 -1.9,0 -3.8,-0.3 -5.6,-1.1 -0.5,-0.2 -0.9,-0.5 -1.2,-0.8 -1,-1.1 -1.3,-2.5 -1.3,-4.5 0,-5.9 6.7,-6.9 18.4,-7.4 0,0.1 0,0.2 0.1,0.4 z M 90,17.1 90,12.9 c -0.8,0.1 -1.6,0.3 -2.3,0.5 l 0,29.4 c 0.7,0.2 1.5,0.4 2.3,0.5 l 0,-15.2 0,-0.2 c 0,-8 1.7,-13.3 10,-13.3 l 0,0 -1.1,-2 c -4.2,0.2 -7.1,1.7 -8.9,4.5 z"
+     id="path7"
+     inkscape:connector-curvature="0"
+     style="fill:#97d23d" /></svg>
diff --git a/docs/source/xsimd-small.svg b/docs/source/xsimd-small.svg
index 84d92be03..b191c15f9 100644
--- a/docs/source/xsimd-small.svg
+++ b/docs/source/xsimd-small.svg
@@ -45,8 +45,8 @@
      inkscape:current-layer="Calque_1" /><style
      type="text/css"
      id="style3">
-	.st0{fill:#D8E448;}
-	.st1{opacity:0.28;fill:#D8E448;enable-background:new    ;}
+    .st0{fill:#D8E448;}
+    .st1{opacity:0.28;fill:#D8E448;enable-background:new    ;}
 </style><path
      class="st0"
      d="M42.8,8.5c0.8-0.3,2.2-0.5,4-0.7v44.6H4.9c0.2,0,0.4-0.1,0.5-0.1c2.5-0.8,4.5-2,4.6-2.1c2-1.3,3.6-3.1,4.9-5.1  c0.4-0.6,5.2-7.8,8.6-12.9c3.4,5.1,8.2,12.3,8.6,12.9c1.2,2,2.9,3.8,4.9,5.1c0,0.1,2.1,1.3,4.6,2.1c0.2,0,0.4,0.1,0.5,0.1h4.8v-2.2  c-1.8-0.2-3.2-0.4-4-0.7c-2-0.6-3.5-1.6-3.5-1.6c-1.5-0.9-2.6-2.1-3.5-3.4c-0.4-0.7-6.6-9.9-10.1-15.3c0,0-0.1-0.1-0.1-0.2  s0.1-0.1,0.1-0.2c3.5-5.3,9.7-14.6,10.1-15.3c0.9-1.3,2-2.5,3.5-3.4C39.2,10.2,40.7,9.2,42.8,8.5z M65.4,30.1  c-4.6-1.3-7.4-2.5-7.4-6.3c0-4.4,3.1-5.7,7-5.7c2.6,0,5,0.4,7.2,1.5l0.9-2C70.5,16.3,67.7,16,65,16c-4.7,0-9.2,2.2-9.2,7.7  s4,7.2,8.7,8.5c4.5,1.2,8.1,2.1,8.1,6.2c0,4.9-3.5,6.5-7.4,6.5c-2.6,0-5.2-0.5-7.4-1.5l-1,1.9c2.5,1.1,5.4,1.6,8.5,1.6  c5.1,0,9.6-2.3,9.6-8.5C74.9,32.8,70.6,31.5,65.4,30.1z M11,44.5c0.4-0.7,6.6-9.9,10.1-15.3c0-0.1,0.1-0.1,0.1-0.2s-0.1-0.1-0.1-0.2  c-3.5-5.3-9.7-14.6-10.1-15.3c-0.9-1.3-2-2.5-3.5-3.4c0,0-1.5-1-3.5-1.6C3.2,8.3,1.8,8,0,7.8v42.4c1.8-0.2,3.2-0.4,4-0.7  c2-0.6,3.5-1.6,3.5-1.6C9,46.9,10.2,45.8,11,44.5z M9.9,7.9c2,1.3,3.6,3.1,4.9,5.1c0.4,0.6,5.2,7.8,8.6,12.9  c3.4-5.1,8.2-12.3,8.6-12.9c1.2-2,2.9-3.8,4.9-5.1c0-0.1,2.1-1.3,4.6-2.1c0.2,0,0.4-0.1,0.5-0.1H5c0.2,0,0.4,0.1,0.5,0.2  C7.8,6.6,9.9,7.8,9.9,7.9z M173.4,0v46.9c-0.8-0.1-1.6-0.3-2.3-0.5v-4c-1.9,3.1-5.2,4.6-10,4.6c-8.9,0-12.4-5-12.4-15.5  S152.2,16,161,16c4.9,0,8.1,1.5,10,4.6V0.5C171.8,0.3,172.6,0.1,173.4,0z M171.1,31.5c0-8-1.7-13.4-10-13.4c-8.4,0-10,5.3-10,13.4  s1.7,13.4,10,13.4C169.4,44.9,171.1,39.6,171.1,31.5z M86.2,47l2.3-1.2V16.5h-2.3V47z M130.4,15.9h-1.3c-5.1,0-7.6,2.5-8.9,5.8  c-1.3-3.4-3.8-5.8-8.9-5.8H110c-8.8,0-10,7.4-10,13.8v15.6c0.7,0.6,1.5,1.1,2.4,1.5V30.5c0-7.3,1.1-12.4,8-12.4h0.6  c6.9,0,8,5.1,8,12.4v14.7l2.4-0.1V30.5c0-7.3,1.1-12.4,8-12.4h0.6c6.9,0,8,5.1,8,12.4V47c0.8-0.4,1.7-0.9,2.4-1.5V29.8  C140.4,23.3,139.1,15.9,130.4,15.9z M86.2,12.3h2.3V9.9h-2.3V12.3z"
diff --git a/docs/source/xsimd.svg b/docs/source/xsimd.svg
index 163cfa07a..60d893ca0 100644
--- a/docs/source/xsimd.svg
+++ b/docs/source/xsimd.svg
@@ -1,30 +1,30 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 173.4 52.4" style="enable-background:new 0 0 173.4 52.4;" width="554.584222" height="167.590618" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#D8E448;}
-	.st1{opacity:0.28;fill:#D8E448;enable-background:new    ;}
-</style>
-<path class="st0" d="M42.8,8.5c0.8-0.3,2.2-0.5,4-0.7v44.6H4.9c0.2,0,0.4-0.1,0.5-0.1c2.5-0.8,4.5-2,4.6-2.1c2-1.3,3.6-3.1,4.9-5.1
-	c0.4-0.6,5.2-7.8,8.6-12.9c3.4,5.1,8.2,12.3,8.6,12.9c1.2,2,2.9,3.8,4.9,5.1c0,0.1,2.1,1.3,4.6,2.1c0.2,0,0.4,0.1,0.5,0.1h4.8v-2.2
-	c-1.8-0.2-3.2-0.4-4-0.7c-2-0.6-3.5-1.6-3.5-1.6c-1.5-0.9-2.6-2.1-3.5-3.4c-0.4-0.7-6.6-9.9-10.1-15.3c0,0-0.1-0.1-0.1-0.2
-	s0.1-0.1,0.1-0.2c3.5-5.3,9.7-14.6,10.1-15.3c0.9-1.3,2-2.5,3.5-3.4C39.2,10.2,40.7,9.2,42.8,8.5z M65.4,30.1
-	c-4.6-1.3-7.4-2.5-7.4-6.3c0-4.4,3.1-5.7,7-5.7c2.6,0,5,0.4,7.2,1.5l0.9-2C70.5,16.3,67.7,16,65,16c-4.7,0-9.2,2.2-9.2,7.7
-	s4,7.2,8.7,8.5c4.5,1.2,8.1,2.1,8.1,6.2c0,4.9-3.5,6.5-7.4,6.5c-2.6,0-5.2-0.5-7.4-1.5l-1,1.9c2.5,1.1,5.4,1.6,8.5,1.6
-	c5.1,0,9.6-2.3,9.6-8.5C74.9,32.8,70.6,31.5,65.4,30.1z M11,44.5c0.4-0.7,6.6-9.9,10.1-15.3c0-0.1,0.1-0.1,0.1-0.2s-0.1-0.1-0.1-0.2
-	c-3.5-5.3-9.7-14.6-10.1-15.3c-0.9-1.3-2-2.5-3.5-3.4c0,0-1.5-1-3.5-1.6C3.2,8.3,1.8,8,0,7.8v42.4c1.8-0.2,3.2-0.4,4-0.7
-	c2-0.6,3.5-1.6,3.5-1.6C9,46.9,10.2,45.8,11,44.5z M9.9,7.9c2,1.3,3.6,3.1,4.9,5.1c0.4,0.6,5.2,7.8,8.6,12.9
-	c3.4-5.1,8.2-12.3,8.6-12.9c1.2-2,2.9-3.8,4.9-5.1c0-0.1,2.1-1.3,4.6-2.1c0.2,0,0.4-0.1,0.5-0.1H5c0.2,0,0.4,0.1,0.5,0.2
-	C7.8,6.6,9.9,7.8,9.9,7.9z M173.4,0v46.9c-0.8-0.1-1.6-0.3-2.3-0.5v-4c-1.9,3.1-5.2,4.6-10,4.6c-8.9,0-12.4-5-12.4-15.5
-	S152.2,16,161,16c4.9,0,8.1,1.5,10,4.6V0.5C171.8,0.3,172.6,0.1,173.4,0z M171.1,31.5c0-8-1.7-13.4-10-13.4c-8.4,0-10,5.3-10,13.4
-	s1.7,13.4,10,13.4C169.4,44.9,171.1,39.6,171.1,31.5z M86.2,47l2.3-1.2V16.5h-2.3V47z M130.4,15.9h-1.3c-5.1,0-7.6,2.5-8.9,5.8
-	c-1.3-3.4-3.8-5.8-8.9-5.8H110c-8.8,0-10,7.4-10,13.8v15.6c0.7,0.6,1.5,1.1,2.4,1.5V30.5c0-7.3,1.1-12.4,8-12.4h0.6
-	c6.9,0,8,5.1,8,12.4v14.7l2.4-0.1V30.5c0-7.3,1.1-12.4,8-12.4h0.6c6.9,0,8,5.1,8,12.4V47c0.8-0.4,1.7-0.9,2.4-1.5V29.8
-	C140.4,23.3,139.1,15.9,130.4,15.9z M86.2,12.3h2.3V9.9h-2.3V12.3z"/>
-<path class="st1" d="M46.7,50.2v2.2h-4.8c-0.2,0-0.4-0.1-0.5-0.1c-2.5-0.8-4.5-2-4.6-2.1c-2-1.3-3.6-3.1-4.9-5.1
-	c-0.4-0.6-5.2-7.8-8.6-12.9c0.8-1.2,1.5-2.3,2.1-3.1c0,0.1,0.1,0.1,0.1,0.2c3.5,5.3,9.7,14.6,10.1,15.3c0.9,1.3,2,2.5,3.5,3.4
-	c0,0,1.5,1,3.5,1.6C43.5,49.7,44.9,50,46.7,50.2z M9.9,7.9c0-0.1-2.1-1.3-4.6-2.1C5.2,5.7,5,5.7,4.8,5.7H0v2.2C1.8,8,3.2,8.3,4,8.5
-	c2,0.6,3.5,1.6,3.5,1.6C9,11,10.1,12.2,11,13.5c0.4,0.7,6.6,9.9,10.1,15.3c0,0.1,0.1,0.1,0.1,0.2c0.6-0.8,1.3-1.9,2.1-3.1
-	c-3.4-5.1-8.2-12.3-8.6-12.9C13.5,11,11.9,9.2,9.9,7.9z"/>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 173.4 52.4" style="enable-background:new 0 0 173.4 52.4;" width="554.584222" height="167.590618" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#D8E448;}
+    .st1{opacity:0.28;fill:#D8E448;enable-background:new    ;}
+</style>
+<path class="st0" d="M42.8,8.5c0.8-0.3,2.2-0.5,4-0.7v44.6H4.9c0.2,0,0.4-0.1,0.5-0.1c2.5-0.8,4.5-2,4.6-2.1c2-1.3,3.6-3.1,4.9-5.1
+    c0.4-0.6,5.2-7.8,8.6-12.9c3.4,5.1,8.2,12.3,8.6,12.9c1.2,2,2.9,3.8,4.9,5.1c0,0.1,2.1,1.3,4.6,2.1c0.2,0,0.4,0.1,0.5,0.1h4.8v-2.2
+    c-1.8-0.2-3.2-0.4-4-0.7c-2-0.6-3.5-1.6-3.5-1.6c-1.5-0.9-2.6-2.1-3.5-3.4c-0.4-0.7-6.6-9.9-10.1-15.3c0,0-0.1-0.1-0.1-0.2
+    s0.1-0.1,0.1-0.2c3.5-5.3,9.7-14.6,10.1-15.3c0.9-1.3,2-2.5,3.5-3.4C39.2,10.2,40.7,9.2,42.8,8.5z M65.4,30.1
+    c-4.6-1.3-7.4-2.5-7.4-6.3c0-4.4,3.1-5.7,7-5.7c2.6,0,5,0.4,7.2,1.5l0.9-2C70.5,16.3,67.7,16,65,16c-4.7,0-9.2,2.2-9.2,7.7
+    s4,7.2,8.7,8.5c4.5,1.2,8.1,2.1,8.1,6.2c0,4.9-3.5,6.5-7.4,6.5c-2.6,0-5.2-0.5-7.4-1.5l-1,1.9c2.5,1.1,5.4,1.6,8.5,1.6
+    c5.1,0,9.6-2.3,9.6-8.5C74.9,32.8,70.6,31.5,65.4,30.1z M11,44.5c0.4-0.7,6.6-9.9,10.1-15.3c0-0.1,0.1-0.1,0.1-0.2s-0.1-0.1-0.1-0.2
+    c-3.5-5.3-9.7-14.6-10.1-15.3c-0.9-1.3-2-2.5-3.5-3.4c0,0-1.5-1-3.5-1.6C3.2,8.3,1.8,8,0,7.8v42.4c1.8-0.2,3.2-0.4,4-0.7
+    c2-0.6,3.5-1.6,3.5-1.6C9,46.9,10.2,45.8,11,44.5z M9.9,7.9c2,1.3,3.6,3.1,4.9,5.1c0.4,0.6,5.2,7.8,8.6,12.9
+    c3.4-5.1,8.2-12.3,8.6-12.9c1.2-2,2.9-3.8,4.9-5.1c0-0.1,2.1-1.3,4.6-2.1c0.2,0,0.4-0.1,0.5-0.1H5c0.2,0,0.4,0.1,0.5,0.2
+    C7.8,6.6,9.9,7.8,9.9,7.9z M173.4,0v46.9c-0.8-0.1-1.6-0.3-2.3-0.5v-4c-1.9,3.1-5.2,4.6-10,4.6c-8.9,0-12.4-5-12.4-15.5
+    S152.2,16,161,16c4.9,0,8.1,1.5,10,4.6V0.5C171.8,0.3,172.6,0.1,173.4,0z M171.1,31.5c0-8-1.7-13.4-10-13.4c-8.4,0-10,5.3-10,13.4
+    s1.7,13.4,10,13.4C169.4,44.9,171.1,39.6,171.1,31.5z M86.2,47l2.3-1.2V16.5h-2.3V47z M130.4,15.9h-1.3c-5.1,0-7.6,2.5-8.9,5.8
+    c-1.3-3.4-3.8-5.8-8.9-5.8H110c-8.8,0-10,7.4-10,13.8v15.6c0.7,0.6,1.5,1.1,2.4,1.5V30.5c0-7.3,1.1-12.4,8-12.4h0.6
+    c6.9,0,8,5.1,8,12.4v14.7l2.4-0.1V30.5c0-7.3,1.1-12.4,8-12.4h0.6c6.9,0,8,5.1,8,12.4V47c0.8-0.4,1.7-0.9,2.4-1.5V29.8
+    C140.4,23.3,139.1,15.9,130.4,15.9z M86.2,12.3h2.3V9.9h-2.3V12.3z"/>
+<path class="st1" d="M46.7,50.2v2.2h-4.8c-0.2,0-0.4-0.1-0.5-0.1c-2.5-0.8-4.5-2-4.6-2.1c-2-1.3-3.6-3.1-4.9-5.1
+    c-0.4-0.6-5.2-7.8-8.6-12.9c0.8-1.2,1.5-2.3,2.1-3.1c0,0.1,0.1,0.1,0.1,0.2c3.5,5.3,9.7,14.6,10.1,15.3c0.9,1.3,2,2.5,3.5,3.4
+    c0,0,1.5,1,3.5,1.6C43.5,49.7,44.9,50,46.7,50.2z M9.9,7.9c0-0.1-2.1-1.3-4.6-2.1C5.2,5.7,5,5.7,4.8,5.7H0v2.2C1.8,8,3.2,8.3,4,8.5
+    c2,0.6,3.5,1.6,3.5,1.6C9,11,10.1,12.2,11,13.5c0.4,0.7,6.6,9.9,10.1,15.3c0,0.1,0.1,0.1,0.1,0.2c0.6-0.8,1.3-1.9,2.1-3.1
+    c-3.4-5.1-8.2-12.3-8.6-12.9C13.5,11,11.9,9.2,9.9,7.9z"/>
+</svg>
diff --git a/docs/source/xtensor-blas-small.svg b/docs/source/xtensor-blas-small.svg
index b59fb3c20..bbd3defaf 100644
--- a/docs/source/xtensor-blas-small.svg
+++ b/docs/source/xtensor-blas-small.svg
@@ -1,53 +1,53 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 238.8 73.3" style="enable-background:new 0 0 238.8 73.3;" width="355.357143" height="109.77381" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-</style>
-<g>
-	<path class="st0" d="M194.8,63.9v-0.1c0.8-0.1,1.5-0.5,2-1.2s0.7-1.5,0.7-2.6c0-1.5-0.6-2.7-1.7-3.4s-2.9-1.1-5.4-1.1H185v17.5h6.6
-		c2,0,3.6-0.4,4.7-1.3c1.2-0.9,1.7-2.1,1.7-3.7c0-1.1-0.2-2-0.7-2.7C196.8,64.6,195.9,64.1,194.8,63.9z M188.7,58.6h2
-		c1.1,0,1.8,0.1,2.3,0.4c0.5,0.3,0.7,0.8,0.7,1.4c0,0.7-0.2,1.2-0.7,1.5c-0.5,0.3-1.2,0.5-2.2,0.5h-2.2V58.6z M193.4,69.4
-		c-0.5,0.4-1.2,0.6-2.3,0.6h-2.4v-4.6h2.3c2.1,0,3.1,0.7,3.1,2.2C194.1,68.4,193.9,69,193.4,69.4z M202.4,54.4h3.7v18.7h-3.7V54.4z
-		 M216.6,59.4c-1.9,0-3.6,0.4-5.1,1.2l1.2,2.5c1.4-0.6,2.7-1,3.8-1c1.4,0,2.1,0.7,2.1,2v0.6l-2.3,0.1c-2,0.1-3.5,0.4-4.5,1.1
-		c-1,0.7-1.5,1.7-1.5,3.1c0,1.4,0.4,2.4,1.1,3.1c0.7,0.7,1.8,1.1,3,1.1c1,0,1.9-0.2,2.5-0.5s1.3-0.8,1.9-1.6h0.1l0.7,1.8h2.6v-8.9
-		c0-1.6-0.5-2.8-1.4-3.6C219.8,59.8,218.5,59.4,216.6,59.4z M218.6,68c0,0.8-0.3,1.5-0.8,1.9c-0.5,0.5-1.2,0.7-2,0.7
-		c-1.2,0-1.8-0.5-1.8-1.5c0-0.7,0.3-1.3,0.8-1.6c0.5-0.4,1.3-0.5,2.4-0.6l1.4,0V68z M236.6,69.1c0,1.4-0.5,2.4-1.4,3.1
-		c-1,0.7-2.4,1.1-4.3,1.1c-1,0-1.8-0.1-2.5-0.2c-0.7-0.1-1.3-0.3-1.9-0.6v-3c0.7,0.3,1.4,0.6,2.3,0.8s1.6,0.3,2.3,0.3
-		c1.3,0,2-0.4,2-1.2c0-0.3-0.1-0.5-0.3-0.7c-0.2-0.2-0.5-0.4-0.9-0.6c-0.4-0.2-1-0.5-1.7-0.8c-1-0.4-1.8-0.8-2.3-1.2
-		c-0.5-0.4-0.8-0.8-1.1-1.3c-0.2-0.5-0.3-1.1-0.3-1.8c0-1.2,0.5-2.1,1.4-2.8c0.9-0.7,2.2-1,3.9-1c1.6,0,3.2,0.4,4.7,1.1l-1.1,2.6
-		c-0.7-0.3-1.3-0.5-1.9-0.7c-0.6-0.2-1.2-0.3-1.8-0.3c-1.1,0-1.6,0.3-1.6,0.9c0,0.3,0.2,0.6,0.5,0.9c0.3,0.2,1.1,0.6,2.3,1.1
-		c1,0.4,1.8,0.8,2.3,1.2c0.5,0.4,0.8,0.8,1.1,1.3C236.5,67.9,236.6,68.4,236.6,69.1z"/>
-	<g>
-		<path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 238.8 73.3" style="enable-background:new 0 0 238.8 73.3;" width="355.357143" height="109.77381" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+</style>
+<g>
+    <path class="st0" d="M194.8,63.9v-0.1c0.8-0.1,1.5-0.5,2-1.2s0.7-1.5,0.7-2.6c0-1.5-0.6-2.7-1.7-3.4s-2.9-1.1-5.4-1.1H185v17.5h6.6
+        c2,0,3.6-0.4,4.7-1.3c1.2-0.9,1.7-2.1,1.7-3.7c0-1.1-0.2-2-0.7-2.7C196.8,64.6,195.9,64.1,194.8,63.9z M188.7,58.6h2
+        c1.1,0,1.8,0.1,2.3,0.4c0.5,0.3,0.7,0.8,0.7,1.4c0,0.7-0.2,1.2-0.7,1.5c-0.5,0.3-1.2,0.5-2.2,0.5h-2.2V58.6z M193.4,69.4
+        c-0.5,0.4-1.2,0.6-2.3,0.6h-2.4v-4.6h2.3c2.1,0,3.1,0.7,3.1,2.2C194.1,68.4,193.9,69,193.4,69.4z M202.4,54.4h3.7v18.7h-3.7V54.4z
+         M216.6,59.4c-1.9,0-3.6,0.4-5.1,1.2l1.2,2.5c1.4-0.6,2.7-1,3.8-1c1.4,0,2.1,0.7,2.1,2v0.6l-2.3,0.1c-2,0.1-3.5,0.4-4.5,1.1
+        c-1,0.7-1.5,1.7-1.5,3.1c0,1.4,0.4,2.4,1.1,3.1c0.7,0.7,1.8,1.1,3,1.1c1,0,1.9-0.2,2.5-0.5s1.3-0.8,1.9-1.6h0.1l0.7,1.8h2.6v-8.9
+        c0-1.6-0.5-2.8-1.4-3.6C219.8,59.8,218.5,59.4,216.6,59.4z M218.6,68c0,0.8-0.3,1.5-0.8,1.9c-0.5,0.5-1.2,0.7-2,0.7
+        c-1.2,0-1.8-0.5-1.8-1.5c0-0.7,0.3-1.3,0.8-1.6c0.5-0.4,1.3-0.5,2.4-0.6l1.4,0V68z M236.6,69.1c0,1.4-0.5,2.4-1.4,3.1
+        c-1,0.7-2.4,1.1-4.3,1.1c-1,0-1.8-0.1-2.5-0.2c-0.7-0.1-1.3-0.3-1.9-0.6v-3c0.7,0.3,1.4,0.6,2.3,0.8s1.6,0.3,2.3,0.3
+        c1.3,0,2-0.4,2-1.2c0-0.3-0.1-0.5-0.3-0.7c-0.2-0.2-0.5-0.4-0.9-0.6c-0.4-0.2-1-0.5-1.7-0.8c-1-0.4-1.8-0.8-2.3-1.2
+        c-0.5-0.4-0.8-0.8-1.1-1.3c-0.2-0.5-0.3-1.1-0.3-1.8c0-1.2,0.5-2.1,1.4-2.8c0.9-0.7,2.2-1,3.9-1c1.6,0,3.2,0.4,4.7,1.1l-1.1,2.6
+        c-0.7-0.3-1.3-0.5-1.9-0.7c-0.6-0.2-1.2-0.3-1.8-0.3c-1.1,0-1.6,0.3-1.6,0.9c0,0.3,0.2,0.6,0.5,0.9c0.3,0.2,1.1,0.6,2.3,1.1
+        c1,0.4,1.8,0.8,2.3,1.2c0.5,0.4,0.8,0.8,1.1,1.3C236.5,67.9,236.6,68.4,236.6,69.1z"/>
+    <g>
+        <path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+</g>
+</svg>
diff --git a/docs/source/xtensor-blas.svg b/docs/source/xtensor-blas.svg
index 9ab9f9481..86714cb23 100644
--- a/docs/source/xtensor-blas.svg
+++ b/docs/source/xtensor-blas.svg
@@ -1,53 +1,53 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 238.8 73.3" style="enable-background:new 0 0 238.8 73.3;" width="710.714286" height="218.154762" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-</style>
-<g>
-	<path class="st0" d="M194.8,63.9v-0.1c0.8-0.1,1.5-0.5,2-1.2s0.7-1.5,0.7-2.6c0-1.5-0.6-2.7-1.7-3.4s-2.9-1.1-5.4-1.1H185v17.5h6.6
-		c2,0,3.6-0.4,4.7-1.3c1.2-0.9,1.7-2.1,1.7-3.7c0-1.1-0.2-2-0.7-2.7C196.8,64.6,195.9,64.1,194.8,63.9z M188.7,58.6h2
-		c1.1,0,1.8,0.1,2.3,0.4c0.5,0.3,0.7,0.8,0.7,1.4c0,0.7-0.2,1.2-0.7,1.5c-0.5,0.3-1.2,0.5-2.2,0.5h-2.2V58.6z M193.4,69.4
-		c-0.5,0.4-1.2,0.6-2.3,0.6h-2.4v-4.6h2.3c2.1,0,3.1,0.7,3.1,2.2C194.1,68.4,193.9,69,193.4,69.4z M202.4,54.4h3.7v18.7h-3.7V54.4z
-		 M216.6,59.4c-1.9,0-3.6,0.4-5.1,1.2l1.2,2.5c1.4-0.6,2.7-1,3.8-1c1.4,0,2.1,0.7,2.1,2v0.6l-2.3,0.1c-2,0.1-3.5,0.4-4.5,1.1
-		c-1,0.7-1.5,1.7-1.5,3.1c0,1.4,0.4,2.4,1.1,3.1c0.7,0.7,1.8,1.1,3,1.1c1,0,1.9-0.2,2.5-0.5s1.3-0.8,1.9-1.6h0.1l0.7,1.8h2.6v-8.9
-		c0-1.6-0.5-2.8-1.4-3.6C219.8,59.8,218.5,59.4,216.6,59.4z M218.6,68c0,0.8-0.3,1.5-0.8,1.9c-0.5,0.5-1.2,0.7-2,0.7
-		c-1.2,0-1.8-0.5-1.8-1.5c0-0.7,0.3-1.3,0.8-1.6c0.5-0.4,1.3-0.5,2.4-0.6l1.4,0V68z M236.6,69.1c0,1.4-0.5,2.4-1.4,3.1
-		c-1,0.7-2.4,1.1-4.3,1.1c-1,0-1.8-0.1-2.5-0.2c-0.7-0.1-1.3-0.3-1.9-0.6v-3c0.7,0.3,1.4,0.6,2.3,0.8s1.6,0.3,2.3,0.3
-		c1.3,0,2-0.4,2-1.2c0-0.3-0.1-0.5-0.3-0.7c-0.2-0.2-0.5-0.4-0.9-0.6c-0.4-0.2-1-0.5-1.7-0.8c-1-0.4-1.8-0.8-2.3-1.2
-		c-0.5-0.4-0.8-0.8-1.1-1.3c-0.2-0.5-0.3-1.1-0.3-1.8c0-1.2,0.5-2.1,1.4-2.8c0.9-0.7,2.2-1,3.9-1c1.6,0,3.2,0.4,4.7,1.1l-1.1,2.6
-		c-0.7-0.3-1.3-0.5-1.9-0.7c-0.6-0.2-1.2-0.3-1.8-0.3c-1.1,0-1.6,0.3-1.6,0.9c0,0.3,0.2,0.6,0.5,0.9c0.3,0.2,1.1,0.6,2.3,1.1
-		c1,0.4,1.8,0.8,2.3,1.2c0.5,0.4,0.8,0.8,1.1,1.3C236.5,67.9,236.6,68.4,236.6,69.1z"/>
-	<g>
-		<path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 238.8 73.3" style="enable-background:new 0 0 238.8 73.3;" width="710.714286" height="218.154762" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+</style>
+<g>
+    <path class="st0" d="M194.8,63.9v-0.1c0.8-0.1,1.5-0.5,2-1.2s0.7-1.5,0.7-2.6c0-1.5-0.6-2.7-1.7-3.4s-2.9-1.1-5.4-1.1H185v17.5h6.6
+        c2,0,3.6-0.4,4.7-1.3c1.2-0.9,1.7-2.1,1.7-3.7c0-1.1-0.2-2-0.7-2.7C196.8,64.6,195.9,64.1,194.8,63.9z M188.7,58.6h2
+        c1.1,0,1.8,0.1,2.3,0.4c0.5,0.3,0.7,0.8,0.7,1.4c0,0.7-0.2,1.2-0.7,1.5c-0.5,0.3-1.2,0.5-2.2,0.5h-2.2V58.6z M193.4,69.4
+        c-0.5,0.4-1.2,0.6-2.3,0.6h-2.4v-4.6h2.3c2.1,0,3.1,0.7,3.1,2.2C194.1,68.4,193.9,69,193.4,69.4z M202.4,54.4h3.7v18.7h-3.7V54.4z
+         M216.6,59.4c-1.9,0-3.6,0.4-5.1,1.2l1.2,2.5c1.4-0.6,2.7-1,3.8-1c1.4,0,2.1,0.7,2.1,2v0.6l-2.3,0.1c-2,0.1-3.5,0.4-4.5,1.1
+        c-1,0.7-1.5,1.7-1.5,3.1c0,1.4,0.4,2.4,1.1,3.1c0.7,0.7,1.8,1.1,3,1.1c1,0,1.9-0.2,2.5-0.5s1.3-0.8,1.9-1.6h0.1l0.7,1.8h2.6v-8.9
+        c0-1.6-0.5-2.8-1.4-3.6C219.8,59.8,218.5,59.4,216.6,59.4z M218.6,68c0,0.8-0.3,1.5-0.8,1.9c-0.5,0.5-1.2,0.7-2,0.7
+        c-1.2,0-1.8-0.5-1.8-1.5c0-0.7,0.3-1.3,0.8-1.6c0.5-0.4,1.3-0.5,2.4-0.6l1.4,0V68z M236.6,69.1c0,1.4-0.5,2.4-1.4,3.1
+        c-1,0.7-2.4,1.1-4.3,1.1c-1,0-1.8-0.1-2.5-0.2c-0.7-0.1-1.3-0.3-1.9-0.6v-3c0.7,0.3,1.4,0.6,2.3,0.8s1.6,0.3,2.3,0.3
+        c1.3,0,2-0.4,2-1.2c0-0.3-0.1-0.5-0.3-0.7c-0.2-0.2-0.5-0.4-0.9-0.6c-0.4-0.2-1-0.5-1.7-0.8c-1-0.4-1.8-0.8-2.3-1.2
+        c-0.5-0.4-0.8-0.8-1.1-1.3c-0.2-0.5-0.3-1.1-0.3-1.8c0-1.2,0.5-2.1,1.4-2.8c0.9-0.7,2.2-1,3.9-1c1.6,0,3.2,0.4,4.7,1.1l-1.1,2.6
+        c-0.7-0.3-1.3-0.5-1.9-0.7c-0.6-0.2-1.2-0.3-1.8-0.3c-1.1,0-1.6,0.3-1.6,0.9c0,0.3,0.2,0.6,0.5,0.9c0.3,0.2,1.1,0.6,2.3,1.1
+        c1,0.4,1.8,0.8,2.3,1.2c0.5,0.4,0.8,0.8,1.1,1.3C236.5,67.9,236.6,68.4,236.6,69.1z"/>
+    <g>
+        <path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+</g>
+</svg>
diff --git a/docs/source/xtensor-cookiecutter.svg b/docs/source/xtensor-cookiecutter.svg
index 118d91308..961833a5b 100644
--- a/docs/source/xtensor-cookiecutter.svg
+++ b/docs/source/xtensor-cookiecutter.svg
@@ -3767,4 +3767,4 @@
                d="m 179.748,307.774 c -1.662,-0.26 -2.799,-2.016 -2.642,-3.604 l 0,0 c 0.209,-2.117 2.693,-3.665 4.506,-2.954 l 0,0 c 1.237,0.484 1.928,1.928 1.858,3.195 l 0,0 c -0.092,1.695 -1.566,3.395 -3.308,3.395 l 0,0 c -0.136,0 -0.275,-0.01 -0.414,-0.032"
                style="fill:url(#radialGradient3560);stroke:none"
                id="path3570"
-               inkscape:connector-curvature="0" /></g></g></g></g></g></svg>
\ No newline at end of file
+               inkscape:connector-curvature="0" /></g></g></g></g></g></svg>
diff --git a/docs/source/xtensor-fftw.svg b/docs/source/xtensor-fftw.svg
index 681d8a053..d290fdc94 100644
--- a/docs/source/xtensor-fftw.svg
+++ b/docs/source/xtensor-fftw.svg
@@ -44,9 +44,9 @@
      inkscape:current-layer="text4147" /><style
      type="text/css"
      id="style3">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
 </style><g
      style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#666666;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
      id="text4147"><path
diff --git a/docs/source/xtensor-io-small.svg b/docs/source/xtensor-io-small.svg
index f5d61c9e7..1b358ed3b 100644
--- a/docs/source/xtensor-io-small.svg
+++ b/docs/source/xtensor-io-small.svg
@@ -45,9 +45,9 @@
      inkscape:current-layer="text4147" /><style
      type="text/css"
      id="style3">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
 </style><g
      style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#666666;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
      id="text4147"><g
diff --git a/docs/source/xtensor-io.svg b/docs/source/xtensor-io.svg
index 61bf6e9f5..9d5c110fd 100644
--- a/docs/source/xtensor-io.svg
+++ b/docs/source/xtensor-io.svg
@@ -45,9 +45,9 @@
      inkscape:current-layer="text4147" /><style
      type="text/css"
      id="style3">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
 </style><g
      style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#666666;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
      id="text4147"><g
@@ -69,4 +69,4 @@
          id="path11" /><path
          class="st2"
          d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3    c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7    c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7    c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9    c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"
-         id="path13" /></g></g></svg>
\ No newline at end of file
+         id="path13" /></g></g></svg>
diff --git a/docs/source/xtensor-julia-small.svg b/docs/source/xtensor-julia-small.svg
index 4b31c814b..3fd141998 100644
--- a/docs/source/xtensor-julia-small.svg
+++ b/docs/source/xtensor-julia-small.svg
@@ -1,61 +1,61 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 238.8 93.5" style="enable-background:new 0 0 238.8 93.5;" width="355.36" height="139.137" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#7FD787;}
-	.st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-	.st2{fill:#666666;}
-	.st3{fill:#B9BABA;}
-</style>
-<g>
-	<g>
-		<path class="st0" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2H68v8.2h-8l-1.2,2.4H68c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			v-48c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st1" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			C38,41,31.3,31.1,27.5,25.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3C21.5,16.4,16.4,8.6,15.9,8
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-	<path class="st2" d="M187.6,86L187.6,86c0,1.6-0.2,2.9-0.5,3.9c-0.4,1-0.9,1.7-1.5,2.3c-0.7,0.5-1.5,0.9-2.4,1.1
-		c-0.9,0.2-2,0.3-3.1,0.3c-1.5,0-2.7-0.2-3.5-0.7c-0.8-0.5-1.2-1.1-1.2-1.7c0-0.6,0.2-1,0.7-1.4c0.5-0.4,1.1-0.6,1.8-0.6
-		c0.6,0,1,0.2,1.4,0.5c0.3,0.3,0.6,0.6,0.9,0.9c0.3,0.3,0.5,0.6,0.6,0.7c0.2,0.1,0.3,0.2,0.5,0.2c0.3,0,0.5-0.2,0.7-0.5
-		c0.2-0.4,0.2-1.1,0.2-2.1V68.9l5.5-1.5V86z M200.8,80.9c-0.4,0.6-0.9,1.2-1.5,1.6c-0.6,0.4-1,0.6-1.5,0.6c-0.4,0-0.7-0.1-1-0.2
-		s-0.6-0.3-0.8-0.5c-0.2-0.2-0.4-0.5-0.6-0.8c-0.1-0.3-0.2-0.6-0.2-1V67.9h-5.5v12.7c0,0.8,0.2,1.5,0.5,2.2c0.3,0.7,0.8,1.3,1.4,1.8
-		c0.6,0.5,1.2,0.9,2,1.2c0.8,0.3,1.6,0.4,2.5,0.4c0.8,0,1.6-0.2,2.4-0.6s1.6-0.9,2.3-1.5V86h5.5v-18h-5.5V80.9z M208.5,86l5.4,0
-		V59.2l-5.4,1.5V86z M216.1,86h5.5V67.4l-5.5,1.5V86z M238.6,72.5V86l-5.5,0v-1.4c-0.3,0.3-0.6,0.5-0.9,0.7c-0.3,0.2-0.6,0.4-1,0.6
-		c-0.4,0.2-0.8,0.3-1.2,0.4c-0.4,0.1-1,0.1-1.6,0.1c-0.8,0-1.6-0.1-2.2-0.4c-0.7-0.2-1.2-0.6-1.7-1c-0.5-0.4-0.8-0.9-1.1-1.5
-		c-0.2-0.6-0.4-1.2-0.4-1.9c0-0.7,0.1-1.3,0.4-1.9c0.3-0.6,0.6-1.1,1.1-1.5c0.5-0.4,1-0.8,1.6-1.2c0.6-0.4,1.3-0.7,2-1
-		s1.4-0.6,2.2-0.8c0.8-0.2,1.5-0.5,2.2-0.7l0.6-0.1v-1.8c0-1.2-0.2-2-0.7-2.4c-0.4-0.5-1-0.7-1.8-0.7c-0.9,0-1.5,0.2-1.8,0.6
-		c-0.3,0.4-0.5,0.9-0.5,1.5c0,0.3,0,0.7-0.1,1c-0.1,0.3-0.2,0.6-0.4,0.8c-0.2,0.2-0.4,0.4-0.8,0.6c-0.3,0.1-0.7,0.2-1.2,0.2
-		c-0.8,0-1.4-0.2-1.9-0.7c-0.5-0.4-0.7-1-0.7-1.7c0-0.6,0.2-1.2,0.6-1.7c0.4-0.5,1-1,1.7-1.4c0.7-0.4,1.6-0.7,2.5-0.9
-		c0.9-0.2,1.9-0.3,3-0.3c1.3,0,2.4,0.1,3.3,0.3c0.9,0.2,1.7,0.6,2.3,1c0.6,0.4,1.1,1,1.3,1.6C238.5,71,238.6,71.7,238.6,72.5z
-		 M233.1,76.7c-0.5,0.2-1.1,0.5-1.6,0.8c-0.5,0.3-1,0.6-1.5,1c-0.4,0.4-0.8,0.7-1.1,1.1c-0.3,0.4-0.4,0.8-0.4,1.2c0,0.3,0,0.7,0.1,1
-		c0.1,0.3,0.2,0.6,0.4,0.8c0.2,0.2,0.3,0.4,0.5,0.5c0.2,0.1,0.4,0.2,0.6,0.2c0.4,0,0.9-0.1,1.4-0.4c0.5-0.3,1-0.6,1.5-1V76.7
-		L233.1,76.7z"/>
-	<path class="st3" d="M222.9,62.7c0,2-1.6,3.7-3.7,3.7c-2,0-3.7-1.6-3.7-3.7c0-2,1.6-3.7,3.7-3.7C221.2,59,222.9,60.6,222.9,62.7z
-		 M184.8,59c-2,0-3.7,1.6-3.7,3.7c0,2,1.6,3.7,3.7,3.7s3.7-1.6,3.7-3.7C188.5,60.6,186.8,59,184.8,59z M227.3,55
-		c0-2-1.6-3.7-3.7-3.7c-2,0-3.7,1.6-3.7,3.7s1.6,3.7,3.7,3.7C225.7,58.7,227.3,57,227.3,55z M228.1,59c-2,0-3.7,1.6-3.7,3.7
-		c0,2,1.6,3.7,3.7,3.7c2,0,3.7-1.6,3.7-3.7C231.8,60.6,230.1,59,228.1,59z"/>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 238.8 93.5" style="enable-background:new 0 0 238.8 93.5;" width="355.36" height="139.137" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#7FD787;}
+    .st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+    .st2{fill:#666666;}
+    .st3{fill:#B9BABA;}
+</style>
+<g>
+    <g>
+        <path class="st0" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2H68v8.2h-8l-1.2,2.4H68c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            v-48c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st1" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            C38,41,31.3,31.1,27.5,25.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3C21.5,16.4,16.4,8.6,15.9,8
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+    <path class="st2" d="M187.6,86L187.6,86c0,1.6-0.2,2.9-0.5,3.9c-0.4,1-0.9,1.7-1.5,2.3c-0.7,0.5-1.5,0.9-2.4,1.1
+        c-0.9,0.2-2,0.3-3.1,0.3c-1.5,0-2.7-0.2-3.5-0.7c-0.8-0.5-1.2-1.1-1.2-1.7c0-0.6,0.2-1,0.7-1.4c0.5-0.4,1.1-0.6,1.8-0.6
+        c0.6,0,1,0.2,1.4,0.5c0.3,0.3,0.6,0.6,0.9,0.9c0.3,0.3,0.5,0.6,0.6,0.7c0.2,0.1,0.3,0.2,0.5,0.2c0.3,0,0.5-0.2,0.7-0.5
+        c0.2-0.4,0.2-1.1,0.2-2.1V68.9l5.5-1.5V86z M200.8,80.9c-0.4,0.6-0.9,1.2-1.5,1.6c-0.6,0.4-1,0.6-1.5,0.6c-0.4,0-0.7-0.1-1-0.2
+        s-0.6-0.3-0.8-0.5c-0.2-0.2-0.4-0.5-0.6-0.8c-0.1-0.3-0.2-0.6-0.2-1V67.9h-5.5v12.7c0,0.8,0.2,1.5,0.5,2.2c0.3,0.7,0.8,1.3,1.4,1.8
+        c0.6,0.5,1.2,0.9,2,1.2c0.8,0.3,1.6,0.4,2.5,0.4c0.8,0,1.6-0.2,2.4-0.6s1.6-0.9,2.3-1.5V86h5.5v-18h-5.5V80.9z M208.5,86l5.4,0
+        V59.2l-5.4,1.5V86z M216.1,86h5.5V67.4l-5.5,1.5V86z M238.6,72.5V86l-5.5,0v-1.4c-0.3,0.3-0.6,0.5-0.9,0.7c-0.3,0.2-0.6,0.4-1,0.6
+        c-0.4,0.2-0.8,0.3-1.2,0.4c-0.4,0.1-1,0.1-1.6,0.1c-0.8,0-1.6-0.1-2.2-0.4c-0.7-0.2-1.2-0.6-1.7-1c-0.5-0.4-0.8-0.9-1.1-1.5
+        c-0.2-0.6-0.4-1.2-0.4-1.9c0-0.7,0.1-1.3,0.4-1.9c0.3-0.6,0.6-1.1,1.1-1.5c0.5-0.4,1-0.8,1.6-1.2c0.6-0.4,1.3-0.7,2-1
+        s1.4-0.6,2.2-0.8c0.8-0.2,1.5-0.5,2.2-0.7l0.6-0.1v-1.8c0-1.2-0.2-2-0.7-2.4c-0.4-0.5-1-0.7-1.8-0.7c-0.9,0-1.5,0.2-1.8,0.6
+        c-0.3,0.4-0.5,0.9-0.5,1.5c0,0.3,0,0.7-0.1,1c-0.1,0.3-0.2,0.6-0.4,0.8c-0.2,0.2-0.4,0.4-0.8,0.6c-0.3,0.1-0.7,0.2-1.2,0.2
+        c-0.8,0-1.4-0.2-1.9-0.7c-0.5-0.4-0.7-1-0.7-1.7c0-0.6,0.2-1.2,0.6-1.7c0.4-0.5,1-1,1.7-1.4c0.7-0.4,1.6-0.7,2.5-0.9
+        c0.9-0.2,1.9-0.3,3-0.3c1.3,0,2.4,0.1,3.3,0.3c0.9,0.2,1.7,0.6,2.3,1c0.6,0.4,1.1,1,1.3,1.6C238.5,71,238.6,71.7,238.6,72.5z
+         M233.1,76.7c-0.5,0.2-1.1,0.5-1.6,0.8c-0.5,0.3-1,0.6-1.5,1c-0.4,0.4-0.8,0.7-1.1,1.1c-0.3,0.4-0.4,0.8-0.4,1.2c0,0.3,0,0.7,0.1,1
+        c0.1,0.3,0.2,0.6,0.4,0.8c0.2,0.2,0.3,0.4,0.5,0.5c0.2,0.1,0.4,0.2,0.6,0.2c0.4,0,0.9-0.1,1.4-0.4c0.5-0.3,1-0.6,1.5-1V76.7
+        L233.1,76.7z"/>
+    <path class="st3" d="M222.9,62.7c0,2-1.6,3.7-3.7,3.7c-2,0-3.7-1.6-3.7-3.7c0-2,1.6-3.7,3.7-3.7C221.2,59,222.9,60.6,222.9,62.7z
+         M184.8,59c-2,0-3.7,1.6-3.7,3.7c0,2,1.6,3.7,3.7,3.7s3.7-1.6,3.7-3.7C188.5,60.6,186.8,59,184.8,59z M227.3,55
+        c0-2-1.6-3.7-3.7-3.7c-2,0-3.7,1.6-3.7,3.7s1.6,3.7,3.7,3.7C225.7,58.7,227.3,57,227.3,55z M228.1,59c-2,0-3.7,1.6-3.7,3.7
+        c0,2,1.6,3.7,3.7,3.7c2,0,3.7-1.6,3.7-3.7C231.8,60.6,230.1,59,228.1,59z"/>
+</g>
+</svg>
diff --git a/docs/source/xtensor-julia.svg b/docs/source/xtensor-julia.svg
index cba4c7fb1..9f80f2ff1 100644
--- a/docs/source/xtensor-julia.svg
+++ b/docs/source/xtensor-julia.svg
@@ -1,61 +1,61 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 238.8 93.5" style="enable-background:new 0 0 238.8 93.5;" width="710.714286" height="278.27381" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#7FD787;}
-	.st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-	.st2{fill:#666666;}
-	.st3{fill:#B9BABA;}
-</style>
-<g>
-	<g>
-		<path class="st0" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2H68v8.2h-8l-1.2,2.4H68c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			v-48c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st1" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			C38,41,31.3,31.1,27.5,25.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3C21.5,16.4,16.4,8.6,15.9,8
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-	<path class="st2" d="M187.6,86L187.6,86c0,1.6-0.2,2.9-0.5,3.9c-0.4,1-0.9,1.7-1.5,2.3c-0.7,0.5-1.5,0.9-2.4,1.1
-		c-0.9,0.2-2,0.3-3.1,0.3c-1.5,0-2.7-0.2-3.5-0.7c-0.8-0.5-1.2-1.1-1.2-1.7c0-0.6,0.2-1,0.7-1.4c0.5-0.4,1.1-0.6,1.8-0.6
-		c0.6,0,1,0.2,1.4,0.5c0.3,0.3,0.6,0.6,0.9,0.9c0.3,0.3,0.5,0.6,0.6,0.7c0.2,0.1,0.3,0.2,0.5,0.2c0.3,0,0.5-0.2,0.7-0.5
-		c0.2-0.4,0.2-1.1,0.2-2.1V68.9l5.5-1.5V86z M200.8,80.9c-0.4,0.6-0.9,1.2-1.5,1.6c-0.6,0.4-1,0.6-1.5,0.6c-0.4,0-0.7-0.1-1-0.2
-		s-0.6-0.3-0.8-0.5c-0.2-0.2-0.4-0.5-0.6-0.8c-0.1-0.3-0.2-0.6-0.2-1V67.9h-5.5v12.7c0,0.8,0.2,1.5,0.5,2.2c0.3,0.7,0.8,1.3,1.4,1.8
-		c0.6,0.5,1.2,0.9,2,1.2c0.8,0.3,1.6,0.4,2.5,0.4c0.8,0,1.6-0.2,2.4-0.6s1.6-0.9,2.3-1.5V86h5.5v-18h-5.5V80.9z M208.5,86l5.4,0
-		V59.2l-5.4,1.5V86z M216.1,86h5.5V67.4l-5.5,1.5V86z M238.6,72.5V86l-5.5,0v-1.4c-0.3,0.3-0.6,0.5-0.9,0.7c-0.3,0.2-0.6,0.4-1,0.6
-		c-0.4,0.2-0.8,0.3-1.2,0.4c-0.4,0.1-1,0.1-1.6,0.1c-0.8,0-1.6-0.1-2.2-0.4c-0.7-0.2-1.2-0.6-1.7-1c-0.5-0.4-0.8-0.9-1.1-1.5
-		c-0.2-0.6-0.4-1.2-0.4-1.9c0-0.7,0.1-1.3,0.4-1.9c0.3-0.6,0.6-1.1,1.1-1.5c0.5-0.4,1-0.8,1.6-1.2c0.6-0.4,1.3-0.7,2-1
-		s1.4-0.6,2.2-0.8c0.8-0.2,1.5-0.5,2.2-0.7l0.6-0.1v-1.8c0-1.2-0.2-2-0.7-2.4c-0.4-0.5-1-0.7-1.8-0.7c-0.9,0-1.5,0.2-1.8,0.6
-		c-0.3,0.4-0.5,0.9-0.5,1.5c0,0.3,0,0.7-0.1,1c-0.1,0.3-0.2,0.6-0.4,0.8c-0.2,0.2-0.4,0.4-0.8,0.6c-0.3,0.1-0.7,0.2-1.2,0.2
-		c-0.8,0-1.4-0.2-1.9-0.7c-0.5-0.4-0.7-1-0.7-1.7c0-0.6,0.2-1.2,0.6-1.7c0.4-0.5,1-1,1.7-1.4c0.7-0.4,1.6-0.7,2.5-0.9
-		c0.9-0.2,1.9-0.3,3-0.3c1.3,0,2.4,0.1,3.3,0.3c0.9,0.2,1.7,0.6,2.3,1c0.6,0.4,1.1,1,1.3,1.6C238.5,71,238.6,71.7,238.6,72.5z
-		 M233.1,76.7c-0.5,0.2-1.1,0.5-1.6,0.8c-0.5,0.3-1,0.6-1.5,1c-0.4,0.4-0.8,0.7-1.1,1.1c-0.3,0.4-0.4,0.8-0.4,1.2c0,0.3,0,0.7,0.1,1
-		c0.1,0.3,0.2,0.6,0.4,0.8c0.2,0.2,0.3,0.4,0.5,0.5c0.2,0.1,0.4,0.2,0.6,0.2c0.4,0,0.9-0.1,1.4-0.4c0.5-0.3,1-0.6,1.5-1V76.7
-		L233.1,76.7z"/>
-	<path class="st3" d="M222.9,62.7c0,2-1.6,3.7-3.7,3.7c-2,0-3.7-1.6-3.7-3.7c0-2,1.6-3.7,3.7-3.7C221.2,59,222.9,60.6,222.9,62.7z
-		 M184.8,59c-2,0-3.7,1.6-3.7,3.7c0,2,1.6,3.7,3.7,3.7s3.7-1.6,3.7-3.7C188.5,60.6,186.8,59,184.8,59z M227.3,55
-		c0-2-1.6-3.7-3.7-3.7c-2,0-3.7,1.6-3.7,3.7s1.6,3.7,3.7,3.7C225.7,58.7,227.3,57,227.3,55z M228.1,59c-2,0-3.7,1.6-3.7,3.7
-		c0,2,1.6,3.7,3.7,3.7c2,0,3.7-1.6,3.7-3.7C231.8,60.6,230.1,59,228.1,59z"/>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 238.8 93.5" style="enable-background:new 0 0 238.8 93.5;" width="710.714286" height="278.27381" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#7FD787;}
+    .st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+    .st2{fill:#666666;}
+    .st3{fill:#B9BABA;}
+</style>
+<g>
+    <g>
+        <path class="st0" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2H68v8.2h-8l-1.2,2.4H68c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            v-48c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st1" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            C38,41,31.3,31.1,27.5,25.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3C21.5,16.4,16.4,8.6,15.9,8
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+    <path class="st2" d="M187.6,86L187.6,86c0,1.6-0.2,2.9-0.5,3.9c-0.4,1-0.9,1.7-1.5,2.3c-0.7,0.5-1.5,0.9-2.4,1.1
+        c-0.9,0.2-2,0.3-3.1,0.3c-1.5,0-2.7-0.2-3.5-0.7c-0.8-0.5-1.2-1.1-1.2-1.7c0-0.6,0.2-1,0.7-1.4c0.5-0.4,1.1-0.6,1.8-0.6
+        c0.6,0,1,0.2,1.4,0.5c0.3,0.3,0.6,0.6,0.9,0.9c0.3,0.3,0.5,0.6,0.6,0.7c0.2,0.1,0.3,0.2,0.5,0.2c0.3,0,0.5-0.2,0.7-0.5
+        c0.2-0.4,0.2-1.1,0.2-2.1V68.9l5.5-1.5V86z M200.8,80.9c-0.4,0.6-0.9,1.2-1.5,1.6c-0.6,0.4-1,0.6-1.5,0.6c-0.4,0-0.7-0.1-1-0.2
+        s-0.6-0.3-0.8-0.5c-0.2-0.2-0.4-0.5-0.6-0.8c-0.1-0.3-0.2-0.6-0.2-1V67.9h-5.5v12.7c0,0.8,0.2,1.5,0.5,2.2c0.3,0.7,0.8,1.3,1.4,1.8
+        c0.6,0.5,1.2,0.9,2,1.2c0.8,0.3,1.6,0.4,2.5,0.4c0.8,0,1.6-0.2,2.4-0.6s1.6-0.9,2.3-1.5V86h5.5v-18h-5.5V80.9z M208.5,86l5.4,0
+        V59.2l-5.4,1.5V86z M216.1,86h5.5V67.4l-5.5,1.5V86z M238.6,72.5V86l-5.5,0v-1.4c-0.3,0.3-0.6,0.5-0.9,0.7c-0.3,0.2-0.6,0.4-1,0.6
+        c-0.4,0.2-0.8,0.3-1.2,0.4c-0.4,0.1-1,0.1-1.6,0.1c-0.8,0-1.6-0.1-2.2-0.4c-0.7-0.2-1.2-0.6-1.7-1c-0.5-0.4-0.8-0.9-1.1-1.5
+        c-0.2-0.6-0.4-1.2-0.4-1.9c0-0.7,0.1-1.3,0.4-1.9c0.3-0.6,0.6-1.1,1.1-1.5c0.5-0.4,1-0.8,1.6-1.2c0.6-0.4,1.3-0.7,2-1
+        s1.4-0.6,2.2-0.8c0.8-0.2,1.5-0.5,2.2-0.7l0.6-0.1v-1.8c0-1.2-0.2-2-0.7-2.4c-0.4-0.5-1-0.7-1.8-0.7c-0.9,0-1.5,0.2-1.8,0.6
+        c-0.3,0.4-0.5,0.9-0.5,1.5c0,0.3,0,0.7-0.1,1c-0.1,0.3-0.2,0.6-0.4,0.8c-0.2,0.2-0.4,0.4-0.8,0.6c-0.3,0.1-0.7,0.2-1.2,0.2
+        c-0.8,0-1.4-0.2-1.9-0.7c-0.5-0.4-0.7-1-0.7-1.7c0-0.6,0.2-1.2,0.6-1.7c0.4-0.5,1-1,1.7-1.4c0.7-0.4,1.6-0.7,2.5-0.9
+        c0.9-0.2,1.9-0.3,3-0.3c1.3,0,2.4,0.1,3.3,0.3c0.9,0.2,1.7,0.6,2.3,1c0.6,0.4,1.1,1,1.3,1.6C238.5,71,238.6,71.7,238.6,72.5z
+         M233.1,76.7c-0.5,0.2-1.1,0.5-1.6,0.8c-0.5,0.3-1,0.6-1.5,1c-0.4,0.4-0.8,0.7-1.1,1.1c-0.3,0.4-0.4,0.8-0.4,1.2c0,0.3,0,0.7,0.1,1
+        c0.1,0.3,0.2,0.6,0.4,0.8c0.2,0.2,0.3,0.4,0.5,0.5c0.2,0.1,0.4,0.2,0.6,0.2c0.4,0,0.9-0.1,1.4-0.4c0.5-0.3,1-0.6,1.5-1V76.7
+        L233.1,76.7z"/>
+    <path class="st3" d="M222.9,62.7c0,2-1.6,3.7-3.7,3.7c-2,0-3.7-1.6-3.7-3.7c0-2,1.6-3.7,3.7-3.7C221.2,59,222.9,60.6,222.9,62.7z
+         M184.8,59c-2,0-3.7,1.6-3.7,3.7c0,2,1.6,3.7,3.7,3.7s3.7-1.6,3.7-3.7C188.5,60.6,186.8,59,184.8,59z M227.3,55
+        c0-2-1.6-3.7-3.7-3.7c-2,0-3.7,1.6-3.7,3.7s1.6,3.7,3.7,3.7C225.7,58.7,227.3,57,227.3,55z M228.1,59c-2,0-3.7,1.6-3.7,3.7
+        c0,2,1.6,3.7,3.7,3.7c2,0,3.7-1.6,3.7-3.7C231.8,60.6,230.1,59,228.1,59z"/>
+</g>
+</svg>
diff --git a/docs/source/xtensor-python-small.svg b/docs/source/xtensor-python-small.svg
index 08f6215d0..ad71c9ab9 100644
--- a/docs/source/xtensor-python-small.svg
+++ b/docs/source/xtensor-python-small.svg
@@ -1,60 +1,60 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 238.8 81.3" width="355.36" height="120.982" style="enable-background:new 0 0 238.8 81.3;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-</style>
-<g>
-	<path class="st0" d="M177.8,62.3L177.8,62.3c-1.7,0-3.2,0.3-4.3,1c-0.5,0.3-0.9,0.6-1.3,1v15.7l2,0.7v-7.1c1.2,0.8,2.4,1.1,3.6,1.1
-		c1.5,0,2.7-0.7,3.6-1.9c0.8-1.1,1.2-2.5,1.2-4.1h0c0-1.9-0.4-3.4-1.2-4.6C180.6,62.9,179.4,62.3,177.8,62.3z M177.4,73.4
-		c-0.9,0.1-2-0.3-3.2-1v-7.8c0.2-0.2,0.6-0.4,1.1-0.6c0.7-0.3,1.4-0.4,2.2-0.4c1.9,0.1,2.8,1.8,2.8,5
-		C180.3,71.7,179.3,73.3,177.4,73.4z M192.8,62.6h2v10.8c0,2.2-0.2,3.8-0.7,4.6c-0.4,0.9-1.3,1.5-2.6,2c-1,0.4-2.1,0.6-3.3,0.7
-		l-0.3-1.3c1.2-0.2,2-0.3,2.5-0.5c1-0.3,1.6-0.8,2-1.5c0.3-0.5,0.4-1.6,0.4-3.1v-0.5c-1.4,0.6-2.8,0.9-4.3,0.9c-1,0-1.8-0.3-2.6-0.9
-		c-0.8-0.7-1.3-1.5-1.3-2.6V63l2-0.7v8.3c0,0.9,0.3,1.6,0.9,2.1c0.6,0.5,1.3,0.7,2.2,0.7c0.9,0,1.9-0.4,2.9-1.1V62.6z M200.3,62.6
-		h2.2v1.3h-2.2v7.8c0,0.7,0.2,1.3,0.6,1.6c0.3,0.3,0.9,0.4,1.6,0.4v1c-0.2,0-0.5,0-0.7,0c-1.1,0-2-0.3-2.6-0.8
-		c-0.6-0.5-0.9-1.3-0.9-2.2v-7.8h-1.4v-1.3h1.4v-3.3l2-0.7V62.6z M213.6,63.6c0.7,0.7,1,1.6,1,2.6v8.3h-2v-7.7c0-0.8-0.2-1.5-0.5-2
-		c-0.4-0.6-1-1-1.8-1c-0.9,0-2.1,0.5-3.4,1.4v9.2h-2V56.2l2-0.6v8.4c1.3-0.9,2.7-1.4,4.2-1.4C212.1,62.5,212.9,62.9,213.6,63.6z
-		 M221.9,62.3c-1.7,0-3,0.6-4,1.8c-1,1.1-1.4,2.6-1.4,4.2c0,1.8,0.4,3.3,1.3,4.4c1,1.3,2.3,2,4.1,2c1.8,0,3.1-0.7,4.1-2
-		c0.9-1.2,1.4-2.7,1.4-4.4c0-1.7-0.5-3.1-1.4-4.2C224.9,62.9,223.5,62.3,221.9,62.3z M221.9,73.5c-1.2,0-2-0.6-2.6-1.7
-		c-0.5-0.9-0.7-2.1-0.7-3.4c0-3,1.1-4.6,3.3-4.7c1.2,0.1,2.1,0.6,2.6,1.6c0.5,0.8,0.7,1.8,0.7,3.1C225.2,71.8,224.1,73.5,221.9,73.5
-		z M238.8,65.4v9.1h-2v-8.1c0-0.9-0.3-1.6-0.8-2.1c-0.5-0.5-1.3-0.7-2.1-0.7c-0.9,0-1.8,0.3-2.7,0.9v10h-2V64.3
-		c1.1-0.8,2.2-1.4,3.2-1.6c0.9-0.2,1.7-0.4,2.4-0.4c0.5,0,0.9,0,1.3,0.1c0.8,0.2,1.4,0.5,1.9,1C238.5,64,238.8,64.6,238.8,65.4z
-		 M149.7,68.3h6c1.7,0,3-1.4,3-3v-5.7c0-1.6-1.4-2.8-3-3.1c-1-0.2-2.1-0.2-3.1-0.2s-2,0.1-2.9,0.2c-2.5,0.4-3,1.4-3,3.1v2.3h6v0.8
-		h-6h-2.2c-1.7,0-3.3,1-3.7,3c-0.6,2.3-0.6,3.7,0,6.1c0.4,1.8,1.4,3,3.2,3h2.1v-2.7C145.9,70.1,147.7,68.3,149.7,68.3z M149.3,60.4
-		c-0.6,0-1.1-0.5-1.1-1.1c0-0.6,0.5-1.1,1.1-1.1c0.6,0,1.1,0.5,1.1,1.1C150.4,59.8,149.9,60.4,149.3,60.4z M161.7,62.6h-2.2v2.7
-		c0,2.1-1.7,3.8-3.7,3.8h-6c-1.6,0-3,1.4-3,3v5.7c0,1.6,1.4,2.6,3,3c1.9,0.6,3.7,0.7,6,0c1.5-0.4,3-1.3,3-3v-2.3h-6v-0.8h6h3
-		c1.7,0,2.4-1.2,3-3c0.6-1.9,0.6-3.7,0-6.1C164.2,63.9,163.4,62.6,161.7,62.6z M156,77.1c0.6,0,1.1,0.5,1.1,1.1
-		c0,0.6-0.5,1.1-1.1,1.1c-0.6,0-1.1-0.5-1.1-1.1C154.9,77.6,155.4,77.1,156,77.1z"/>
-	<g>
-		<path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 238.8 81.3" width="355.36" height="120.982" style="enable-background:new 0 0 238.8 81.3;" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+</style>
+<g>
+    <path class="st0" d="M177.8,62.3L177.8,62.3c-1.7,0-3.2,0.3-4.3,1c-0.5,0.3-0.9,0.6-1.3,1v15.7l2,0.7v-7.1c1.2,0.8,2.4,1.1,3.6,1.1
+        c1.5,0,2.7-0.7,3.6-1.9c0.8-1.1,1.2-2.5,1.2-4.1h0c0-1.9-0.4-3.4-1.2-4.6C180.6,62.9,179.4,62.3,177.8,62.3z M177.4,73.4
+        c-0.9,0.1-2-0.3-3.2-1v-7.8c0.2-0.2,0.6-0.4,1.1-0.6c0.7-0.3,1.4-0.4,2.2-0.4c1.9,0.1,2.8,1.8,2.8,5
+        C180.3,71.7,179.3,73.3,177.4,73.4z M192.8,62.6h2v10.8c0,2.2-0.2,3.8-0.7,4.6c-0.4,0.9-1.3,1.5-2.6,2c-1,0.4-2.1,0.6-3.3,0.7
+        l-0.3-1.3c1.2-0.2,2-0.3,2.5-0.5c1-0.3,1.6-0.8,2-1.5c0.3-0.5,0.4-1.6,0.4-3.1v-0.5c-1.4,0.6-2.8,0.9-4.3,0.9c-1,0-1.8-0.3-2.6-0.9
+        c-0.8-0.7-1.3-1.5-1.3-2.6V63l2-0.7v8.3c0,0.9,0.3,1.6,0.9,2.1c0.6,0.5,1.3,0.7,2.2,0.7c0.9,0,1.9-0.4,2.9-1.1V62.6z M200.3,62.6
+        h2.2v1.3h-2.2v7.8c0,0.7,0.2,1.3,0.6,1.6c0.3,0.3,0.9,0.4,1.6,0.4v1c-0.2,0-0.5,0-0.7,0c-1.1,0-2-0.3-2.6-0.8
+        c-0.6-0.5-0.9-1.3-0.9-2.2v-7.8h-1.4v-1.3h1.4v-3.3l2-0.7V62.6z M213.6,63.6c0.7,0.7,1,1.6,1,2.6v8.3h-2v-7.7c0-0.8-0.2-1.5-0.5-2
+        c-0.4-0.6-1-1-1.8-1c-0.9,0-2.1,0.5-3.4,1.4v9.2h-2V56.2l2-0.6v8.4c1.3-0.9,2.7-1.4,4.2-1.4C212.1,62.5,212.9,62.9,213.6,63.6z
+         M221.9,62.3c-1.7,0-3,0.6-4,1.8c-1,1.1-1.4,2.6-1.4,4.2c0,1.8,0.4,3.3,1.3,4.4c1,1.3,2.3,2,4.1,2c1.8,0,3.1-0.7,4.1-2
+        c0.9-1.2,1.4-2.7,1.4-4.4c0-1.7-0.5-3.1-1.4-4.2C224.9,62.9,223.5,62.3,221.9,62.3z M221.9,73.5c-1.2,0-2-0.6-2.6-1.7
+        c-0.5-0.9-0.7-2.1-0.7-3.4c0-3,1.1-4.6,3.3-4.7c1.2,0.1,2.1,0.6,2.6,1.6c0.5,0.8,0.7,1.8,0.7,3.1C225.2,71.8,224.1,73.5,221.9,73.5
+        z M238.8,65.4v9.1h-2v-8.1c0-0.9-0.3-1.6-0.8-2.1c-0.5-0.5-1.3-0.7-2.1-0.7c-0.9,0-1.8,0.3-2.7,0.9v10h-2V64.3
+        c1.1-0.8,2.2-1.4,3.2-1.6c0.9-0.2,1.7-0.4,2.4-0.4c0.5,0,0.9,0,1.3,0.1c0.8,0.2,1.4,0.5,1.9,1C238.5,64,238.8,64.6,238.8,65.4z
+         M149.7,68.3h6c1.7,0,3-1.4,3-3v-5.7c0-1.6-1.4-2.8-3-3.1c-1-0.2-2.1-0.2-3.1-0.2s-2,0.1-2.9,0.2c-2.5,0.4-3,1.4-3,3.1v2.3h6v0.8
+        h-6h-2.2c-1.7,0-3.3,1-3.7,3c-0.6,2.3-0.6,3.7,0,6.1c0.4,1.8,1.4,3,3.2,3h2.1v-2.7C145.9,70.1,147.7,68.3,149.7,68.3z M149.3,60.4
+        c-0.6,0-1.1-0.5-1.1-1.1c0-0.6,0.5-1.1,1.1-1.1c0.6,0,1.1,0.5,1.1,1.1C150.4,59.8,149.9,60.4,149.3,60.4z M161.7,62.6h-2.2v2.7
+        c0,2.1-1.7,3.8-3.7,3.8h-6c-1.6,0-3,1.4-3,3v5.7c0,1.6,1.4,2.6,3,3c1.9,0.6,3.7,0.7,6,0c1.5-0.4,3-1.3,3-3v-2.3h-6v-0.8h6h3
+        c1.7,0,2.4-1.2,3-3c0.6-1.9,0.6-3.7,0-6.1C164.2,63.9,163.4,62.6,161.7,62.6z M156,77.1c0.6,0,1.1,0.5,1.1,1.1
+        c0,0.6-0.5,1.1-1.1,1.1c-0.6,0-1.1-0.5-1.1-1.1C154.9,77.6,155.4,77.1,156,77.1z"/>
+    <g>
+        <path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+</g>
+</svg>
diff --git a/docs/source/xtensor-python.svg b/docs/source/xtensor-python.svg
index 181465f92..7a29ffde8 100644
--- a/docs/source/xtensor-python.svg
+++ b/docs/source/xtensor-python.svg
@@ -1,60 +1,60 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 238.8 81.3" width="710.714286" height="241.964286" style="enable-background:new 0 0 238.8 81.3;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-</style>
-<g>
-	<path class="st0" d="M177.8,62.3L177.8,62.3c-1.7,0-3.2,0.3-4.3,1c-0.5,0.3-0.9,0.6-1.3,1v15.7l2,0.7v-7.1c1.2,0.8,2.4,1.1,3.6,1.1
-		c1.5,0,2.7-0.7,3.6-1.9c0.8-1.1,1.2-2.5,1.2-4.1h0c0-1.9-0.4-3.4-1.2-4.6C180.6,62.9,179.4,62.3,177.8,62.3z M177.4,73.4
-		c-0.9,0.1-2-0.3-3.2-1v-7.8c0.2-0.2,0.6-0.4,1.1-0.6c0.7-0.3,1.4-0.4,2.2-0.4c1.9,0.1,2.8,1.8,2.8,5
-		C180.3,71.7,179.3,73.3,177.4,73.4z M192.8,62.6h2v10.8c0,2.2-0.2,3.8-0.7,4.6c-0.4,0.9-1.3,1.5-2.6,2c-1,0.4-2.1,0.6-3.3,0.7
-		l-0.3-1.3c1.2-0.2,2-0.3,2.5-0.5c1-0.3,1.6-0.8,2-1.5c0.3-0.5,0.4-1.6,0.4-3.1v-0.5c-1.4,0.6-2.8,0.9-4.3,0.9c-1,0-1.8-0.3-2.6-0.9
-		c-0.8-0.7-1.3-1.5-1.3-2.6V63l2-0.7v8.3c0,0.9,0.3,1.6,0.9,2.1c0.6,0.5,1.3,0.7,2.2,0.7c0.9,0,1.9-0.4,2.9-1.1V62.6z M200.3,62.6
-		h2.2v1.3h-2.2v7.8c0,0.7,0.2,1.3,0.6,1.6c0.3,0.3,0.9,0.4,1.6,0.4v1c-0.2,0-0.5,0-0.7,0c-1.1,0-2-0.3-2.6-0.8
-		c-0.6-0.5-0.9-1.3-0.9-2.2v-7.8h-1.4v-1.3h1.4v-3.3l2-0.7V62.6z M213.6,63.6c0.7,0.7,1,1.6,1,2.6v8.3h-2v-7.7c0-0.8-0.2-1.5-0.5-2
-		c-0.4-0.6-1-1-1.8-1c-0.9,0-2.1,0.5-3.4,1.4v9.2h-2V56.2l2-0.6v8.4c1.3-0.9,2.7-1.4,4.2-1.4C212.1,62.5,212.9,62.9,213.6,63.6z
-		 M221.9,62.3c-1.7,0-3,0.6-4,1.8c-1,1.1-1.4,2.6-1.4,4.2c0,1.8,0.4,3.3,1.3,4.4c1,1.3,2.3,2,4.1,2c1.8,0,3.1-0.7,4.1-2
-		c0.9-1.2,1.4-2.7,1.4-4.4c0-1.7-0.5-3.1-1.4-4.2C224.9,62.9,223.5,62.3,221.9,62.3z M221.9,73.5c-1.2,0-2-0.6-2.6-1.7
-		c-0.5-0.9-0.7-2.1-0.7-3.4c0-3,1.1-4.6,3.3-4.7c1.2,0.1,2.1,0.6,2.6,1.6c0.5,0.8,0.7,1.8,0.7,3.1C225.2,71.8,224.1,73.5,221.9,73.5
-		z M238.8,65.4v9.1h-2v-8.1c0-0.9-0.3-1.6-0.8-2.1c-0.5-0.5-1.3-0.7-2.1-0.7c-0.9,0-1.8,0.3-2.7,0.9v10h-2V64.3
-		c1.1-0.8,2.2-1.4,3.2-1.6c0.9-0.2,1.7-0.4,2.4-0.4c0.5,0,0.9,0,1.3,0.1c0.8,0.2,1.4,0.5,1.9,1C238.5,64,238.8,64.6,238.8,65.4z
-		 M149.7,68.3h6c1.7,0,3-1.4,3-3v-5.7c0-1.6-1.4-2.8-3-3.1c-1-0.2-2.1-0.2-3.1-0.2s-2,0.1-2.9,0.2c-2.5,0.4-3,1.4-3,3.1v2.3h6v0.8
-		h-6h-2.2c-1.7,0-3.3,1-3.7,3c-0.6,2.3-0.6,3.7,0,6.1c0.4,1.8,1.4,3,3.2,3h2.1v-2.7C145.9,70.1,147.7,68.3,149.7,68.3z M149.3,60.4
-		c-0.6,0-1.1-0.5-1.1-1.1c0-0.6,0.5-1.1,1.1-1.1c0.6,0,1.1,0.5,1.1,1.1C150.4,59.8,149.9,60.4,149.3,60.4z M161.7,62.6h-2.2v2.7
-		c0,2.1-1.7,3.8-3.7,3.8h-6c-1.6,0-3,1.4-3,3v5.7c0,1.6,1.4,2.6,3,3c1.9,0.6,3.7,0.7,6,0c1.5-0.4,3-1.3,3-3v-2.3h-6v-0.8h6h3
-		c1.7,0,2.4-1.2,3-3c0.6-1.9,0.6-3.7,0-6.1C164.2,63.9,163.4,62.6,161.7,62.6z M156,77.1c0.6,0,1.1,0.5,1.1,1.1
-		c0,0.6-0.5,1.1-1.1,1.1c-0.6,0-1.1-0.5-1.1-1.1C154.9,77.6,155.4,77.1,156,77.1z"/>
-	<g>
-		<path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 238.8 81.3" width="710.714286" height="241.964286" style="enable-background:new 0 0 238.8 81.3;" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+</style>
+<g>
+    <path class="st0" d="M177.8,62.3L177.8,62.3c-1.7,0-3.2,0.3-4.3,1c-0.5,0.3-0.9,0.6-1.3,1v15.7l2,0.7v-7.1c1.2,0.8,2.4,1.1,3.6,1.1
+        c1.5,0,2.7-0.7,3.6-1.9c0.8-1.1,1.2-2.5,1.2-4.1h0c0-1.9-0.4-3.4-1.2-4.6C180.6,62.9,179.4,62.3,177.8,62.3z M177.4,73.4
+        c-0.9,0.1-2-0.3-3.2-1v-7.8c0.2-0.2,0.6-0.4,1.1-0.6c0.7-0.3,1.4-0.4,2.2-0.4c1.9,0.1,2.8,1.8,2.8,5
+        C180.3,71.7,179.3,73.3,177.4,73.4z M192.8,62.6h2v10.8c0,2.2-0.2,3.8-0.7,4.6c-0.4,0.9-1.3,1.5-2.6,2c-1,0.4-2.1,0.6-3.3,0.7
+        l-0.3-1.3c1.2-0.2,2-0.3,2.5-0.5c1-0.3,1.6-0.8,2-1.5c0.3-0.5,0.4-1.6,0.4-3.1v-0.5c-1.4,0.6-2.8,0.9-4.3,0.9c-1,0-1.8-0.3-2.6-0.9
+        c-0.8-0.7-1.3-1.5-1.3-2.6V63l2-0.7v8.3c0,0.9,0.3,1.6,0.9,2.1c0.6,0.5,1.3,0.7,2.2,0.7c0.9,0,1.9-0.4,2.9-1.1V62.6z M200.3,62.6
+        h2.2v1.3h-2.2v7.8c0,0.7,0.2,1.3,0.6,1.6c0.3,0.3,0.9,0.4,1.6,0.4v1c-0.2,0-0.5,0-0.7,0c-1.1,0-2-0.3-2.6-0.8
+        c-0.6-0.5-0.9-1.3-0.9-2.2v-7.8h-1.4v-1.3h1.4v-3.3l2-0.7V62.6z M213.6,63.6c0.7,0.7,1,1.6,1,2.6v8.3h-2v-7.7c0-0.8-0.2-1.5-0.5-2
+        c-0.4-0.6-1-1-1.8-1c-0.9,0-2.1,0.5-3.4,1.4v9.2h-2V56.2l2-0.6v8.4c1.3-0.9,2.7-1.4,4.2-1.4C212.1,62.5,212.9,62.9,213.6,63.6z
+         M221.9,62.3c-1.7,0-3,0.6-4,1.8c-1,1.1-1.4,2.6-1.4,4.2c0,1.8,0.4,3.3,1.3,4.4c1,1.3,2.3,2,4.1,2c1.8,0,3.1-0.7,4.1-2
+        c0.9-1.2,1.4-2.7,1.4-4.4c0-1.7-0.5-3.1-1.4-4.2C224.9,62.9,223.5,62.3,221.9,62.3z M221.9,73.5c-1.2,0-2-0.6-2.6-1.7
+        c-0.5-0.9-0.7-2.1-0.7-3.4c0-3,1.1-4.6,3.3-4.7c1.2,0.1,2.1,0.6,2.6,1.6c0.5,0.8,0.7,1.8,0.7,3.1C225.2,71.8,224.1,73.5,221.9,73.5
+        z M238.8,65.4v9.1h-2v-8.1c0-0.9-0.3-1.6-0.8-2.1c-0.5-0.5-1.3-0.7-2.1-0.7c-0.9,0-1.8,0.3-2.7,0.9v10h-2V64.3
+        c1.1-0.8,2.2-1.4,3.2-1.6c0.9-0.2,1.7-0.4,2.4-0.4c0.5,0,0.9,0,1.3,0.1c0.8,0.2,1.4,0.5,1.9,1C238.5,64,238.8,64.6,238.8,65.4z
+         M149.7,68.3h6c1.7,0,3-1.4,3-3v-5.7c0-1.6-1.4-2.8-3-3.1c-1-0.2-2.1-0.2-3.1-0.2s-2,0.1-2.9,0.2c-2.5,0.4-3,1.4-3,3.1v2.3h6v0.8
+        h-6h-2.2c-1.7,0-3.3,1-3.7,3c-0.6,2.3-0.6,3.7,0,6.1c0.4,1.8,1.4,3,3.2,3h2.1v-2.7C145.9,70.1,147.7,68.3,149.7,68.3z M149.3,60.4
+        c-0.6,0-1.1-0.5-1.1-1.1c0-0.6,0.5-1.1,1.1-1.1c0.6,0,1.1,0.5,1.1,1.1C150.4,59.8,149.9,60.4,149.3,60.4z M161.7,62.6h-2.2v2.7
+        c0,2.1-1.7,3.8-3.7,3.8h-6c-1.6,0-3,1.4-3,3v5.7c0,1.6,1.4,2.6,3,3c1.9,0.6,3.7,0.7,6,0c1.5-0.4,3-1.3,3-3v-2.3h-6v-0.8h6h3
+        c1.7,0,2.4-1.2,3-3c0.6-1.9,0.6-3.7,0-6.1C164.2,63.9,163.4,62.6,161.7,62.6z M156,77.1c0.6,0,1.1,0.5,1.1,1.1
+        c0,0.6-0.5,1.1-1.1,1.1c-0.6,0-1.1-0.5-1.1-1.1C154.9,77.6,155.4,77.1,156,77.1z"/>
+    <g>
+        <path class="st1" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st2" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+</g>
+</svg>
diff --git a/docs/source/xtensor-r-small.svg b/docs/source/xtensor-r-small.svg
index 5e3a5cd99..ff7958a87 100644
--- a/docs/source/xtensor-r-small.svg
+++ b/docs/source/xtensor-r-small.svg
@@ -1,48 +1,48 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 243.1 80.5" style="enable-background:new 0 0 243.1 80.5;" width="361.55" height="119.79" xml:space="preserve">
-<style type="text/css">
-	.st0{opacity:0.2;fill:#808080;}
-	.st1{fill:#666666;}
-	.st2{fill:#7FD787;}
-	.st3{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-</style>
-<g>
-	<path id="path16_2_" class="st0" d="M222.8,76.4c-11.2,0-20.2-6.1-20.2-13.5
-		c0-7.5,9.1-13.5,20.2-13.5c11.2,0,20.2,6.1,20.2,13.5C243.1,70.4,234,76.4,222.8,76.4z M225.9,54.6c-8.5,0-15.4,4.1-15.4,9.3
-		s6.9,9.3,15.4,9.3c8.5,0,14.8-2.8,14.8-9.3C240.7,57.5,234.4,54.6,225.9,54.6L225.9,54.6z"/>
-	<path id="path18_2_" class="st1" d="M233.4,70.3c0,0,1.2,0.4,1.9,0.7c0.2,0.1,0.7,0.4,1,0.7
-		c0.3,0.3,0.4,0.6,0.4,0.6l4.8,8.1l-7.8,0l-3.6-6.8c0,0-0.7-1.3-1.2-1.7c-0.4-0.3-0.5-0.4-0.9-0.4c-0.3,0-1.9,0-1.9,0l0,8.9l-6.9,0
-		V57.7h13.9c0,0,6.3,0.1,6.3,6.1C239.4,69.9,233.4,70.3,233.4,70.3L233.4,70.3z M230.4,62.7l-4.2,0l0,3.9l4.2,0c0,0,1.9,0,1.9-2
-		C232.3,62.6,230.4,62.7,230.4,62.7L230.4,62.7z"/>
-	<g>
-		<path class="st2" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st3" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 243.1 80.5" style="enable-background:new 0 0 243.1 80.5;" width="361.55" height="119.79" xml:space="preserve">
+<style type="text/css">
+    .st0{opacity:0.2;fill:#808080;}
+    .st1{fill:#666666;}
+    .st2{fill:#7FD787;}
+    .st3{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+</style>
+<g>
+    <path id="path16_2_" class="st0" d="M222.8,76.4c-11.2,0-20.2-6.1-20.2-13.5
+        c0-7.5,9.1-13.5,20.2-13.5c11.2,0,20.2,6.1,20.2,13.5C243.1,70.4,234,76.4,222.8,76.4z M225.9,54.6c-8.5,0-15.4,4.1-15.4,9.3
+        s6.9,9.3,15.4,9.3c8.5,0,14.8-2.8,14.8-9.3C240.7,57.5,234.4,54.6,225.9,54.6L225.9,54.6z"/>
+    <path id="path18_2_" class="st1" d="M233.4,70.3c0,0,1.2,0.4,1.9,0.7c0.2,0.1,0.7,0.4,1,0.7
+        c0.3,0.3,0.4,0.6,0.4,0.6l4.8,8.1l-7.8,0l-3.6-6.8c0,0-0.7-1.3-1.2-1.7c-0.4-0.3-0.5-0.4-0.9-0.4c-0.3,0-1.9,0-1.9,0l0,8.9l-6.9,0
+        V57.7h13.9c0,0,6.3,0.1,6.3,6.1C239.4,69.9,233.4,70.3,233.4,70.3L233.4,70.3z M230.4,62.7l-4.2,0l0,3.9l4.2,0c0,0,1.9,0,1.9-2
+        C232.3,62.6,230.4,62.7,230.4,62.7L230.4,62.7z"/>
+    <g>
+        <path class="st2" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st3" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+</g>
+</svg>
diff --git a/docs/source/xtensor-r.svg b/docs/source/xtensor-r.svg
index de03f1aed..c07afc656 100644
--- a/docs/source/xtensor-r.svg
+++ b/docs/source/xtensor-r.svg
@@ -1,48 +1,48 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 243.1 80.5" style="enable-background:new 0 0 243.1 80.5;" width="723.511905" height="239.583333" xml:space="preserve">
-<style type="text/css">
-	.st0{opacity:0.2;fill:#808080;}
-	.st1{fill:#666666;}
-	.st2{fill:#7FD787;}
-	.st3{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-</style>
-<g>
-	<path id="path16_2_" class="st0" d="M222.8,76.4c-11.2,0-20.2-6.1-20.2-13.5
-		c0-7.5,9.1-13.5,20.2-13.5c11.2,0,20.2,6.1,20.2,13.5C243.1,70.4,234,76.4,222.8,76.4z M225.9,54.6c-8.5,0-15.4,4.1-15.4,9.3
-		s6.9,9.3,15.4,9.3c8.5,0,14.8-2.8,14.8-9.3C240.7,57.5,234.4,54.6,225.9,54.6L225.9,54.6z"/>
-	<path id="path18_2_" class="st1" d="M233.4,70.3c0,0,1.2,0.4,1.9,0.7c0.2,0.1,0.7,0.4,1,0.7
-		c0.3,0.3,0.4,0.6,0.4,0.6l4.8,8.1l-7.8,0l-3.6-6.8c0,0-0.7-1.3-1.2-1.7c-0.4-0.3-0.5-0.4-0.9-0.4c-0.3,0-1.9,0-1.9,0l0,8.9l-6.9,0
-		V57.7h13.9c0,0,6.3,0.1,6.3,6.1C239.4,69.9,233.4,70.3,233.4,70.3L233.4,70.3z M230.4,62.7l-4.2,0l0,3.9l4.2,0c0,0,1.9,0,1.9-2
-		C232.3,62.6,230.4,62.7,230.4,62.7L230.4,62.7z"/>
-	<g>
-		<path class="st2" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
-			l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
-			c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
-			C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
-			H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
-			c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
-			V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
-			c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
-			c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
-			c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
-			C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
-			C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
-			C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
-			c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
-			c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
-			C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
-			c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
-			c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
-			c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
-			c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
-			C179.1,30.9,174.4,29.6,168.9,28z"/>
-		<path class="st3" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
-			c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
-			c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
-			c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
-			c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
-	</g>
-</g>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 243.1 80.5" style="enable-background:new 0 0 243.1 80.5;" width="723.511905" height="239.583333" xml:space="preserve">
+<style type="text/css">
+    .st0{opacity:0.2;fill:#808080;}
+    .st1{fill:#666666;}
+    .st2{fill:#7FD787;}
+    .st3{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+</style>
+<g>
+    <path id="path16_2_" class="st0" d="M222.8,76.4c-11.2,0-20.2-6.1-20.2-13.5
+        c0-7.5,9.1-13.5,20.2-13.5c11.2,0,20.2,6.1,20.2,13.5C243.1,70.4,234,76.4,222.8,76.4z M225.9,54.6c-8.5,0-15.4,4.1-15.4,9.3
+        s6.9,9.3,15.4,9.3c8.5,0,14.8-2.8,14.8-9.3C240.7,57.5,234.4,54.6,225.9,54.6L225.9,54.6z"/>
+    <path id="path18_2_" class="st1" d="M233.4,70.3c0,0,1.2,0.4,1.9,0.7c0.2,0.1,0.7,0.4,1,0.7
+        c0.3,0.3,0.4,0.6,0.4,0.6l4.8,8.1l-7.8,0l-3.6-6.8c0,0-0.7-1.3-1.2-1.7c-0.4-0.3-0.5-0.4-0.9-0.4c-0.3,0-1.9,0-1.9,0l0,8.9l-6.9,0
+        V57.7h13.9c0,0,6.3,0.1,6.3,6.1C239.4,69.9,233.4,70.3,233.4,70.3L233.4,70.3z M230.4,62.7l-4.2,0l0,3.9l4.2,0c0,0,1.9,0,1.9-2
+        C232.3,62.6,230.4,62.7,230.4,62.7L230.4,62.7z"/>
+    <g>
+        <path class="st2" d="M79.7,15.9L79.7,15.9L79.7,15.9L79.7,15.9z M71.4,38.4c-0.5-1.2-0.8-2.5-0.8-3.8c0-0.9,0-18.8,0-18.8h9.1
+            l-1.2-2.3h-7.9V5.2h-2.6v8.2h-8l-1.2,2.4h9.2c0,0,0,17.1,0,18c-0.1,1.9,0.2,3.9,0.9,5.5c0,0.1,0.8,1.6,1.9,3.1
+            c0.6,0.6,1.8,1.7,3.5,2.9l1.2-2.4c-1.3-0.9-2.2-1.6-2.7-2.2C71.9,39.5,71.4,38.4,71.4,38.4z M42.3,4.9c-1.6,1-2.8,2.3-3.8,3.7
+            C38.1,9.3,31.4,19.2,27.7,25C24.5,29.7,16.5,41.7,16,42.5c-1.3,2.2-3.1,4.1-5.2,5.5c0,0.1-2.3,1.4-5,2.3c-0.2,0-0.4,0.1-0.5,0.1
+            H45c-0.1,0-0.2-0.1-0.4-0.1c-2.7-0.9-4.9-2.2-5-2.3c-2.1-1.4-3.9-3.3-5.2-5.5c-0.4-0.6-5.6-8.4-9.3-13.9c0.9-1.3,1.6-2.5,2.3-3.3
+            c0,0.1,0.1,0.1,0.1,0.2c3.8,5.7,10.5,15.7,10.9,16.4c1,1.4,2.2,2.7,3.8,3.7c0,0,1.6,1.1,3.8,1.7c0.9,0.3,2.4,0.5,4.3,0.8v2.3h0.1
+            V2.4c-1.9,0.2-3.5,0.4-4.3,0.8C44,3.8,42.3,4.9,42.3,4.9z M11.9,41.9c0.4-0.8,7.1-10.7,10.9-16.4c3.1-4.9,11.1-16.7,11.7-17.6
+            c1.3-2.2,3.1-4.1,5.2-5.5c0-0.1,2.3-1.4,5-2.3C44.8,0.1,45,0,45.2,0H5.4c0.1,0,0.3,0.1,0.4,0.1c2.7,0.9,4.9,2.2,5,2.3
+            c2.1,1.4,3.9,3.3,5.2,5.5c0.4,0.6,5.6,8.4,9.3,13.9c-0.9,1.3-1.6,2.5-2.3,3.3c0-0.1-0.1-0.1-0.1-0.2C19,19.3,12.3,9.3,11.9,8.5
+            c-1-1.4-2.2-2.7-3.8-3.7c0,0-1.6-1.1-3.8-1.7C3.5,2.8,1.9,2.6,0,2.4v45.8c1.9-0.2,3.5-0.4,4.3-0.8c2.2-0.6,3.8-1.7,3.8-1.7
+            C9.7,44.5,11,43.3,11.9,41.9z M201.3,12.7c-9.6,0-13.4,5.4-13.4,16.7c0,11.5,3.8,16.7,13.4,16.7c9.6,0,13.4-5.4,13.4-16.7
+            C214.7,18,210.9,12.7,201.3,12.7z M201.3,44.1c-9.1,0-10.9-5.7-10.9-14.5s1.8-14.5,10.9-14.5c9.1,0,10.9,5.7,10.9,14.5
+            C212.2,38.2,210.3,44,201.3,44.1z M237.7,12.7c-4.6,0.2-7.8,1.8-9.8,5v-4.5c-0.9,0.1-1.7,0.3-2.5,0.5v32.1
+            c0.8,0.2,1.6,0.4,2.5,0.5v-17c0-8.8,1.8-14.5,10.9-14.5l0,0L237.7,12.7z M101,12.7c-5.8,0-12.7,2.2-12.7,16.9
+            c0,13.6,5.9,16.7,13.3,16.7c4,0,7.5-0.8,10.4-2.5l-1-2.2c-3,1.7-5.8,2.4-9.4,2.4c-5.8,0-10.4-2.1-10.8-12.4v-1.3h22.5l0,0v-0.9
+            C113.3,16.9,108.7,12.7,101,12.7z M90.6,28c0.2-11,5.1-13,10.3-13c5.7,0,9.7,3,9.7,13H90.6z M136.3,12.6h-1.4
+            c-9.5,0-10.8,8-10.8,15v16.9c0.8,0.6,1.6,1.2,2.6,1.6V28.4c0-7.9,1.2-13.5,8.6-13.5h0.6c7.5,0,8.6,5.5,8.6,13.5v17.8
+            c0.9-0.4,1.8-1,2.6-1.6V27.8C147.1,20.6,145.7,12.6,136.3,12.6z M168.9,28c-5-1.4-8-2.7-8-6.8c0-4.8,3.3-6.2,7.6-6.2
+            c2.8,0,5.4,0.4,7.8,1.6l1-2.2c-2.8-1.4-5.8-1.7-8.8-1.7c-5.2,0-9.9,2.4-9.9,8.3s4.2,7.8,9.4,9.2c4.9,1.3,8.8,2.4,8.8,6.7
+            c0,5.3-3.8,7-8,7c-3.8,0-7.5-1-10.2-2.8l-1.1,2.1c3.2,2.2,7.1,2.9,11.3,2.9c5.5,0,10.4-2.5,10.4-9.2
+            C179.1,30.9,174.4,29.6,168.9,28z"/>
+        <path class="st3" d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3
+            c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7
+            c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7
+            c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9
+            c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"/>
+    </g>
+</g>
+</svg>
diff --git a/docs/source/xtensor-ros.svg b/docs/source/xtensor-ros.svg
index cf86857ba..5f03871d1 100644
--- a/docs/source/xtensor-ros.svg
+++ b/docs/source/xtensor-ros.svg
@@ -45,9 +45,9 @@
      inkscape:current-layer="text4147" /><style
      type="text/css"
      id="style3">
-	.st0{fill:#666666;}
-	.st1{fill:#7FD787;}
-	.st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+    .st0{fill:#666666;}
+    .st1{fill:#7FD787;}
+    .st2{opacity:0.28;fill:#7FD787;enable-background:new    ;}
 </style><g
      style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#666666;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
      id="text4147"><g
@@ -73,4 +73,4 @@
          id="path11" /><path
          class="st2"
          d="M27.4,25.2c-0.6,0.9-1.4,2.1-2.3,3.3c3.7,5.5,8.8,13.3,9.3,13.9c1.3,2.2,3.1,4.1,5.2,5.5c0,0.1,2.3,1.4,5,2.3    c0.2,0,0.4,0.1,0.5,0.1h5.2V48c-1.9-0.2-3.5-0.4-4.3-0.8c-2.2-0.6-3.8-1.7-3.8-1.7c-1.6-1-2.8-2.3-3.8-3.7    c-0.4-0.8-7.1-10.7-10.9-16.4l0,0C27.5,25.4,27.5,25.3,27.4,25.2 M5.2,0H0v2.4c1.9,0.2,3.5,0.4,4.3,0.8c2.2,0.6,3.8,1.7,3.8,1.7    c1.6,1,2.8,2.3,3.8,3.7C12.3,9.3,19,19.2,22.8,25l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.9,1.4-2.1,2.3-3.3c-3.7-5.5-8.8-13.3-9.3-13.9    c-1.3-2.2-3.1-4.1-5.2-5.5c0-0.1-2.3-1.4-5-2.3C5.6,0.1,5.4,0,5.2,0"
-         id="path13" /></g></g></svg>
\ No newline at end of file
+         id="path13" /></g></g></svg>
diff --git a/docs/source/xtensor.svg b/docs/source/xtensor.svg
index df4cdb2fb..d86f6294f 100644
--- a/docs/source/xtensor.svg
+++ b/docs/source/xtensor.svg
@@ -1,35 +1,35 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 221 46.7" style="enable-background:new 0 0 221 46.7;" width="709.850107" height="150" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#7FD787;}
-	.st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
-</style>
-<path class="st0" d="M73.8,14.7L73.8,14.7L73.8,14.7L73.8,14.7z M66.1,35.5c-0.5-1.1-0.7-2.3-0.7-3.5c0-0.8,0-17.4,0-17.4h8.4
-	l-1.1-2.1h-7.3V4.8H63v7.6h-7.4l-1.1,2.2H63c0,0,0,15.8,0,16.7c-0.1,1.8,0.2,3.6,0.8,5.1c0,0.1,0.7,1.5,1.8,2.9
-	c0.6,0.6,1.7,1.6,3.2,2.7l1.1-2.2c-1.2-0.8-2-1.5-2.5-2C66.6,36.6,66.1,35.5,66.1,35.5z M39.2,4.5c-1.5,0.9-2.6,2.1-3.5,3.4
-	c-0.4,0.7-6.6,9.9-10.1,15.2c-2.9,4.4-10.3,15.5-10.8,16.2c-1.2,2-2.9,3.8-4.8,5.1c0,0.1-2.1,1.3-4.6,2.1c-0.2,0-0.4,0.1-0.5,0.1
-	h36.8c-0.1,0-0.2-0.1-0.4-0.1c-2.5-0.8-4.5-2-4.6-2.1c-1.9-1.3-3.6-3.1-4.8-5.1c-0.4-0.6-5.2-7.8-8.6-12.9c0.8-1.2,1.5-2.3,2.1-3.1
-	c0,0.1,0.1,0.1,0.1,0.2C29,28.8,35.2,38,35.6,38.7c0.9,1.3,2,2.5,3.5,3.4c0,0,1.5,1,3.5,1.6c0.8,0.3,2.2,0.5,4,0.7v2.1h0.1V2.2
-	c-1.8,0.2-3.2,0.4-4,0.7C40.7,3.5,39.2,4.5,39.2,4.5z M11,38.8c0.4-0.7,6.6-9.9,10.1-15.2C24,19.1,31.4,8.1,31.9,7.3
-	c1.2-2,2.9-3.8,4.8-5.1c0-0.1,2.1-1.3,4.6-2.1c0.2,0,0.4-0.1,0.5-0.1H5c0.1,0,0.3,0.1,0.4,0.1c2.5,0.8,4.5,2,4.6,2.1
-	c1.9,1.3,3.6,3.1,4.8,5.1c0.4,0.6,5.2,7.8,8.6,12.9c-0.8,1.2-1.5,2.3-2.1,3.1c0-0.1-0.1-0.1-0.1-0.2C17.6,17.9,11.4,8.6,11,7.9
-	c-0.9-1.3-2-2.5-3.5-3.4c0,0-1.5-1-3.5-1.6C3.2,2.6,1.8,2.4,0,2.2v42.4c1.8-0.2,3.2-0.4,4-0.7c2-0.6,3.5-1.6,3.5-1.6
-	C9,41.2,10.2,40.1,11,38.8z M186.3,11.8c-8.9,0-12.4,5-12.4,15.5c0,10.6,3.5,15.5,12.4,15.5s12.4-5,12.4-15.5
-	C198.7,16.7,195.2,11.8,186.3,11.8z M186.3,40.8c-8.4,0-10.1-5.3-10.1-13.4S177.9,14,186.3,14c8.4,0,10.1,5.3,10.1,13.4
-	C196.4,35.4,194.7,40.7,186.3,40.8z M220,11.8c-4.3,0.2-7.2,1.7-9.1,4.6v-4.2c-0.8,0.1-1.6,0.3-2.3,0.5v29.7
-	c0.7,0.2,1.5,0.4,2.3,0.5V27.2c0-8.1,1.7-13.4,10.1-13.4l0,0L220,11.8z M93.5,11.8c-5.4,0-11.8,2-11.8,15.6
-	c0,12.6,5.5,15.5,12.3,15.5c3.7,0,6.9-0.7,9.6-2.3l-0.9-2c-2.8,1.6-5.4,2.2-8.7,2.2c-5.4,0-9.6-1.9-10-11.5v-1.2h20.8l0,0v-0.8
-	C104.9,15.6,100.6,11.8,93.5,11.8z M83.9,25.9c0.2-10.2,4.7-12,9.5-12c5.3,0,9,2.8,9,12H83.9z M126.2,11.7h-1.3
-	c-8.8,0-10,7.4-10,13.9v15.6c0.7,0.6,1.5,1.1,2.4,1.5V26.3c0-7.3,1.1-12.5,8-12.5h0.6c6.9,0,8,5.1,8,12.5v16.5
-	c0.8-0.4,1.7-0.9,2.4-1.5V25.7C136.2,19.1,134.9,11.7,126.2,11.7z M156.3,25.9c-4.6-1.3-7.4-2.5-7.4-6.3c0-4.4,3.1-5.7,7-5.7
-	c2.6,0,5,0.4,7.2,1.5l0.9-2c-2.6-1.3-5.4-1.6-8.1-1.6c-4.8,0-9.2,2.2-9.2,7.7s3.9,7.2,8.7,8.5c4.5,1.2,8.1,2.2,8.1,6.2
-	c0,4.9-3.5,6.5-7.4,6.5c-3.5,0-6.9-0.9-9.4-2.6l-1,1.9c3,2,6.6,2.7,10.5,2.7c5.1,0,9.6-2.3,9.6-8.5
-	C165.8,28.6,161.4,27.4,156.3,25.9z"/>
-<path class="st1" d="M25.4,23.3c-0.6,0.8-1.3,1.9-2.1,3.1c3.4,5.1,8.1,12.3,8.6,12.9c1.2,2,2.9,3.8,4.8,5.1c0,0.1,2.1,1.3,4.6,2.1
-	c0.2,0,0.4,0.1,0.5,0.1h4.8v-2.2c-1.8-0.2-3.2-0.4-4-0.7c-2-0.6-3.5-1.6-3.5-1.6c-1.5-0.9-2.6-2.1-3.5-3.4
-	C35.2,38,29,28.8,25.5,23.5l0,0C25.5,23.5,25.5,23.4,25.4,23.3 M4.8,0H0v2.2c1.8,0.2,3.2,0.4,4,0.7c2,0.6,3.5,1.6,3.5,1.6
-	C9,5.4,10.1,6.6,11,7.9c0.4,0.7,6.6,9.9,10.1,15.2l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.8,1.3-1.9,2.1-3.1c-3.4-5.1-8.1-12.3-8.6-12.9
-	c-1.2-2-2.9-3.8-4.8-5.1c0-0.1-2.1-1.3-4.6-2.1C5.2,0.1,5,0,4.8,0"/>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Calque_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+     viewBox="0 0 221 46.7" style="enable-background:new 0 0 221 46.7;" width="709.850107" height="150" xml:space="preserve">
+<style type="text/css">
+    .st0{fill:#7FD787;}
+    .st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+</style>
+<path class="st0" d="M73.8,14.7L73.8,14.7L73.8,14.7L73.8,14.7z M66.1,35.5c-0.5-1.1-0.7-2.3-0.7-3.5c0-0.8,0-17.4,0-17.4h8.4
+    l-1.1-2.1h-7.3V4.8H63v7.6h-7.4l-1.1,2.2H63c0,0,0,15.8,0,16.7c-0.1,1.8,0.2,3.6,0.8,5.1c0,0.1,0.7,1.5,1.8,2.9
+    c0.6,0.6,1.7,1.6,3.2,2.7l1.1-2.2c-1.2-0.8-2-1.5-2.5-2C66.6,36.6,66.1,35.5,66.1,35.5z M39.2,4.5c-1.5,0.9-2.6,2.1-3.5,3.4
+    c-0.4,0.7-6.6,9.9-10.1,15.2c-2.9,4.4-10.3,15.5-10.8,16.2c-1.2,2-2.9,3.8-4.8,5.1c0,0.1-2.1,1.3-4.6,2.1c-0.2,0-0.4,0.1-0.5,0.1
+    h36.8c-0.1,0-0.2-0.1-0.4-0.1c-2.5-0.8-4.5-2-4.6-2.1c-1.9-1.3-3.6-3.1-4.8-5.1c-0.4-0.6-5.2-7.8-8.6-12.9c0.8-1.2,1.5-2.3,2.1-3.1
+    c0,0.1,0.1,0.1,0.1,0.2C29,28.8,35.2,38,35.6,38.7c0.9,1.3,2,2.5,3.5,3.4c0,0,1.5,1,3.5,1.6c0.8,0.3,2.2,0.5,4,0.7v2.1h0.1V2.2
+    c-1.8,0.2-3.2,0.4-4,0.7C40.7,3.5,39.2,4.5,39.2,4.5z M11,38.8c0.4-0.7,6.6-9.9,10.1-15.2C24,19.1,31.4,8.1,31.9,7.3
+    c1.2-2,2.9-3.8,4.8-5.1c0-0.1,2.1-1.3,4.6-2.1c0.2,0,0.4-0.1,0.5-0.1H5c0.1,0,0.3,0.1,0.4,0.1c2.5,0.8,4.5,2,4.6,2.1
+    c1.9,1.3,3.6,3.1,4.8,5.1c0.4,0.6,5.2,7.8,8.6,12.9c-0.8,1.2-1.5,2.3-2.1,3.1c0-0.1-0.1-0.1-0.1-0.2C17.6,17.9,11.4,8.6,11,7.9
+    c-0.9-1.3-2-2.5-3.5-3.4c0,0-1.5-1-3.5-1.6C3.2,2.6,1.8,2.4,0,2.2v42.4c1.8-0.2,3.2-0.4,4-0.7c2-0.6,3.5-1.6,3.5-1.6
+    C9,41.2,10.2,40.1,11,38.8z M186.3,11.8c-8.9,0-12.4,5-12.4,15.5c0,10.6,3.5,15.5,12.4,15.5s12.4-5,12.4-15.5
+    C198.7,16.7,195.2,11.8,186.3,11.8z M186.3,40.8c-8.4,0-10.1-5.3-10.1-13.4S177.9,14,186.3,14c8.4,0,10.1,5.3,10.1,13.4
+    C196.4,35.4,194.7,40.7,186.3,40.8z M220,11.8c-4.3,0.2-7.2,1.7-9.1,4.6v-4.2c-0.8,0.1-1.6,0.3-2.3,0.5v29.7
+    c0.7,0.2,1.5,0.4,2.3,0.5V27.2c0-8.1,1.7-13.4,10.1-13.4l0,0L220,11.8z M93.5,11.8c-5.4,0-11.8,2-11.8,15.6
+    c0,12.6,5.5,15.5,12.3,15.5c3.7,0,6.9-0.7,9.6-2.3l-0.9-2c-2.8,1.6-5.4,2.2-8.7,2.2c-5.4,0-9.6-1.9-10-11.5v-1.2h20.8l0,0v-0.8
+    C104.9,15.6,100.6,11.8,93.5,11.8z M83.9,25.9c0.2-10.2,4.7-12,9.5-12c5.3,0,9,2.8,9,12H83.9z M126.2,11.7h-1.3
+    c-8.8,0-10,7.4-10,13.9v15.6c0.7,0.6,1.5,1.1,2.4,1.5V26.3c0-7.3,1.1-12.5,8-12.5h0.6c6.9,0,8,5.1,8,12.5v16.5
+    c0.8-0.4,1.7-0.9,2.4-1.5V25.7C136.2,19.1,134.9,11.7,126.2,11.7z M156.3,25.9c-4.6-1.3-7.4-2.5-7.4-6.3c0-4.4,3.1-5.7,7-5.7
+    c2.6,0,5,0.4,7.2,1.5l0.9-2c-2.6-1.3-5.4-1.6-8.1-1.6c-4.8,0-9.2,2.2-9.2,7.7s3.9,7.2,8.7,8.5c4.5,1.2,8.1,2.2,8.1,6.2
+    c0,4.9-3.5,6.5-7.4,6.5c-3.5,0-6.9-0.9-9.4-2.6l-1,1.9c3,2,6.6,2.7,10.5,2.7c5.1,0,9.6-2.3,9.6-8.5
+    C165.8,28.6,161.4,27.4,156.3,25.9z"/>
+<path class="st1" d="M25.4,23.3c-0.6,0.8-1.3,1.9-2.1,3.1c3.4,5.1,8.1,12.3,8.6,12.9c1.2,2,2.9,3.8,4.8,5.1c0,0.1,2.1,1.3,4.6,2.1
+    c0.2,0,0.4,0.1,0.5,0.1h4.8v-2.2c-1.8-0.2-3.2-0.4-4-0.7c-2-0.6-3.5-1.6-3.5-1.6c-1.5-0.9-2.6-2.1-3.5-3.4
+    C35.2,38,29,28.8,25.5,23.5l0,0C25.5,23.5,25.5,23.4,25.4,23.3 M4.8,0H0v2.2c1.8,0.2,3.2,0.4,4,0.7c2,0.6,3.5,1.6,3.5,1.6
+    C9,5.4,10.1,6.6,11,7.9c0.4,0.7,6.6,9.9,10.1,15.2l0,0c0,0.1,0.1,0.1,0.1,0.2c0.6-0.8,1.3-1.9,2.1-3.1c-3.4-5.1-8.1-12.3-8.6-12.9
+    c-1.2-2-2.9-3.8-4.8-5.1c0-0.1-2.1-1.3-4.6-2.1C5.2,0.1,5,0,4.8,0"/>
+</svg>
diff --git a/docs/source/xtl.svg b/docs/source/xtl.svg
index 52318e2eb..2e7eea7a0 100644
--- a/docs/source/xtl.svg
+++ b/docs/source/xtl.svg
@@ -48,8 +48,8 @@
      inkscape:current-layer="Calque_1" /><style
      type="text/css"
      id="style20">
-	.st0{fill:#7FD787;}
-	.st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
+    .st0{fill:#7FD787;}
+    .st1{opacity:0.28;fill:#7FD787;enable-background:new    ;}
 </style><path
      class="st0"
      d="m 73.8,14.700001 0,0 0,0 z M 66.1,35.5 C 65.6,34.400001 65.4,33.200001 65.4,32 l 0,-17.399999 8.4,0 -1.1,-2.1 -7.3,0 0,-7.700001 -2.4,0 0,7.600001 -7.4,0 -1.1,2.2 8.5,0 L 63,31.3 c -0.1,1.8 0.2,3.6 0.8,5.1 0,0.1 0.7,1.5 1.8,2.9 0.6,0.6 1.7,1.6 3.2,2.7 l 1.1,-2.2 c -1.2,-0.8 -2,-1.5 -2.5,-2 -0.8,-1.2 -1.3,-2.3 -1.3,-2.3 z M 39.2,4.5 c -1.5,0.9 -2.6,2.1 -3.5,3.4 -0.4,0.7000004 -6.6,9.900001 -10.1,15.2 -2.9,4.400001 -10.3,15.5 -10.8,16.200001 -1.2,2 -2.9,3.799999 -4.8,5.1 0,0.1 -2.1,1.3 -4.6,2.1 -0.2,0 -0.4,0.1 -0.5,0.1 l 36.8,0 c -0.1,0 -0.2,-0.1 -0.4,-0.1 -2.5,-0.8 -4.5,-2 -4.6,-2.1 -1.9,-1.3 -3.6,-3.1 -4.8,-5.1 L 23.3,26.4 c 0.8,-1.199999 1.5,-2.3 2.1,-3.1 0,0.1 0.1,0.1 0.1,0.2 3.5,5.3 9.7,14.5 10.1,15.200001 0.9,1.299999 2,2.5 3.5,3.399999 0,0 1.5,1 3.5,1.600001 0.8,0.299999 2.2,0.5 4,0.7 l 0,2.1 0.1,0 L 46.7,2.2 c -1.8,0.2 -3.2,0.4 -4,0.7 -2,0.6 -3.5,1.6 -3.5,1.6 z M 11,38.800001 C 11.4,38.1 17.6,28.9 21.1,23.6 24,19.1 31.4,8.1 31.9,7.3 c 1.2,-2 2.9,-3.8 4.8,-5.1 0,-0.1 2.1,-1.3 4.6,-2.1 0.2,0 0.4,-0.1 0.5,-0.1 L 5,0 c 0.1,0 0.3,0.1 0.4,0.1 2.5,0.8 4.5,2 4.6,2.1 1.9,1.3 3.6,3.1 4.8,5.1 l 8.6,12.900001 c -0.8,1.199999 -1.5,2.3 -2.1,3.1 0,-0.1 -0.1,-0.1 -0.1,-0.200001 C 17.6,17.9 11.4,8.6000004 11,7.9 10.1,6.6 9,5.4 7.5,4.5 7.5,4.5 6,3.5 4,2.9 3.2,2.6 1.8,2.4 0,2.2 l 0,42.4 c 1.8,-0.199999 3.2,-0.399999 4,-0.699999 2,-0.6 3.5,-1.6 3.5,-1.6 1.5,-1.1 2.7,-2.200001 3.5,-3.5 z"
diff --git a/environment-dev.yml b/environment-dev.yml
new file mode 100644
index 000000000..fdfc75ea9
--- /dev/null
+++ b/environment-dev.yml
@@ -0,0 +1,11 @@
+name: xtensor
+channels:
+- conda-forge
+dependencies:
+- cmake
+- xtl=0.8.0
+- xsimd=14.2.0
+- nlohmann_json
+- doctest
+- pre-commit
+- ninja
diff --git a/environment.yml b/environment.yml
index 771f0f56f..b5b559d52 100644
--- a/environment.yml
+++ b/environment.yml
@@ -1,9 +1,7 @@
 name: xtensor
 channels:
-  - QuantStack
-  - conda-forge
+- conda-forge
 dependencies:
-  - xtensor=0.18.2
-  - xtensor-blas=0.14.0
-  - xeus-cling=0.4.5
-  - notebook
+- xtensor=0.24.6
+- xtensor-blas=0.20.0
+- xeus-cling=0.15.0
diff --git a/etc/xeus-cpp/tags.d/xtensor.json b/etc/xeus-cpp/tags.d/xtensor.json
new file mode 100644
index 000000000..8c10f7409
--- /dev/null
+++ b/etc/xeus-cpp/tags.d/xtensor.json
@@ -0,0 +1,4 @@
+{
+  "tagfile": "xtensor.tag",
+  "url": "https://xtensor.readthedocs.io/en/latest/"
+}
diff --git a/include/xtensor/chunk/xchunked_array.hpp b/include/xtensor/chunk/xchunked_array.hpp
new file mode 100644
index 000000000..dc0c16355
--- /dev/null
+++ b/include/xtensor/chunk/xchunked_array.hpp
@@ -0,0 +1,686 @@
+/***************************************************************************
+ * 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_CHUNKED_ARRAY_HPP
+#define XTENSOR_CHUNKED_ARRAY_HPP
+
+#include <array>
+#include <vector>
+
+#include "../chunk/xchunked_assign.hpp"
+#include "../containers/xarray.hpp"
+
+namespace xt
+{
+    /**
+     * @defgroup xt_xchunked_array Chunked array
+     *
+     * Chunked array container.
+     * Defined in ``xtensor/xchunked_array.hpp``.
+     */
+
+    /******************************
+     * xchunked_array declaration *
+     ******************************/
+
+    template <class chunk_storage>
+    class xchunked_array;
+
+    template <class chunk_storage>
+    struct xcontainer_inner_types<xchunked_array<chunk_storage>>
+    {
+        using chunk_type = typename chunk_storage::value_type;
+        using const_reference = typename chunk_type::const_reference;
+        using reference = typename chunk_type::reference;
+        using size_type = std::size_t;
+        using storage_type = chunk_type;
+        using temporary_type = xchunked_array<chunk_storage>;
+    };
+
+    template <class chunk_storage>
+    struct xiterable_inner_types<xchunked_array<chunk_storage>>
+    {
+        using chunk_type = typename chunk_storage::value_type;
+        using inner_shape_type = typename chunk_type::shape_type;
+        using const_stepper = xindexed_stepper<xchunked_array<chunk_storage>, true>;
+        using stepper = xindexed_stepper<xchunked_array<chunk_storage>, false>;
+    };
+
+    template <class chunk_storage>
+    class xchunked_array : public xaccessible<xchunked_array<chunk_storage>>,
+                           public xiterable<xchunked_array<chunk_storage>>,
+                           public xchunked_semantic<xchunked_array<chunk_storage>>
+    {
+    public:
+
+        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>;
+        static constexpr layout_type static_layout = layout_type::dynamic;
+        static constexpr bool contiguous_layout = false;
+        using chunk_iterator = xchunk_iterator<self_type>;
+        using const_chunk_iterator = xchunk_iterator<const self_type>;
+
+        template <class S>
+        xchunked_array(
+            chunk_storage_type&& chunks,
+            S&& shape,
+            S&& chunk_shape,
+            layout_type chunk_memory_layout = XTENSOR_DEFAULT_LAYOUT
+        );
+        ~xchunked_array() = default;
+
+        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 = XTENSOR_DEFAULT_LAYOUT
+        );
+
+        template <class E, class S>
+        xchunked_array(
+            const xexpression<E>& e,
+            chunk_storage_type&& chunks,
+            S&& chunk_shape,
+            layout_type chunk_memory_layout = XTENSOR_DEFAULT_LAYOUT
+        );
+
+        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;
+
+    private:
+
+        template <class... Idxs>
+        using indexes_type = std::
+            pair<std::array<std::size_t, sizeof...(Idxs)>, std::array<std::size_t, sizeof...(Idxs)>>;
+
+        template <class... Idxs>
+        using chunk_indexes_type = std::array<std::pair<std::size_t, std::size_t>, sizeof...(Idxs)>;
+
+        template <std::size_t N>
+        using static_indexes_type = std::pair<std::array<std::size_t, N>, std::array<std::size_t, N>>;
+
+        using dynamic_indexes_type = std::pair<std::vector<std::size_t>, std::vector<std::size_t>>;
+
+        template <class S1, class S2>
+        void resize(S1&& shape, S2&& chunk_shape, layout_type chunk_memory_layout = XTENSOR_DEFAULT_LAYOUT);
+
+        template <class... Idxs>
+        indexes_type<Idxs...> get_indexes(Idxs... idxs) const;
+
+        template <class Idx>
+        std::pair<std::size_t, std::size_t> get_chunk_indexes_in_dimension(std::size_t dim, Idx idx) const;
+
+        template <std::size_t... dims, class... Idxs>
+        chunk_indexes_type<Idxs...> get_chunk_indexes(std::index_sequence<dims...>, Idxs... idxs) const;
+
+        template <class T, std::size_t N>
+        static_indexes_type<N> unpack(const std::array<T, N>& arr) const;
+
+        template <class It>
+        dynamic_indexes_type get_indexes_dynamic(It first, It last) const;
+
+        shape_type m_shape;
+        shape_type m_chunk_shape;
+        chunk_storage_type m_chunks;
+    };
+
+    template <class E>
+    constexpr bool is_chunked(const xexpression<E>& e);
+
+    template <class E>
+    constexpr bool is_chunked();
+
+    /**
+     * Creates an in-memory chunked array.
+     *
+     * This function returns an uninitialized ``xt::xchunked_array<xt::xarray<T>>``.
+     *
+     * @ingroup xt_xchunked_array
+     *
+     * @tparam T The type of the elements (e.g. double)
+     * @tparam L The layout_type of the array
+     *
+     * @param shape The shape of the array
+     * @param chunk_shape The shape of a chunk
+     * @param chunk_memory_layout The layout of each chunk (default: XTENSOR_DEFAULT_LAYOUT)
+     *
+     * @return returns a ``xt::xchunked_array<xt::xarray<T>>`` with the given shape, chunk shape and memory
+     * layout.
+     */
+    template <class T, layout_type L = XTENSOR_DEFAULT_LAYOUT, class S>
+    xchunked_array<xarray<xarray<T>>>
+    chunked_array(S&& shape, S&& chunk_shape, layout_type chunk_memory_layout = XTENSOR_DEFAULT_LAYOUT);
+
+    template <class T, layout_type L = XTENSOR_DEFAULT_LAYOUT, class S>
+    xchunked_array<xarray<xarray<T>>> chunked_array(
+        std::initializer_list<S> shape,
+        std::initializer_list<S> chunk_shape,
+        layout_type chunk_memory_layout = XTENSOR_DEFAULT_LAYOUT
+    );
+
+    /**
+     * Creates an in-memory chunked array.
+     *
+     * This function returns a ``xt::xchunked_array<xt::xarray<T>>`` initialized from an expression.
+     *
+     * @ingroup xt_xchunked_array
+     *
+     * @tparam L The layout_type of the array
+     *
+     * @param e The expression to initialize the chunked array from
+     * @param chunk_shape The shape of a chunk
+     * @param chunk_memory_layout The layout of each chunk (default: XTENSOR_DEFAULT_LAYOUT)
+     *
+     * @return returns a ``xt::xchunked_array<xt::xarray<T>>`` from the given expression, with the given chunk
+     * shape and memory layout.
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class E, class S>
+    xchunked_array<xarray<xarray<typename E::value_type>>>
+    chunked_array(const xexpression<E>& e, S&& chunk_shape, layout_type chunk_memory_layout = XTENSOR_DEFAULT_LAYOUT);
+
+    /**
+     * Creates an in-memory chunked array.
+     *
+     * This function returns a ``xt::xchunked_array<xt::xarray<T>>`` initialized from an expression.
+     *
+     * @ingroup xt_xchunked_array
+     *
+     * @tparam L The layout_type of the array
+     *
+     * @param e The expression to initialize the chunked array from
+     * @param chunk_memory_layout The layout of each chunk (default: XTENSOR_DEFAULT_LAYOUT)
+     *
+     * @return returns a ``xt::xchunked_array<xt::xarray<T>>`` from the given expression, with the
+     * expression's chunk shape and the given memory layout.
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class E>
+    xchunked_array<xarray<xarray<typename E::value_type>>>
+    chunked_array(const xexpression<E>& e, layout_type chunk_memory_layout = XTENSOR_DEFAULT_LAYOUT);
+
+    /*******************************
+     * chunk_helper implementation *
+     *******************************/
+
+    namespace detail
+    {
+        // Workaround for VS2015
+        template <class E>
+        using try_chunk_shape = decltype(std::declval<E>().chunk_shape());
+
+        template <class E, template <class> class OP, class = void>
+        struct chunk_helper_impl
+        {
+            using is_chunked = std::false_type;
+
+            static const auto& chunk_shape(const xexpression<E>& e)
+            {
+                return e.derived_cast().shape();
+            }
+
+            template <class S1, class S2>
+            static void
+            resize(E& chunks, const S1& container_shape, const S2& chunk_shape, layout_type chunk_memory_layout)
+            {
+                chunks.resize(container_shape);
+                for (auto& c : chunks)
+                {
+                    c.resize(chunk_shape, chunk_memory_layout);
+                }
+            }
+        };
+
+        template <class E, template <class> class OP>
+        struct chunk_helper_impl<E, OP, void_t<OP<E>>>
+        {
+            using is_chunked = std::true_type;
+
+            static const auto& chunk_shape(const xexpression<E>& e)
+            {
+                return e.derived_cast().chunk_shape();
+            }
+
+            template <class S1, class S2>
+            static void
+            resize(E& chunks, const S1& container_shape, const S2& /*chunk_shape*/, layout_type /*chunk_memory_layout*/)
+            {
+                chunks.resize(container_shape);
+            }
+        };
+
+        template <class E>
+        using chunk_helper = chunk_helper_impl<E, try_chunk_shape>;
+    }
+
+    template <class E>
+    constexpr bool is_chunked(const xexpression<E>&)
+    {
+        return is_chunked<E>();
+    }
+
+    template <class E>
+    constexpr bool is_chunked()
+    {
+        using return_type = typename detail::chunk_helper<E>::is_chunked;
+        return return_type::value;
+    }
+
+    template <class T, layout_type L, class S>
+    inline xchunked_array<xarray<xarray<T>>>
+    chunked_array(S&& shape, S&& chunk_shape, layout_type chunk_memory_layout)
+    {
+        using chunk_storage = xarray<xarray<T, L>>;
+        return xchunked_array<chunk_storage>(
+            chunk_storage(),
+            std::forward<S>(shape),
+            std::forward<S>(chunk_shape),
+            chunk_memory_layout
+        );
+    }
+
+    template <class T, layout_type L, class S>
+    xchunked_array<xarray<xarray<T>>>
+    chunked_array(std::initializer_list<S> shape, std::initializer_list<S> chunk_shape, layout_type chunk_memory_layout)
+    {
+        using sh_type = std::vector<std::size_t>;
+        auto sh = xtl::forward_sequence<sh_type, std::initializer_list<S>>(shape);
+        auto ch_sh = xtl::forward_sequence<sh_type, std::initializer_list<S>>(chunk_shape);
+        return chunked_array<T, L, sh_type>(std::move(sh), std::move(ch_sh), chunk_memory_layout);
+    }
+
+    template <layout_type L, class E, class S>
+    inline xchunked_array<xarray<xarray<typename E::value_type>>>
+    chunked_array(const xexpression<E>& e, S&& chunk_shape, layout_type chunk_memory_layout)
+    {
+        using chunk_storage = xarray<xarray<typename E::value_type, L>>;
+        return xchunked_array<chunk_storage>(e, chunk_storage(), std::forward<S>(chunk_shape), chunk_memory_layout);
+    }
+
+    template <layout_type L, class E>
+    inline xchunked_array<xarray<xarray<typename E::value_type>>>
+    chunked_array(const xexpression<E>& e, layout_type chunk_memory_layout)
+    {
+        using chunk_storage = xarray<xarray<typename E::value_type, L>>;
+        return xchunked_array<chunk_storage>(e, chunk_storage(), chunk_memory_layout);
+    }
+
+    /*********************************
+     * xchunked_array implementation *
+     *********************************/
+
+    template <class CS>
+    template <class S>
+    inline xchunked_array<CS>::xchunked_array(CS&& chunks, S&& shape, S&& chunk_shape, layout_type chunk_memory_layout)
+        : m_chunks(std::move(chunks))
+    {
+        resize(std::forward<S>(shape), std::forward<S>(chunk_shape), chunk_memory_layout);
+    }
+
+    template <class CS>
+    template <class E>
+    inline xchunked_array<CS>::xchunked_array(const xexpression<E>& e, CS&& chunks, layout_type chunk_memory_layout)
+        : xchunked_array(e, std::move(chunks), detail::chunk_helper<E>::chunk_shape(e), chunk_memory_layout)
+    {
+    }
+
+    template <class CS>
+    template <class E, class S>
+    inline xchunked_array<CS>::xchunked_array(
+        const xexpression<E>& e,
+        CS&& chunks,
+        S&& chunk_shape,
+        layout_type chunk_memory_layout
+    )
+        : m_chunks(std::move(chunks))
+    {
+        resize(e.derived_cast().shape(), std::forward<S>(chunk_shape), chunk_memory_layout);
+        semantic_base::assign_xexpression(e);
+    }
+
+    template <class CS>
+    template <class E>
+    inline auto xchunked_array<CS>::operator=(const xexpression<E>& e) -> self_type&
+    {
+        return semantic_base::operator=(e);
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::dimension() const noexcept -> size_type
+    {
+        return m_shape.size();
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::shape() const noexcept -> const shape_type&
+    {
+        return m_shape;
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::layout() const noexcept -> layout_type
+    {
+        return static_layout;
+    }
+
+    template <class CS>
+    inline bool xchunked_array<CS>::is_contiguous() const noexcept
+    {
+        return false;
+    }
+
+    template <class CS>
+    template <class... Idxs>
+    inline auto xchunked_array<CS>::operator()(Idxs... idxs) -> reference
+    {
+        auto ii = get_indexes(idxs...);
+        auto& chunk = m_chunks.element(ii.first.cbegin(), ii.first.cend());
+        return chunk.element(ii.second.cbegin(), ii.second.cend());
+    }
+
+    template <class CS>
+    template <class... Idxs>
+    inline auto xchunked_array<CS>::operator()(Idxs... idxs) const -> const_reference
+    {
+        auto ii = get_indexes(idxs...);
+        auto& chunk = m_chunks.element(ii.first.cbegin(), ii.first.cend());
+        return chunk.element(ii.second.cbegin(), ii.second.cend());
+    }
+
+    template <class CS>
+    template <class It>
+    inline auto xchunked_array<CS>::element(It first, It last) -> reference
+    {
+        auto ii = get_indexes_dynamic(first, last);
+        auto& chunk = m_chunks.element(ii.first.begin(), ii.first.end());
+        return chunk.element(ii.second.begin(), ii.second.end());
+    }
+
+    template <class CS>
+    template <class It>
+    inline auto xchunked_array<CS>::element(It first, It last) const -> const_reference
+    {
+        auto ii = get_indexes_dynamic(first, last);
+        auto& chunk = m_chunks.element(ii.first.begin(), ii.first.end());
+        return chunk.element(ii.second.begin(), ii.second.end());
+    }
+
+    template <class CS>
+    template <class S>
+    inline bool xchunked_array<CS>::broadcast_shape(S& s, bool) const
+    {
+        return xt::broadcast_shape(shape(), s);
+    }
+
+    template <class CS>
+    template <class S>
+    inline bool xchunked_array<CS>::has_linear_assign(const S&) const noexcept
+    {
+        return false;
+    }
+
+    template <class CS>
+    template <class S>
+    inline auto xchunked_array<CS>::stepper_begin(const S& shape) noexcept -> stepper
+    {
+        size_type offset = shape.size() - this->dimension();
+        return stepper(this, offset);
+    }
+
+    template <class CS>
+    template <class S>
+    inline auto xchunked_array<CS>::stepper_end(const S& shape, layout_type) noexcept -> stepper
+    {
+        size_type offset = shape.size() - this->dimension();
+        return stepper(this, offset, true);
+    }
+
+    template <class CS>
+    template <class S>
+    inline auto xchunked_array<CS>::stepper_begin(const S& shape) const noexcept -> const_stepper
+    {
+        size_type offset = shape.size() - this->dimension();
+        return const_stepper(this, offset);
+    }
+
+    template <class CS>
+    template <class S>
+    inline auto xchunked_array<CS>::stepper_end(const S& shape, layout_type) const noexcept -> const_stepper
+    {
+        size_type offset = shape.size() - this->dimension();
+        return const_stepper(this, offset, true);
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunk_shape() const noexcept -> const shape_type&
+    {
+        return m_chunk_shape;
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::grid_size() const noexcept -> size_type
+    {
+        return m_chunks.size();
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::grid_shape() const noexcept -> const grid_shape_type&
+    {
+        return m_chunks.shape();
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunks() -> chunk_storage_type&
+    {
+        return m_chunks;
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunks() const -> const chunk_storage_type&
+    {
+        return m_chunks;
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunk_begin() -> chunk_iterator
+    {
+        shape_type chunk_index(m_shape.size(), size_type(0));
+        return chunk_iterator(*this, std::move(chunk_index), 0u);
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunk_end() -> chunk_iterator
+    {
+        shape_type sh = xtl::forward_sequence<shape_type, const grid_shape_type>(grid_shape());
+        return chunk_iterator(*this, std::move(sh), grid_size());
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunk_begin() const -> const_chunk_iterator
+    {
+        shape_type chunk_index(m_shape.size(), size_type(0));
+        return const_chunk_iterator(*this, std::move(chunk_index), 0u);
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunk_end() const -> const_chunk_iterator
+    {
+        shape_type sh = xtl::forward_sequence<shape_type, const grid_shape_type>(grid_shape());
+        return const_chunk_iterator(*this, std::move(sh), grid_size());
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunk_cbegin() const -> const_chunk_iterator
+    {
+        return chunk_begin();
+    }
+
+    template <class CS>
+    inline auto xchunked_array<CS>::chunk_cend() const -> const_chunk_iterator
+    {
+        return chunk_end();
+    }
+
+    template <class CS>
+    template <class S1, class S2>
+    inline void xchunked_array<CS>::resize(S1&& shape, S2&& chunk_shape, layout_type chunk_memory_layout)
+    {
+        // compute chunk number in each dimension (shape_of_chunks)
+        std::vector<std::size_t> shape_of_chunks(shape.size());
+        std::transform(
+            shape.cbegin(),
+            shape.cend(),
+            chunk_shape.cbegin(),
+            shape_of_chunks.begin(),
+            [](auto s, auto cs)
+            {
+                std::size_t cn = s / cs;
+                if (s % cs > 0)
+                {
+                    cn += std::size_t(1);  // edge_chunk
+                }
+                return cn;
+            }
+        );
+
+        detail::chunk_helper<CS>::resize(m_chunks, shape_of_chunks, chunk_shape, chunk_memory_layout);
+
+        m_shape = xtl::forward_sequence<shape_type, S1>(shape);
+        m_chunk_shape = xtl::forward_sequence<shape_type, S2>(chunk_shape);
+    }
+
+    template <class CS>
+    template <class... Idxs>
+    inline auto xchunked_array<CS>::get_indexes(Idxs... idxs) const -> indexes_type<Idxs...>
+    {
+        auto chunk_indexes_packed = get_chunk_indexes(std::make_index_sequence<sizeof...(Idxs)>(), idxs...);
+        return unpack(chunk_indexes_packed);
+    }
+
+    template <class CS>
+    template <class Idx>
+    inline std::pair<std::size_t, std::size_t>
+    xchunked_array<CS>::get_chunk_indexes_in_dimension(std::size_t dim, Idx idx) const
+    {
+        std::size_t index_of_chunk = static_cast<size_t>(idx) / m_chunk_shape[dim];
+        std::size_t index_in_chunk = static_cast<size_t>(idx) - index_of_chunk * m_chunk_shape[dim];
+        return std::make_pair(index_of_chunk, index_in_chunk);
+    }
+
+    template <class CS>
+    template <std::size_t... dims, class... Idxs>
+    inline auto xchunked_array<CS>::get_chunk_indexes(std::index_sequence<dims...>, Idxs... idxs) const
+        -> chunk_indexes_type<Idxs...>
+    {
+        chunk_indexes_type<Idxs...> chunk_indexes = {{get_chunk_indexes_in_dimension(dims, idxs)...}};
+        return chunk_indexes;
+    }
+
+    template <class CS>
+    template <class T, std::size_t N>
+    inline auto xchunked_array<CS>::unpack(const std::array<T, N>& arr) const -> static_indexes_type<N>
+    {
+        std::array<std::size_t, N> arr0;
+        std::array<std::size_t, N> arr1;
+        for (std::size_t i = 0; i < N; ++i)
+        {
+            arr0[i] = std::get<0>(arr[i]);
+            arr1[i] = std::get<1>(arr[i]);
+        }
+        return std::make_pair(arr0, arr1);
+    }
+
+    template <class CS>
+    template <class It>
+    inline auto xchunked_array<CS>::get_indexes_dynamic(It first, It last) const -> dynamic_indexes_type
+    {
+        auto size = static_cast<std::size_t>(std::distance(first, last));
+        std::vector<std::size_t> indexes_of_chunk(size);
+        std::vector<std::size_t> indexes_in_chunk(size);
+        for (std::size_t dim = 0; dim < size; ++dim)
+        {
+            auto chunk_index = get_chunk_indexes_in_dimension(dim, *first++);
+            indexes_of_chunk[dim] = chunk_index.first;
+            indexes_in_chunk[dim] = chunk_index.second;
+        }
+        return std::make_pair(indexes_of_chunk, indexes_in_chunk);
+    }
+}
+
+#endif
diff --git a/include/xtensor/chunk/xchunked_assign.hpp b/include/xtensor/chunk/xchunked_assign.hpp
new file mode 100644
index 000000000..334e824b9
--- /dev/null
+++ b/include/xtensor/chunk/xchunked_assign.hpp
@@ -0,0 +1,378 @@
+/***************************************************************************
+ * 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_CHUNKED_ASSIGN_HPP
+#define XTENSOR_CHUNKED_ASSIGN_HPP
+
+#include "../core/xnoalias.hpp"
+#include "../views/xstrided_view.hpp"
+
+namespace xt
+{
+
+    /*******************
+     * xchunk_assigner *
+     *******************/
+
+    template <class T, class chunk_storage>
+    class xchunked_assigner
+    {
+    public:
+
+        using temporary_type = T;
+
+        template <class E, class DST>
+        void build_and_assign_temporary(const xexpression<E>& e, DST& dst);
+    };
+
+    /*********************************
+     * xchunked_semantic declaration *
+     *********************************/
+
+    template <class D>
+    class xchunked_semantic : public xsemantic_base<D>
+    {
+    public:
+
+        using base_type = xsemantic_base<D>;
+        using derived_type = D;
+        using temporary_type = typename base_type::temporary_type;
+
+        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);
+
+    protected:
+
+        xchunked_semantic() = default;
+        ~xchunked_semantic() = default;
+
+        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);
+
+    private:
+
+        template <class CS>
+        xchunked_assigner<temporary_type, CS> get_assigner(const CS&) const;
+    };
+
+    /*******************
+     * xchunk_iterator *
+     *******************/
+
+    template <class CS>
+    class xchunked_array;
+
+    template <class E>
+    class xchunked_view;
+
+    namespace detail
+    {
+        template <class T>
+        struct is_xchunked_array : std::false_type
+        {
+        };
+
+        template <class CS>
+        struct is_xchunked_array<xchunked_array<CS>> : std::true_type
+        {
+        };
+
+        template <class T>
+        struct is_xchunked_view : std::false_type
+        {
+        };
+
+        template <class E>
+        struct is_xchunked_view<xchunked_view<E>> : std::true_type
+        {
+        };
+
+        struct invalid_chunk_iterator
+        {
+        };
+
+        template <class A>
+        struct xchunk_iterator_array
+        {
+            using reference = decltype(*(std::declval<A>().chunks().begin()));
+
+            inline decltype(auto) get_chunk(A& arr, typename A::size_type i, const xstrided_slice_vector&) const
+            {
+                using difference_type = typename A::difference_type;
+                return *(arr.chunks().begin() + static_cast<difference_type>(i));
+            }
+        };
+
+        template <class V>
+        struct xchunk_iterator_view
+        {
+            using reference = decltype(xt::strided_view(
+                std::declval<V>().expression(),
+                std::declval<xstrided_slice_vector>()
+            ));
+
+            inline auto get_chunk(V& view, typename V::size_type, const xstrided_slice_vector& sv) const
+            {
+                return xt::strided_view(view.expression(), sv);
+            }
+        };
+
+        template <class T>
+        struct xchunk_iterator_base
+            : std::conditional_t<
+                  is_xchunked_array<std::decay_t<T>>::value,
+                  xchunk_iterator_array<T>,
+                  std::conditional_t<is_xchunked_view<std::decay_t<T>>::value, xchunk_iterator_view<T>, invalid_chunk_iterator>>
+        {
+        };
+    }
+
+    template <class E>
+    class xchunk_iterator : private detail::xchunk_iterator_base<E>
+    {
+    public:
+
+        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;
+
+
+        xchunk_iterator() = default;
+        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;
+
+    private:
+
+        void fill_slice_vector(size_type index);
+
+        E* p_chunked_expression;
+        shape_type m_chunk_index;
+        size_type m_chunk_linear_index;
+        xstrided_slice_vector m_slice_vector;
+    };
+
+    /************************************
+     * xchunked_semantic implementation *
+     ************************************/
+
+    template <class T, class CS>
+    template <class E, class DST>
+    inline void xchunked_assigner<T, CS>::build_and_assign_temporary(const xexpression<E>& e, DST& dst)
+    {
+        temporary_type tmp(e, CS(), dst.chunk_shape());
+        dst = std::move(tmp);
+    }
+
+    template <class D>
+    template <class E>
+    inline auto xchunked_semantic<D>::assign_xexpression(const xexpression<E>& e) -> derived_type&
+    {
+        auto& d = this->derived_cast();
+        const auto& chunk_shape = d.chunk_shape();
+        size_t i = 0;
+        auto it_end = d.chunk_end();
+        for (auto it = d.chunk_begin(); it != it_end; ++it, ++i)
+        {
+            auto rhs = strided_view(e.derived_cast(), it.get_slice_vector());
+            if (rhs.shape() != chunk_shape)
+            {
+                noalias(strided_view(*it, it.get_chunk_slice_vector())) = rhs;
+            }
+            else
+            {
+                noalias(*it) = rhs;
+            }
+        }
+
+        return this->derived_cast();
+    }
+
+    template <class D>
+    template <class E>
+    inline auto xchunked_semantic<D>::computed_assign(const xexpression<E>& e) -> derived_type&
+    {
+        D& d = this->derived_cast();
+        if (e.derived_cast().dimension() > d.dimension() || e.derived_cast().shape() > d.shape())
+        {
+            return operator=(e);
+        }
+        else
+        {
+            return assign_xexpression(e);
+        }
+    }
+
+    template <class D>
+    template <class E, class F>
+    inline auto xchunked_semantic<D>::scalar_computed_assign(const E& e, F&& f) -> derived_type&
+    {
+        for (auto& c : this->derived_cast().chunks())
+        {
+            c.scalar_computed_assign(e, f);
+        }
+        return this->derived_cast();
+    }
+
+    template <class D>
+    template <class E>
+    inline auto xchunked_semantic<D>::operator=(const xexpression<E>& e) -> derived_type&
+    {
+        D& d = this->derived_cast();
+        get_assigner(d.chunks()).build_and_assign_temporary(e, d);
+        return d;
+    }
+
+    template <class D>
+    template <class CS>
+    inline auto xchunked_semantic<D>::get_assigner(const CS&) const -> xchunked_assigner<temporary_type, CS>
+    {
+        return xchunked_assigner<temporary_type, CS>();
+    }
+
+    /**********************************
+     * xchunk_iterator implementation *
+     **********************************/
+
+    template <class E>
+    inline xchunk_iterator<E>::xchunk_iterator(E& expression, shape_type&& chunk_index, size_type chunk_linear_index)
+        : p_chunked_expression(&expression)
+        , m_chunk_index(std::move(chunk_index))
+        , m_chunk_linear_index(chunk_linear_index)
+        , m_slice_vector(m_chunk_index.size())
+    {
+        for (size_type i = 0; i < m_chunk_index.size(); ++i)
+        {
+            fill_slice_vector(i);
+        }
+    }
+
+    template <class E>
+    inline xchunk_iterator<E>& xchunk_iterator<E>::operator++()
+    {
+        if (m_chunk_linear_index + 1u != p_chunked_expression->grid_size())
+        {
+            size_type i = p_chunked_expression->dimension();
+            while (i != 0)
+            {
+                --i;
+                if (m_chunk_index[i] + 1u == p_chunked_expression->grid_shape()[i])
+                {
+                    m_chunk_index[i] = 0;
+                    fill_slice_vector(i);
+                }
+                else
+                {
+                    m_chunk_index[i] += 1;
+                    fill_slice_vector(i);
+                    break;
+                }
+            }
+        }
+        m_chunk_linear_index++;
+        return *this;
+    }
+
+    template <class E>
+    inline xchunk_iterator<E> xchunk_iterator<E>::operator++(int)
+    {
+        xchunk_iterator<E> it = *this;
+        ++(*this);
+        return it;
+    }
+
+    template <class E>
+    inline decltype(auto) xchunk_iterator<E>::operator*() const
+    {
+        return base_type::get_chunk(*p_chunked_expression, m_chunk_linear_index, m_slice_vector);
+    }
+
+    template <class E>
+    inline bool xchunk_iterator<E>::operator==(const xchunk_iterator& other) const
+    {
+        return m_chunk_linear_index == other.m_chunk_linear_index;
+    }
+
+    template <class E>
+    inline bool xchunk_iterator<E>::operator!=(const xchunk_iterator& other) const
+    {
+        return !(*this == other);
+    }
+
+    template <class E>
+    inline auto xchunk_iterator<E>::get_slice_vector() const -> const slice_vector&
+    {
+        return m_slice_vector;
+    }
+
+    template <class E>
+    auto xchunk_iterator<E>::chunk_index() const -> const shape_type&
+    {
+        return m_chunk_index;
+    }
+
+    template <class E>
+    inline auto xchunk_iterator<E>::get_chunk_slice_vector() const -> slice_vector
+    {
+        slice_vector slices(m_chunk_index.size());
+        for (size_type i = 0; i < m_chunk_index.size(); ++i)
+        {
+            size_type chunk_shape = p_chunked_expression->chunk_shape()[i];
+            size_type end = std::min(
+                chunk_shape,
+                p_chunked_expression->shape()[i] - m_chunk_index[i] * chunk_shape
+            );
+            slices[i] = range(0u, end);
+        }
+        return slices;
+    }
+
+    template <class E>
+    inline void xchunk_iterator<E>::fill_slice_vector(size_type i)
+    {
+        size_type range_start = m_chunk_index[i] * p_chunked_expression->chunk_shape()[i];
+        size_type range_end = std::min(
+            (m_chunk_index[i] + 1) * p_chunked_expression->chunk_shape()[i],
+            p_chunked_expression->shape()[i]
+        );
+        m_slice_vector[i] = range(range_start, range_end);
+    }
+}
+
+#endif
diff --git a/include/xtensor/chunk/xchunked_view.hpp b/include/xtensor/chunk/xchunked_view.hpp
new file mode 100644
index 000000000..6c9d0a3f2
--- /dev/null
+++ b/include/xtensor/chunk/xchunked_view.hpp
@@ -0,0 +1,295 @@
+/***************************************************************************
+ * 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_CHUNKED_VIEW_HPP
+#define XTENSOR_CHUNKED_VIEW_HPP
+
+#include <xtl/xsequence.hpp>
+
+#include "../chunk/xchunked_array.hpp"
+#include "../containers/xstorage.hpp"
+#include "../core/xnoalias.hpp"
+#include "../views/xstrided_view.hpp"
+
+namespace xt
+{
+
+    template <class E>
+    struct is_chunked_t : detail::chunk_helper<E>::is_chunked
+    {
+    };
+
+    /*****************
+     * xchunked_view *
+     *****************/
+
+    template <class E>
+    class xchunk_iterator;
+
+    template <class E>
+    class xchunked_view
+    {
+    public:
+
+        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>;
+
+        template <class OE, class S>
+        xchunked_view(OE&& e, S&& chunk_shape);
+
+        template <class OE>
+        xchunked_view(OE&& e);
+
+        void init();
+
+        template <class OE>
+        typename std::enable_if_t<!is_chunked_t<OE>::value, xchunked_view<E>&> operator=(const OE& e);
+
+        template <class OE>
+        typename 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;
+
+    private:
+
+        E m_expression;
+        shape_type m_shape;
+        shape_type m_chunk_shape;
+        shape_type m_grid_shape;
+        size_type m_chunk_nb;
+    };
+
+    template <class E, class S>
+    xchunked_view<E> as_chunked(E&& e, S&& chunk_shape);
+
+    /********************************
+     * xchunked_view implementation *
+     ********************************/
+
+    template <class E>
+    template <class OE, class S>
+    inline xchunked_view<E>::xchunked_view(OE&& e, S&& chunk_shape)
+        : m_expression(std::forward<OE>(e))
+        , m_chunk_shape(xtl::forward_sequence<shape_type, S>(chunk_shape))
+    {
+        m_shape.resize(e.dimension());
+        const auto& s = e.shape();
+        std::copy(s.cbegin(), s.cend(), m_shape.begin());
+        init();
+    }
+
+    template <class E>
+    template <class OE>
+    inline xchunked_view<E>::xchunked_view(OE&& e)
+        : m_expression(std::forward<OE>(e))
+    {
+        m_shape.resize(e.dimension());
+        const auto& s = e.shape();
+        std::copy(s.cbegin(), s.cend(), m_shape.begin());
+    }
+
+    template <class E>
+    void xchunked_view<E>::init()
+    {
+        // compute chunk number in each dimension
+        m_grid_shape.resize(m_shape.size());
+        std::transform(
+            m_shape.cbegin(),
+            m_shape.cend(),
+            m_chunk_shape.cbegin(),
+            m_grid_shape.begin(),
+            [](auto s, auto cs)
+            {
+                std::size_t cn = s / cs;
+                if (s % cs > 0)
+                {
+                    cn++;  // edge_chunk
+                }
+                return cn;
+            }
+        );
+        m_chunk_nb = std::accumulate(
+            std::begin(m_grid_shape),
+            std::end(m_grid_shape),
+            std::size_t(1),
+            std::multiplies<>()
+        );
+    }
+
+    template <class E>
+    template <class OE>
+    typename std::enable_if_t<!is_chunked_t<OE>::value, xchunked_view<E>&>
+    xchunked_view<E>::operator=(const OE& e)
+    {
+        auto end = chunk_end();
+        for (auto it = chunk_begin(); it != end; ++it)
+        {
+            auto el = *it;
+            noalias(el) = strided_view(e, it.get_slice_vector());
+        }
+        return *this;
+    }
+
+    template <class E>
+    template <class OE>
+    typename std::enable_if_t<is_chunked_t<OE>::value, xchunked_view<E>&>
+    xchunked_view<E>::operator=(const OE& e)
+    {
+        m_chunk_shape.resize(e.dimension());
+        const auto& cs = e.chunk_shape();
+        std::copy(cs.cbegin(), cs.cend(), m_chunk_shape.begin());
+        init();
+        auto it2 = e.chunks().begin();
+        auto end1 = chunk_end();
+        for (auto it1 = chunk_begin(); it1 != end1; ++it1, ++it2)
+        {
+            auto el1 = *it1;
+            auto el2 = *it2;
+            auto lhs_shape = el1.shape();
+            if (lhs_shape != el2.shape())
+            {
+                xstrided_slice_vector esv(el2.dimension());  // element slice in edge chunk
+                std::transform(
+                    lhs_shape.begin(),
+                    lhs_shape.end(),
+                    esv.begin(),
+                    [](auto size)
+                    {
+                        return range(0, size);
+                    }
+                );
+                noalias(el1) = strided_view(el2, esv);
+            }
+            else
+            {
+                noalias(el1) = el2;
+            }
+        }
+        return *this;
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::dimension() const noexcept -> size_type
+    {
+        return m_shape.size();
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::shape() const noexcept -> const shape_type&
+    {
+        return m_shape;
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::chunk_shape() const noexcept -> const shape_type&
+    {
+        return m_chunk_shape;
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::grid_size() const noexcept -> size_type
+    {
+        return m_chunk_nb;
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::grid_shape() const noexcept -> const shape_type&
+    {
+        return m_grid_shape;
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::expression() noexcept -> expression_type&
+    {
+        return m_expression;
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::expression() const noexcept -> const expression_type&
+    {
+        return m_expression;
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::chunk_begin() -> chunk_iterator
+    {
+        shape_type chunk_index(m_shape.size(), size_type(0));
+        return chunk_iterator(*this, std::move(chunk_index), 0u);
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::chunk_end() -> chunk_iterator
+    {
+        return chunk_iterator(*this, shape_type(grid_shape()), grid_size());
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::chunk_begin() const -> const_chunk_iterator
+    {
+        shape_type chunk_index(m_shape.size(), size_type(0));
+        return const_chunk_iterator(*this, std::move(chunk_index), 0u);
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::chunk_end() const -> const_chunk_iterator
+    {
+        return const_chunk_iterator(*this, shape_type(grid_shape()), grid_size());
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::chunk_cbegin() const -> const_chunk_iterator
+    {
+        return chunk_begin();
+    }
+
+    template <class E>
+    inline auto xchunked_view<E>::chunk_cend() const -> const_chunk_iterator
+    {
+        return chunk_end();
+    }
+
+    template <class E, class S>
+    inline xchunked_view<E> as_chunked(E&& e, S&& chunk_shape)
+    {
+        return xchunked_view<E>(std::forward<E>(e), std::forward<S>(chunk_shape));
+    }
+
+    template <class E>
+    inline xchunked_view<E> as_chunked(E&& e)
+    {
+        return xchunked_view<E>(std::forward<E>(e));
+    }
+}
+
+#endif
diff --git a/include/xtensor/containers/xadapt.hpp b/include/xtensor/containers/xadapt.hpp
new file mode 100644
index 000000000..725a75d42
--- /dev/null
+++ b/include/xtensor/containers/xadapt.hpp
@@ -0,0 +1,921 @@
+/***************************************************************************
+ * 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_ADAPT_HPP
+#define XTENSOR_ADAPT_HPP
+
+#include <array>
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+
+#include <xtl/xsequence.hpp>
+
+#include "../containers/xarray.hpp"
+#include "../containers/xbuffer_adaptor.hpp"
+#include "../containers/xfixed.hpp"
+#include "../containers/xtensor.hpp"
+
+namespace xt
+{
+    /**
+     * @defgroup xt_xadapt Adaptors of STL-like containers
+     */
+
+    namespace detail
+    {
+        template <class>
+        struct array_size_impl;
+
+        template <class T, std::size_t N>
+        struct array_size_impl<std::array<T, N>>
+        {
+            static constexpr std::size_t value = N;
+        };
+
+        template <class C>
+        using array_size = array_size_impl<std::decay_t<C>>;
+
+        template <class P>
+        struct default_allocator_for_ptr
+        {
+            using type = std::allocator<std::remove_const_t<std::remove_pointer_t<std::remove_reference_t<P>>>>;
+        };
+
+        template <class P>
+        using default_allocator_for_ptr_t = typename default_allocator_for_ptr<P>::type;
+
+        template <class T>
+        using not_an_array = std::negation<is_array<T>>;
+
+        template <class T>
+        using not_a_pointer = std::negation<std::is_pointer<T>>;
+
+        template <class T>
+        using not_a_layout = std::negation<std::is_same<layout_type, T>>;
+    }
+
+#ifndef IN_DOXYGEN
+
+    /**************************
+     * xarray_adaptor builder *
+     **************************/
+
+    /**
+     * Constructs an xarray_adaptor of the given stl-like container,
+     * with the specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container to adapt
+     * @param shape the shape of the xarray_adaptor
+     * @param l the layout_type of the xarray_adaptor
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class C,
+        class SC,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>, detail::not_a_pointer<C>)>
+    inline xarray_adaptor<xtl::closure_type_t<C>, L, std::decay_t<SC>>
+    adapt(C&& container, const SC& shape, layout_type l = L)
+    {
+        static_assert(!xtl::is_integral<SC>::value, "shape cannot be a integer");
+        using return_type = xarray_adaptor<xtl::closure_type_t<C>, L, std::decay_t<SC>>;
+        return return_type(std::forward<C>(container), shape, l);
+    }
+
+    /**
+     * Constructs an non-owning xarray_adaptor from a pointer with the specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the container to adapt
+     * @param shape the shape of the xarray_adaptor
+     * @param l the layout_type of the xarray_adaptor
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class C,
+        class SC,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>, std::is_pointer<std::remove_reference_t<C>>)>
+    inline auto adapt(C&& pointer, const SC& shape, layout_type l = L)
+    {
+        static_assert(!xtl::is_integral<SC>::value, "shape cannot be a integer");
+        using buffer_type = xbuffer_adaptor<C, xt::no_ownership, detail::default_allocator_for_ptr_t<C>>;
+        using return_type = xarray_adaptor<buffer_type, L, std::decay_t<SC>>;
+        std::size_t size = compute_size(shape);
+        return return_type(buffer_type(pointer, size), shape, l);
+    }
+
+    /**
+     * Constructs an xarray_adaptor of the given stl-like container,
+     * with the specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container to adapt
+     * @param shape the shape of the xarray_adaptor
+     * @param strides the strides of the xarray_adaptor
+     */
+    template <
+        class C,
+        class SC,
+        class SS,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>, detail::not_a_layout<std::decay_t<SS>>)>
+    inline xarray_adaptor<xtl::closure_type_t<C>, layout_type::dynamic, std::decay_t<SC>>
+    adapt(C&& container, SC&& shape, SS&& strides)
+    {
+        static_assert(!xtl::is_integral<std::decay_t<SC>>::value, "shape cannot be a integer");
+        using return_type = xarray_adaptor<xtl::closure_type_t<C>, layout_type::dynamic, std::decay_t<SC>>;
+        return return_type(
+            std::forward<C>(container),
+            xtl::forward_sequence<typename return_type::inner_shape_type, SC>(shape),
+            xtl::forward_sequence<typename return_type::inner_strides_type, SS>(strides)
+        );
+    }
+
+    /**
+     * Constructs an xarray_adaptor of the given dynamically allocated C array,
+     * with the specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param shape the shape of the xarray_adaptor
+     * @param l the layout_type of the xarray_adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class P,
+        class O,
+        class SC,
+        class A = detail::default_allocator_for_ptr_t<P>,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>)>
+    inline xarray_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, L, SC> adapt(
+        P&& pointer,
+        typename A::size_type size,
+        O ownership,
+        const SC& shape,
+        layout_type l = L,
+        const A& alloc = A()
+    )
+    {
+        static_assert(!xtl::is_integral<SC>::value, "shape cannot be a integer");
+        (void) ownership;
+        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
+        using return_type = xarray_adaptor<buffer_type, L, SC>;
+        buffer_type buf(std::forward<P>(pointer), size, alloc);
+        return return_type(std::move(buf), shape, l);
+    }
+
+    /**
+     * Constructs an xarray_adaptor of the given dynamically allocated C array,
+     * with the specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param shape the shape of the xarray_adaptor
+     * @param strides the strides of the xarray_adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <
+        class P,
+        class O,
+        class SC,
+        class SS,
+        class A = detail::default_allocator_for_ptr_t<P>,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>, detail::not_a_layout<std::decay_t<SS>>)>
+    inline xarray_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, layout_type::dynamic, std::decay_t<SC>>
+    adapt(P&& pointer, typename A::size_type size, O ownership, SC&& shape, SS&& strides, const A& alloc = A())
+    {
+        static_assert(!xtl::is_integral<std::decay_t<SC>>::value, "shape cannot be a integer");
+        (void) ownership;
+        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
+        using return_type = xarray_adaptor<buffer_type, layout_type::dynamic, std::decay_t<SC>>;
+        buffer_type buf(std::forward<P>(pointer), size, alloc);
+        return return_type(
+            std::move(buf),
+            xtl::forward_sequence<typename return_type::inner_shape_type, SC>(shape),
+            xtl::forward_sequence<typename return_type::inner_strides_type, SS>(strides)
+        );
+    }
+
+    /**
+     * Constructs an xarray_adaptor of the given C array allocated on the stack, with the
+     * specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param c_array the C array allocated on the stack
+     * @param shape the shape of the xarray_adaptor
+     * @param l the layout_type of the xarray_adaptor
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class T,
+        std::size_t N,
+        class SC,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>)>
+    inline auto adapt(T (&c_array)[N], const SC& shape, layout_type l = L)
+    {
+        return adapt(&c_array[0], N, xt::no_ownership(), shape, l);
+    }
+
+    /**
+     * Constructs an xarray_adaptor of the given C array allocated on the stack, with the
+     * specified shape and stirdes.
+     *
+     * @ingroup xt_xadapt
+     * @param c_array the C array allocated on the stack
+     * @param shape the shape of the xarray_adaptor
+     * @param strides the strides of the xarray_adaptor
+     */
+    template <
+        class T,
+        std::size_t N,
+        class SC,
+        class SS,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>, detail::not_a_layout<std::decay_t<SS>>)>
+    inline auto adapt(T (&c_array)[N], SC&& shape, SS&& strides)
+    {
+        return adapt(&c_array[0], N, xt::no_ownership(), std::forward<SC>(shape), std::forward<SS>(strides));
+    }
+
+    /***************************
+     * xtensor_adaptor builder *
+     ***************************/
+
+    /**
+     * Constructs a 1-D xtensor_adaptor of the given stl-like container,
+     * with the specified layout_type.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container to adapt
+     * @param l the layout_type of the xtensor_adaptor
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C>
+    inline xtensor_adaptor<C, 1, L> adapt(C&& container, layout_type l = L)
+    {
+        const std::array<typename std::decay_t<C>::size_type, 1> shape{container.size()};
+        using return_type = xtensor_adaptor<xtl::closure_type_t<C>, 1, L>;
+        return return_type(std::forward<C>(container), shape, l);
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given stl-like container,
+     * with the specified shape and layout_type.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container to adapt
+     * @param shape the shape of the xtensor_adaptor
+     * @param l the layout_type of the xtensor_adaptor
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class C,
+        class SC,
+        XTL_REQUIRES(detail::is_array<std::decay_t<SC>>, detail::not_a_pointer<C>)>
+    inline xtensor_adaptor<C, detail::array_size<SC>::value, L>
+    adapt(C&& container, const SC& shape, layout_type l = L)
+    {
+        static_assert(!xtl::is_integral<SC>::value, "shape cannot be a integer");
+        constexpr std::size_t N = detail::array_size<SC>::value;
+        using return_type = xtensor_adaptor<xtl::closure_type_t<C>, N, L>;
+        return return_type(std::forward<C>(container), shape, l);
+    }
+
+    /**
+     * Constructs an non-owning xtensor_adaptor from a pointer with the specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to adapt
+     * @param shape the shape of the xtensor_adaptor
+     * @param l the layout_type of the xtensor_adaptor
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class C,
+        class SC,
+        XTL_REQUIRES(detail::is_array<std::decay_t<SC>>, std::is_pointer<std::remove_reference_t<C>>)>
+    inline auto adapt(C&& pointer, const SC& shape, layout_type l = L)
+    {
+        static_assert(!xtl::is_integral<SC>::value, "shape cannot be a integer");
+        using buffer_type = xbuffer_adaptor<C, xt::no_ownership, detail::default_allocator_for_ptr_t<C>>;
+        constexpr std::size_t N = detail::array_size<SC>::value;
+        using return_type = xtensor_adaptor<buffer_type, N, L>;
+        return return_type(buffer_type(pointer, compute_size(shape)), shape, l);
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given stl-like container,
+     * with the specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container to adapt
+     * @param shape the shape of the xtensor_adaptor
+     * @param strides the strides of the xtensor_adaptor
+     */
+    template <
+        class C,
+        class SC,
+        class SS,
+        XTL_REQUIRES(detail::is_array<std::decay_t<SC>>, detail::not_a_layout<std::decay_t<SS>>)>
+    inline xtensor_adaptor<C, detail::array_size<SC>::value, layout_type::dynamic>
+    adapt(C&& container, SC&& shape, SS&& strides)
+    {
+        static_assert(!xtl::is_integral<std::decay_t<SC>>::value, "shape cannot be a integer");
+        constexpr std::size_t N = detail::array_size<SC>::value;
+        using return_type = xtensor_adaptor<xtl::closure_type_t<C>, N, layout_type::dynamic>;
+        return return_type(
+            std::forward<C>(container),
+            xtl::forward_sequence<typename return_type::inner_shape_type, SC>(shape),
+            xtl::forward_sequence<typename return_type::inner_strides_type, SS>(strides)
+        );
+    }
+
+    /**
+     * Constructs a 1-D xtensor_adaptor of the given dynamically allocated C array,
+     * with the specified layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param l the layout_type of the xtensor_adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class O, class A = detail::default_allocator_for_ptr_t<P>>
+    inline xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, 1, L>
+    adapt(P&& pointer, typename A::size_type size, O ownership, layout_type l = L, const A& alloc = A())
+    {
+        (void) ownership;
+        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
+        using return_type = xtensor_adaptor<buffer_type, 1, L>;
+        buffer_type buf(std::forward<P>(pointer), size, alloc);
+        const std::array<typename A::size_type, 1> shape{size};
+        return return_type(std::move(buf), shape, l);
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given dynamically allocated C array,
+     * with the specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param shape the shape of the xtensor_adaptor
+     * @param l the layout_type of the xtensor_adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class P,
+        class O,
+        class SC,
+        class A = detail::default_allocator_for_ptr_t<P>,
+        XTL_REQUIRES(detail::is_array<std::decay_t<SC>>)>
+    inline xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, detail::array_size<SC>::value, L>
+    adapt(
+        P&& pointer,
+        typename A::size_type size,
+        O ownership,
+        const SC& shape,
+        layout_type l = L,
+        const A& alloc = A()
+    )
+    {
+        static_assert(!xtl::is_integral<SC>::value, "shape cannot be a integer");
+        (void) ownership;
+        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
+        constexpr std::size_t N = detail::array_size<SC>::value;
+        using return_type = xtensor_adaptor<buffer_type, N, L>;
+        buffer_type buf(std::forward<P>(pointer), size, alloc);
+        return return_type(std::move(buf), shape, l);
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given dynamically allocated C array,
+     * with the specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param shape the shape of the xtensor_adaptor
+     * @param strides the strides of the xtensor_adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <
+        class P,
+        class O,
+        class SC,
+        class SS,
+        class A = detail::default_allocator_for_ptr_t<P>,
+        XTL_REQUIRES(detail::is_array<std::decay_t<SC>>, detail::not_a_layout<std::decay_t<SS>>)>
+    inline xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, detail::array_size<SC>::value, layout_type::dynamic>
+    adapt(P&& pointer, typename A::size_type size, O ownership, SC&& shape, SS&& strides, const A& alloc = A())
+    {
+        static_assert(!xtl::is_integral<std::decay_t<SC>>::value, "shape cannot be a integer");
+        (void) ownership;
+        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
+        constexpr std::size_t N = detail::array_size<SC>::value;
+        using return_type = xtensor_adaptor<buffer_type, N, layout_type::dynamic>;
+        buffer_type buf(std::forward<P>(pointer), size, alloc);
+        return return_type(
+            std::move(buf),
+            xtl::forward_sequence<typename return_type::inner_shape_type, SC>(shape),
+            xtl::forward_sequence<typename return_type::inner_strides_type, SS>(strides)
+        );
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given C array allocated on the stack, with the
+     * specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param c_array the C array allocated on the stack
+     * @param shape the shape of the xarray_adaptor
+     * @param l the layout_type of the xarray_adaptor
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class T,
+        std::size_t N,
+        class SC,
+        XTL_REQUIRES(detail::is_array<std::decay_t<SC>>)>
+    inline auto adapt(T (&c_array)[N], const SC& shape, layout_type l = L)
+    {
+        return adapt(&c_array[0], N, xt::no_ownership(), shape, l);
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given C array allocated on the stack, with the
+     * specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param c_array the C array allocated on the stack
+     * @param shape the shape of the xarray_adaptor
+     * @param strides the strides of the xarray_adaptor
+     */
+    template <
+        class T,
+        std::size_t N,
+        class SC,
+        class SS,
+        XTL_REQUIRES(detail::is_array<std::decay_t<SC>>, detail::not_a_layout<std::decay_t<SS>>)>
+    inline auto adapt(T (&c_array)[N], SC&& shape, SS&& strides)
+    {
+        return adapt(&c_array[0], N, xt::no_ownership(), std::forward<SC>(shape), std::forward<SS>(strides));
+    }
+
+    /**
+     * Constructs an non-owning xtensor_fixed_adaptor from a pointer with the
+     * specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to adapt
+     * @param shape the shape of the xtensor_fixed_adaptor
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class C,
+        std::size_t... X,
+        XTL_REQUIRES(std::is_pointer<std::remove_reference_t<C>>)>
+    inline auto adapt(C&& pointer, const fixed_shape<X...>& /*shape*/)
+    {
+        using buffer_type = xbuffer_adaptor<C, xt::no_ownership, detail::default_allocator_for_ptr_t<C>>;
+        using return_type = xfixed_adaptor<buffer_type, fixed_shape<X...>, L>;
+        return return_type(buffer_type(pointer, detail::fixed_compute_size<fixed_shape<X...>>::value));
+    }
+
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class T, std::size_t N>
+    inline auto adapt(C&& ptr, const T (&shape)[N])
+    {
+        using shape_type = std::array<std::size_t, N>;
+        return adapt(std::forward<C>(ptr), xtl::forward_sequence<shape_type, decltype(shape)>(shape));
+    }
+
+#else  // IN_DOXYGEN
+
+    /**
+     * Constructs:
+     * - an xarray_adaptor if SC is not an array type
+     * - an xtensor_adaptor if SC is an array type
+     *
+     * from the given stl-like container or pointer, with the specified shape and layout.
+     * If the adaptor is built from a pointer, it does not take its ownership.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container or pointer to adapt
+     * @param shape the shape of the adaptor
+     * @param l the layout_type of the adaptor
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class SC>
+    inline auto adapt(C&& container, const SC& shape, layout_type l = L);
+
+    /**
+     * Constructs:
+     * - an xarray_adaptor if SC is not an array type
+     * - an xtensor_adaptor if SC is an array type
+     *
+     * from the given stl-like container with the specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container to adapt
+     * @param shape the shape of the adaptor
+     * @param strides the strides of the adaptor
+     */
+    template <class C, class SC, class SS>
+    inline auto adapt(C&& container, SC&& shape, SS&& strides);
+
+    /**
+     * Constructs:
+     * - an xarray_adaptor if SC is not an array type
+     * - an xtensor_adaptor if SC is an array type
+     *
+     * of the given dynamically allocated C array, with the specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param shape the shape of the adaptor
+     * @param l the layout_type of the adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class O, class SC, class A = detail::default_allocator_for_ptr_t<P>>
+    inline auto adapt(
+        P&& pointer,
+        typename A::size_type size,
+        O ownership,
+        const SC& shape,
+        layout_type l = L,
+        const A& alloc = A()
+    );
+
+    /**
+     * Constructs:
+     * - an xarray_adaptor if SC is not an array type
+     * - an xtensor_adaptor if SC is an array type
+     *
+     * of the given dynamically allocated C array, with the specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param shape the shape of the adaptor
+     * @param strides the strides of the adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <class P, class O, class SC, class SS, class A = detail::default_allocator_for_ptr_t<P>>
+    inline auto
+    adapt(P&& pointer, typename A::size_type size, O ownership, SC&& shape, SS&& strides, const A& alloc = A());
+
+    /**
+     * Constructs:
+     * - an xarray_adaptor if SC is not an array type
+     * - an xtensor_adaptor if SC is an array type
+     *
+     * of the given C array allocated on the stack, with the specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param c_array the C array allocated on the stack
+     * @param shape the shape of the adaptor
+     * @param l the layout_type of the adaptor
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class T, std::size_t N, class SC>
+    inline auto adapt(T (&c_array)[N], const SC& shape, layout_type l = L);
+
+    /**
+     * Constructs:
+     * - an xarray_adaptor if SC is not an array type
+     * - an xtensor_adaptor if SC is an array type
+     *
+     * of the given C array allocated on the stack, with the
+     * specified shape and strides.
+     *
+     * @ingroup xt_xadapt
+     * @param c_array the C array allocated on the stack
+     * @param shape the shape of the adaptor
+     * @param strides the strides of the adaptor
+     */
+    template <class T, std::size_t N, class SC, class SS>
+    inline auto adapt(T (&c_array)[N], SC&& shape, SS&& strides);
+
+    /**
+     * Constructs an non-owning xtensor_fixed_adaptor from a pointer with the
+     * specified shape and layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to adapt
+     * @param shape the shape of the xtensor_fixed_adaptor
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, std::size_t... X>
+    inline auto adapt(C&& pointer, const fixed_shape<X...>& /*shape*/);
+
+    /**
+     * Constructs a 1-D xtensor_adaptor of the given stl-like container,
+     * with the specified layout_type.
+     *
+     * @ingroup xt_xadapt
+     * @param container the container to adapt
+     * @param l the layout_type of the xtensor_adaptor
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C>
+    inline xtensor_adaptor<C, 1, L> adapt(C&& container, layout_type l = L);
+
+    /**
+     * Constructs a 1-D xtensor_adaptor of the given dynamically allocated C array,
+     * with the specified layout.
+     *
+     * @ingroup xt_xadapt
+     * @param pointer the pointer to the beginning of the dynamic array
+     * @param size the size of the dynamic array
+     * @param ownership indicates whether the adaptor takes ownership of the array.
+     *        Possible values are ``no_ownership()`` or ``acquire_ownership()``
+     * @param l the layout_type of the xtensor_adaptor
+     * @param alloc the allocator used for allocating / deallocating the dynamic array
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class O, class A = detail::default_allocator_for_ptr_t<P>>
+    inline xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, 1, L>
+    adapt(P&& pointer, typename A::size_type size, O ownership, layout_type l = L, const A& alloc = A());
+
+#endif  // IN_DOXYGEN
+
+    /*****************************
+     * smart_ptr adapter builder *
+     *****************************/
+
+    /**
+     * Adapt a smart pointer to a typed memory block (unique_ptr or shared_ptr)
+     *
+     * @code{.cpp}
+     * #include <xtensor/xadapt.hpp>
+     * #include <xtensor/xio.hpp>
+     *
+     * std::shared_ptr<double> sptr(new double[8], std::default_delete<double[]>());
+     * sptr.get()[2] = 321.;
+     * std::vector<size_t> shape = {4, 2};
+     * auto xptr = adapt_smart_ptr(sptr, shape);
+     * xptr(1, 3) = 123.;
+     * std::cout << xptr;
+     * @endcode
+     *
+     * @ingroup xt_xadapt
+     * @param smart_ptr a smart pointer to a memory block of T[]
+     * @param shape The desired shape
+     * @param l The desired memory layout
+     *
+     * @return xarray_adaptor for memory
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class SC, XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>)>
+    auto adapt_smart_ptr(P&& smart_ptr, const SC& shape, layout_type l = L)
+    {
+        using buffer_adaptor = xbuffer_adaptor<decltype(smart_ptr.get()), smart_ownership, std::decay_t<P>>;
+        return xarray_adaptor<buffer_adaptor, L, std::decay_t<SC>>(
+            buffer_adaptor(smart_ptr.get(), compute_size(shape), std::forward<P>(smart_ptr)),
+            shape,
+            l
+        );
+    }
+
+    /**
+     * Adapt a smart pointer (shared_ptr or unique_ptr)
+     *
+     * This function allows to automatically adapt a shared or unique pointer to
+     * a given shape and operate naturally on it. Memory will be automatically
+     * handled by the smart pointer implementation.
+     *
+     * @code{.cpp}
+     * #include <xtensor/xadapt.hpp>
+     * #include <xtensor/xio.hpp>
+     *
+     * struct Buffer {
+     *     Buffer(std::vector<double>& buf) : m_buf(buf) {}
+     *     ~Buffer() { std::cout << "deleted" << std::endl; }
+     *     std::vector<double> m_buf;
+     * };
+     *
+     * auto data = std::vector<double>{1,2,3,4,5,6,7,8};
+     * auto shared_buf = std::make_shared<Buffer>(data);
+     * auto unique_buf = std::make_unique<Buffer>(data);
+     *
+     * std::cout << shared_buf.use_count() << std::endl;
+     * {
+     *     std::vector<size_t> shape = {2, 4};
+     *     auto obj = adapt_smart_ptr(shared_buf.get()->m_buf.data(),
+     *                                shape, 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;
+     *
+     * {
+     *     std::vector<size_t> shape = {2, 4};
+     *     auto obj = adapt_smart_ptr(unique_buf.get()->m_buf.data(),
+     *                                shape, std::move(unique_buf));
+     *     std::cout << obj << std::endl;
+     * }
+     * @endcode
+     *
+     * @ingroup xt_xadapt
+     * @param data_ptr A pointer to a typed data block (e.g. double*)
+     * @param shape The desired shape
+     * @param smart_ptr A smart pointer to move or copy, in order to manage memory
+     * @param l The desired memory layout
+     *
+     * @return xarray_adaptor on the memory
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class P,
+        class SC,
+        class D,
+        XTL_REQUIRES(detail::not_an_array<std::decay_t<SC>>, detail::not_a_layout<std::decay_t<D>>)>
+    auto adapt_smart_ptr(P&& data_ptr, const SC& shape, D&& smart_ptr, layout_type l = L)
+    {
+        using buffer_adaptor = xbuffer_adaptor<P, smart_ownership, std::decay_t<D>>;
+
+        return xarray_adaptor<buffer_adaptor, L, std::decay_t<SC>>(
+            buffer_adaptor(data_ptr, compute_size(shape), std::forward<D>(smart_ptr)),
+            shape,
+            l
+        );
+    }
+
+    /**
+     * Adapt a smart pointer to a typed memory block (unique_ptr or shared_ptr)
+     *
+     * @code{.cpp}
+     * #include <xtensor/xadapt.hpp>
+     * #include <xtensor/xio.hpp>
+     *
+     * std::shared_ptr<double> sptr(new double[8], std::default_delete<double[]>());
+     * sptr.get()[2] = 321.;
+     * auto xptr = adapt_smart_ptr(sptr, {4, 2});
+     * xptr(1, 3) = 123.;
+     * std::cout << xptr;
+     * @endcode
+     *
+     * @ingroup xt_xadapt
+     * @param smart_ptr a smart pointer to a memory block of T[]
+     * @param shape The desired shape
+     * @param l The desired memory layout
+     *
+     * @return xtensor_adaptor for memory
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class I, std::size_t N>
+    auto adapt_smart_ptr(P&& smart_ptr, const I (&shape)[N], layout_type l = L)
+    {
+        using buffer_adaptor = xbuffer_adaptor<decltype(smart_ptr.get()), smart_ownership, std::decay_t<P>>;
+        std::array<std::size_t, N> fshape = xtl::forward_sequence<std::array<std::size_t, N>, decltype(shape)>(
+            shape
+        );
+        return xtensor_adaptor<buffer_adaptor, N, L>(
+            buffer_adaptor(smart_ptr.get(), compute_size(fshape), std::forward<P>(smart_ptr)),
+            std::move(fshape),
+            l
+        );
+    }
+
+    /**
+     * Adapt a smart pointer (shared_ptr or unique_ptr)
+     *
+     * This function allows to automatically adapt a shared or unique pointer to
+     * a given shape and operate naturally on it. Memory will be automatically
+     * handled by the smart pointer implementation.
+     *
+     * @code{.cpp}
+     * #include <xtensor/xadapt.hpp>
+     * #include <xtensor/xio.hpp>
+     *
+     * struct Buffer {
+     *     Buffer(std::vector<double>& buf) : m_buf(buf) {}
+     *     ~Buffer() { std::cout << "deleted" << std::endl; }
+     *     std::vector<double> m_buf;
+     * };
+     *
+     * auto data = std::vector<double>{1,2,3,4,5,6,7,8};
+     * auto shared_buf = std::make_shared<Buffer>(data);
+     * auto unique_buf = std::make_unique<Buffer>(data);
+     *
+     * std::cout << shared_buf.use_count() << std::endl;
+     * {
+     *     auto obj = 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 = adapt_smart_ptr(unique_buf.get()->m_buf.data(),
+     *                                {2, 4}, std::move(unique_buf));
+     *     std::cout << obj << std::endl;
+     * }
+     * @endcode
+     *
+     * @ingroup xt_xadapt
+     * @param data_ptr A pointer to a typed data block (e.g. double*)
+     * @param shape The desired shape
+     * @param smart_ptr A smart pointer to move or copy, in order to manage memory
+     * @param l The desired memory layout
+     *
+     * @return xtensor_adaptor on the memory
+     */
+    template <
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class P,
+        class I,
+        std::size_t N,
+        class D,
+        XTL_REQUIRES(detail::not_a_layout<std::decay_t<D>>)>
+    auto adapt_smart_ptr(P&& data_ptr, const I (&shape)[N], D&& smart_ptr, layout_type l = L)
+    {
+        using buffer_adaptor = xbuffer_adaptor<P, smart_ownership, std::decay_t<D>>;
+        std::array<std::size_t, N> fshape = xtl::forward_sequence<std::array<std::size_t, N>, decltype(shape)>(
+            shape
+        );
+
+        return xtensor_adaptor<buffer_adaptor, N, L>(
+            buffer_adaptor(data_ptr, compute_size(fshape), std::forward<D>(smart_ptr)),
+            std::move(fshape),
+            l
+        );
+    }
+
+    /**
+     * @brief xtensor adaptor for a pointer.
+     *
+     * Construct for example with:
+     *
+     * @code{.cpp}
+     * #include <xtensor/xadapt.hpp>
+     *
+     * std::array<size_t, 2> shape = {2, 2};
+     * std::vector<double> data = {1, 2, 3, 4};
+     *
+     * xt::xtensor_pointer<double, 2> a = xt::adapt(data.data(), 4, xt::no_ownership(), shape);
+     * @endcode
+     *
+     * @ingroup xt_xadapt
+     * @tparam T The data type (e.g. ``double``).
+     * @tparam N The number of dimensions.
+     * @tparam L The xt::layout_type() of the xtensor.
+     */
+    template <class T, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT>
+    using xtensor_pointer = xtensor_adaptor<
+        xbuffer_adaptor<xtl::closure_type_t<T*>, xt::no_ownership, detail::default_allocator_for_ptr_t<T>>,
+        N,
+        L>;
+
+    /**
+     * @brief xarray adaptor for a pointer.
+     *
+     * Construct for example with:
+     *
+     * @code{.cpp}
+     * #include <xtensor/xadapt.hpp>
+     *
+     * std::vector<int> data(4, 0);
+     * xt::svector<size_t> shape({2, 2});
+     *
+     * xt::xarray_pointer<int> a = xt::adapt(data.data(), data.size(), xt::no_ownership(), shape);
+     * @endcode
+     *
+     * @ingroup xt_xadapt
+     * @tparam T The data type (e.g. ``double``).
+     * @tparam L The xt::layout_type() of the xarray.
+     * @tparam SC The shape container type (e.g. ``xt::svector<size_t>``). Default matches
+     *      xt::adapt(P&&, typename A::size_type, O, const SC&, layout_type, const A& alloc)
+     */
+    template <
+        class T,
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class SC = XTENSOR_DEFAULT_SHAPE_CONTAINER(T, std::allocator<std::size_t>, std::allocator<std::size_t>)>
+    using xarray_pointer = xarray_adaptor<
+        xbuffer_adaptor<xtl::closure_type_t<T*>, xt::no_ownership, detail::default_allocator_for_ptr_t<T>>,
+        L,
+        SC>;
+}
+
+#endif
diff --git a/include/xtensor/xarray.hpp b/include/xtensor/containers/xarray.hpp
similarity index 81%
rename from include/xtensor/xarray.hpp
rename to include/xtensor/containers/xarray.hpp
index fb46d2d1a..7f27bd296 100644
--- a/include/xtensor/xarray.hpp
+++ b/include/xtensor/containers/xarray.hpp
@@ -1,23 +1,23 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ARRAY_HPP
 #define XTENSOR_ARRAY_HPP
 
 #include <algorithm>
-#include <initializer_list>
 #include <utility>
 
 #include <xtl/xsequence.hpp>
 
-#include "xbuffer_adaptor.hpp"
-#include "xcontainer.hpp"
-#include "xsemantic.hpp"
+#include "../containers/xbuffer_adaptor.hpp"
+#include "../containers/xcontainer.hpp"
+#include "../core/xsemantic.hpp"
 
 namespace xt
 {
@@ -45,6 +45,9 @@ namespace xt
     struct xcontainer_inner_types<xarray_container<EC, L, SC, Tag>>
     {
         using storage_type = EC;
+        using reference = inner_reference_t<storage_type>;
+        using const_reference = typename storage_type::const_reference;
+        using size_type = typename storage_type::size_type;
         using shape_type = SC;
         using strides_type = get_strides_t<shape_type>;
         using backstrides_type = get_strides_t<shape_type>;
@@ -72,7 +75,7 @@ namespace xt
      * @tparam L The layout_type of the container.
      * @tparam SC The type of the containers holding the shape and the strides.
      * @tparam Tag The expression tag.
-     * @sa xarray
+     * @sa xarray, xstrided_container, xcontainer
      */
     template <class EC, layout_type L, class SC, class Tag>
     class xarray_container : public xstrided_container<xarray_container<EC, L, SC, Tag>>,
@@ -100,6 +103,7 @@ namespace xt
         using inner_backstrides_type = typename base_type::inner_backstrides_type;
         using temporary_type = typename semantic_base::temporary_type;
         using expression_tag = Tag;
+        static constexpr std::size_t rank = SIZE_MAX;
 
         xarray_container();
         explicit xarray_container(const shape_type& shape, layout_type l = L);
@@ -151,10 +155,28 @@ namespace xt
      * xarray_adaptor declaration *
      ******************************/
 
+    namespace extension
+    {
+        template <class EC, layout_type L, class SC, class Tag>
+        struct xarray_adaptor_base;
+
+        template <class EC, layout_type L, class SC>
+        struct xarray_adaptor_base<EC, L, SC, xtensor_expression_tag>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class EC, layout_type L, class SC, class Tag>
+        using xarray_adaptor_base_t = typename xarray_adaptor_base<EC, L, SC, Tag>::type;
+    }
+
     template <class EC, layout_type L, class SC, class Tag>
     struct xcontainer_inner_types<xarray_adaptor<EC, L, SC, Tag>>
     {
         using storage_type = std::remove_reference_t<EC>;
+        using reference = inner_reference_t<storage_type>;
+        using const_reference = typename storage_type::const_reference;
+        using size_type = typename storage_type::size_type;
         using shape_type = SC;
         using strides_type = get_strides_t<shape_type>;
         using backstrides_type = get_strides_t<shape_type>;
@@ -185,10 +207,12 @@ namespace xt
      * @tparam L The layout_type of the adaptor.
      * @tparam SC The type of the containers holding the shape and the strides.
      * @tparam Tag The expression tag.
+     * @sa xstrided_container, xcontainer
      */
     template <class EC, layout_type L, class SC, class Tag>
     class xarray_adaptor : public xstrided_container<xarray_adaptor<EC, L, SC, Tag>>,
-                           public xcontainer_semantic<xarray_adaptor<EC, L, SC, Tag>>
+                           public xcontainer_semantic<xarray_adaptor<EC, L, SC, Tag>>,
+                           public extension::xarray_adaptor_base_t<EC, L, SC, Tag>
     {
     public:
 
@@ -197,6 +221,7 @@ namespace xt
         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;
@@ -204,6 +229,7 @@ namespace xt
         using backstrides_type = typename base_type::backstrides_type;
         using temporary_type = typename semantic_base::temporary_type;
         using expression_tag = Tag;
+        static constexpr std::size_t rank = SIZE_MAX;
 
         xarray_adaptor(storage_type&& storage);
         xarray_adaptor(const storage_type& storage);
@@ -226,6 +252,9 @@ namespace xt
         template <class E>
         xarray_adaptor& operator=(const xexpression<E>& e);
 
+        template <class P, class S>
+        void reset_buffer(P&& pointer, S&& size);
+
     private:
 
         container_closure_type m_storage;
@@ -249,7 +278,8 @@ namespace xt
      */
     template <class EC, layout_type L, class SC, class Tag>
     inline xarray_container<EC, L, SC, Tag>::xarray_container()
-        : base_type(), m_storage(1, value_type())
+        : base_type()
+        , m_storage(1, value_type())
     {
     }
 
@@ -274,7 +304,11 @@ namespace xt
      * @param l the layout_type of the xarray_container
      */
     template <class EC, layout_type L, class SC, class Tag>
-    inline xarray_container<EC, L, SC, Tag>::xarray_container(const shape_type& shape, const_reference value, layout_type l)
+    inline xarray_container<EC, L, SC, Tag>::xarray_container(
+        const shape_type& shape,
+        const_reference value,
+        layout_type l
+    )
         : base_type()
     {
         base_type::resize(shape, l);
@@ -301,7 +335,11 @@ namespace xt
      * @param value the value of the elements
      */
     template <class EC, layout_type L, class SC, class Tag>
-    inline xarray_container<EC, L, SC, Tag>::xarray_container(const shape_type& shape, const strides_type& strides, const_reference value)
+    inline xarray_container<EC, L, SC, Tag>::xarray_container(
+        const shape_type& shape,
+        const strides_type& strides,
+        const_reference value
+    )
         : base_type()
     {
         base_type::resize(shape, strides);
@@ -329,10 +367,16 @@ namespace xt
      * @param strides the strides of the xarray_container
      */
     template <class EC, layout_type L, class SC, class Tag>
-    inline xarray_container<EC, L, SC, Tag>::xarray_container(storage_type&& storage, inner_shape_type&& shape, inner_strides_type&& strides)
-        : base_type(std::move(shape), std::move(strides)), m_storage(std::move(storage))
+    inline xarray_container<EC, L, SC, Tag>::xarray_container(
+        storage_type&& storage,
+        inner_shape_type&& shape,
+        inner_strides_type&& strides
+    )
+        : base_type(std::move(shape), std::move(strides))
+        , m_storage(std::move(storage))
     {
     }
+
     //@}
 
     /**
@@ -348,7 +392,8 @@ namespace xt
         : base_type()
     {
         base_type::resize(xt::shape<shape_type>(t));
-        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
+        constexpr auto tmp = layout_type::row_major;
+        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
     }
 
     /**
@@ -360,7 +405,8 @@ namespace xt
         : base_type()
     {
         base_type::resize(xt::shape<shape_type>(t));
-        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
+        constexpr auto tmp = layout_type::row_major;
+        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
     }
 
     /**
@@ -372,7 +418,8 @@ namespace xt
         : base_type()
     {
         base_type::resize(xt::shape<shape_type>(t));
-        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
+        constexpr auto tmp = layout_type::row_major;
+        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
     }
 
     /**
@@ -384,7 +431,8 @@ namespace xt
         : base_type()
     {
         base_type::resize(xt::shape<shape_type>(t));
-        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
+        constexpr auto tmp = layout_type::row_major;
+        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
     }
 
     /**
@@ -396,8 +444,10 @@ namespace xt
         : base_type()
     {
         base_type::resize(xt::shape<shape_type>(t));
-        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
+        constexpr auto tmp = layout_type::row_major;
+        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
     }
+
     //@}
 
     /**
@@ -408,24 +458,27 @@ namespace xt
     template <class S>
     inline xarray_container<EC, L, SC, Tag> xarray_container<EC, L, SC, Tag>::from_shape(S&& s)
     {
-        shape_type shape = xtl::forward_sequence<shape_type>(s);
+        shape_type shape = xtl::forward_sequence<shape_type, S>(s);
         return self_type(shape);
     }
 
     template <class EC, layout_type L, class SC, class Tag>
     template <std::size_t N>
     inline xarray_container<EC, L, SC, Tag>::xarray_container(xtensor_container<EC, N, L, Tag>&& rhs)
-        : base_type(inner_shape_type(rhs.shape().cbegin(), rhs.shape().cend()),
-                    inner_strides_type(rhs.strides().cbegin(), rhs.strides().cend()),
-                    inner_backstrides_type(rhs.backstrides().cbegin(), rhs.backstrides().cend()),
-                    std::move(rhs.layout())),
-          m_storage(std::move(rhs.storage()))
+        : base_type(
+            inner_shape_type(rhs.shape().cbegin(), rhs.shape().cend()),
+            inner_strides_type(rhs.strides().cbegin(), rhs.strides().cend()),
+            inner_backstrides_type(rhs.backstrides().cbegin(), rhs.backstrides().cend()),
+            std::move(rhs.layout())
+        )
+        , m_storage(std::move(rhs.storage()))
     {
     }
 
     template <class EC, layout_type L, class SC, class Tag>
     template <std::size_t N>
-    inline xarray_container<EC, L, SC, Tag>& xarray_container<EC, L, SC, Tag>::operator=(xtensor_container<EC, N, L, Tag>&& rhs)
+    inline xarray_container<EC, L, SC, Tag>&
+    xarray_container<EC, L, SC, Tag>::operator=(xtensor_container<EC, N, L, Tag>&& rhs)
     {
         this->shape_impl().assign(rhs.shape().cbegin(), rhs.shape().cend());
         this->strides_impl().assign(rhs.strides().cbegin(), rhs.strides().cend());
@@ -465,6 +518,7 @@ namespace xt
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     template <class EC, layout_type L, class SC, class Tag>
@@ -493,7 +547,8 @@ namespace xt
      */
     template <class EC, layout_type L, class SC, class Tag>
     inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(storage_type&& storage)
-        : base_type(), m_storage(std::move(storage))
+        : base_type()
+        , m_storage(std::move(storage))
     {
     }
 
@@ -503,7 +558,8 @@ namespace xt
      */
     template <class EC, layout_type L, class SC, class Tag>
     inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(const storage_type& storage)
-        : base_type(), m_storage(storage)
+        : base_type()
+        , m_storage(storage)
     {
     }
 
@@ -517,7 +573,8 @@ namespace xt
     template <class EC, layout_type L, class SC, class Tag>
     template <class D>
     inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(D&& storage, const shape_type& shape, layout_type l)
-        : base_type(), m_storage(std::forward<D>(storage))
+        : base_type()
+        , m_storage(std::forward<D>(storage))
     {
         base_type::resize(shape, l);
     }
@@ -531,11 +588,17 @@ namespace xt
      */
     template <class EC, layout_type L, class SC, class Tag>
     template <class D>
-    inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(D&& storage, const shape_type& shape, const strides_type& strides)
-        : base_type(), m_storage(std::forward<D>(storage))
+    inline xarray_adaptor<EC, L, SC, Tag>::xarray_adaptor(
+        D&& storage,
+        const shape_type& shape,
+        const strides_type& strides
+    )
+        : base_type()
+        , m_storage(std::forward<D>(storage))
     {
         base_type::resize(shape, strides);
     }
+
     //@}
 
     template <class EC, layout_type L, class SC, class Tag>
@@ -577,6 +640,7 @@ namespace xt
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     template <class EC, layout_type L, class SC, class Tag>
@@ -590,6 +654,13 @@ namespace xt
     {
         return m_storage;
     }
+
+    template <class EC, layout_type L, class SC, class Tag>
+    template <class P, class S>
+    inline void xarray_adaptor<EC, L, SC, Tag>::reset_buffer(P&& pointer, S&& size)
+    {
+        return m_storage.reset_data(std::forward<P>(pointer), std::forward<S>(size));
+    }
 }
 
 #endif
diff --git a/include/xtensor/containers/xbuffer_adaptor.hpp b/include/xtensor/containers/xbuffer_adaptor.hpp
new file mode 100644
index 000000000..e59503f3a
--- /dev/null
+++ b/include/xtensor/containers/xbuffer_adaptor.hpp
@@ -0,0 +1,1282 @@
+/***************************************************************************
+ * 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_BUFFER_ADAPTOR_HPP
+#define XTENSOR_BUFFER_ADAPTOR_HPP
+
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <stdexcept>
+
+#include <xtl/xclosure.hpp>
+
+#include "../containers/xstorage.hpp"
+#include "../core/xtensor_config.hpp"
+
+namespace xt
+{
+
+    struct no_ownership
+    {
+    };
+
+    using smart_ownership = no_ownership;
+
+    struct acquire_ownership
+    {
+    };
+
+    template <class CP, class O = no_ownership, class A = std::allocator<std::remove_pointer_t<std::remove_reference_t<CP>>>>
+    class xbuffer_adaptor;
+
+    /********************
+     * buffer_storage_t *
+     ********************/
+
+    namespace detail
+    {
+        template <class CP, class A>
+        class xbuffer_storage
+        {
+        public:
+
+            using self_type = xbuffer_storage<CP, A>;
+            using allocator_type = A;
+            using destructor_type = allocator_type;
+            using allocator_traits = std::allocator_traits<allocator_type>;
+            using value_type = typename allocator_traits::value_type;
+            using reference = std::conditional_t<
+                std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
+                const value_type&,
+                value_type&>;
+            using const_reference = const value_type&;
+            using pointer = std::conditional_t<
+                std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
+                typename allocator_traits::const_pointer,
+                typename allocator_traits::pointer>;
+            using const_pointer = typename allocator_traits::const_pointer;
+            using size_type = typename allocator_traits::size_type;
+            using difference_type = typename allocator_traits::difference_type;
+
+            xbuffer_storage();
+
+            template <class P>
+            xbuffer_storage(P&& data, size_type size, const allocator_type& alloc = allocator_type());
+
+            size_type size() const noexcept;
+            void resize(size_type size);
+
+            pointer data() noexcept;
+            const_pointer data() const noexcept;
+
+            void swap(self_type& rhs) noexcept;
+
+            template <class P>
+            void reset_data(P&& data, size_type size) noexcept;
+
+        private:
+
+            pointer p_data;
+            size_type m_size;
+        };
+
+        template <class CP, class D>
+        class xbuffer_smart_pointer
+        {
+        public:
+
+            using self_type = xbuffer_storage<CP, D>;
+            using destructor_type = D;
+            using value_type = std::remove_const_t<std::remove_pointer_t<std::remove_reference_t<CP>>>;
+            using allocator_type = std::allocator<value_type>;
+            using allocator_traits = std::allocator_traits<allocator_type>;
+            using reference = std::conditional_t<
+                std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
+                const value_type&,
+                value_type&>;
+            using const_reference = const value_type&;
+            using pointer = std::conditional_t<
+                std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
+                typename allocator_traits::const_pointer,
+                typename allocator_traits::pointer>;
+            using const_pointer = typename allocator_traits::const_pointer;
+            using size_type = typename allocator_traits::size_type;
+            using difference_type = typename allocator_traits::difference_type;
+
+            xbuffer_smart_pointer();
+
+            template <class P, class DT>
+            xbuffer_smart_pointer(P&& data_ptr, size_type size, DT&& destruct);
+
+            size_type size() const noexcept;
+            void resize(size_type size);
+
+            pointer data() noexcept;
+            const_pointer data() const noexcept;
+
+            void swap(self_type& rhs) noexcept;
+
+            template <class P, class DT>
+            void reset_data(P&& data, size_type size, DT&& destruct) noexcept;
+
+        private:
+
+            pointer p_data;
+            size_type m_size;
+            destructor_type m_destruct;
+        };
+
+        template <class CP, class A>
+        class xbuffer_owner_storage
+        {
+        public:
+
+            using self_type = xbuffer_owner_storage<CP, A>;
+            using allocator_type = A;
+            using destructor_type = allocator_type;
+            using allocator_traits = std::allocator_traits<allocator_type>;
+            using value_type = typename allocator_traits::value_type;
+            using reference = std::conditional_t<
+                std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
+                const value_type&,
+                value_type&>;
+            using const_reference = const value_type&;
+            using pointer = std::conditional_t<
+                std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
+                typename allocator_traits::const_pointer,
+                typename allocator_traits::pointer>;
+            using const_pointer = typename allocator_traits::const_pointer;
+            using size_type = typename allocator_traits::size_type;
+            using difference_type = typename allocator_traits::difference_type;
+
+            xbuffer_owner_storage() = default;
+
+            template <class P>
+            xbuffer_owner_storage(P&& data, size_type size, const allocator_type& alloc = allocator_type());
+
+            ~xbuffer_owner_storage();
+
+            xbuffer_owner_storage(const self_type&) = delete;
+            self_type& operator=(const self_type&);
+
+            xbuffer_owner_storage(self_type&&);
+            self_type& operator=(self_type&&);
+
+            size_type size() const noexcept;
+            void resize(size_type size);
+
+            pointer data() noexcept;
+            const_pointer data() const noexcept;
+
+            allocator_type get_allocator() const noexcept;
+
+            void swap(self_type& rhs) noexcept;
+
+            template <class P>
+            void reset_data(P&& data, size_type size, const allocator_type& alloc = allocator_type()) noexcept;
+
+        private:
+
+            xtl::xclosure_wrapper<CP> m_data;
+            size_type m_size;
+            bool m_moved_from;
+            allocator_type m_allocator;
+        };
+
+        // Workaround for MSVC2015: using void_t results in some
+        // template instantiation caching that leads to wrong
+        // type deduction later in xfunction.
+        template <class T>
+        struct msvc2015_void
+        {
+            using type = void;
+        };
+
+        template <class T>
+        using msvc2015_void_t = typename msvc2015_void<T>::type;
+
+        template <class E, class = void>
+        struct is_lambda_type : std::false_type
+        {
+        };
+
+        // check if operator() is available
+        template <class E>
+        struct is_lambda_type<E, msvc2015_void_t<decltype(&E::operator())>> : std::true_type
+        {
+        };
+
+        template <class T>
+        struct self_type
+        {
+            using type = T;
+        };
+
+        template <class CP, class A, class O>
+        struct get_buffer_storage
+        {
+            using type = xtl::mpl::eval_if_t<
+                is_lambda_type<A>,
+                self_type<xbuffer_smart_pointer<CP, A>>,
+                self_type<xbuffer_storage<CP, A>>>;
+        };
+
+        template <class CP, class A>
+        struct get_buffer_storage<CP, A, acquire_ownership>
+        {
+            using type = xbuffer_owner_storage<CP, A>;
+        };
+
+        template <class CP, class T>
+        struct get_buffer_storage<CP, std::shared_ptr<T>, no_ownership>
+        {
+            using type = xbuffer_smart_pointer<CP, std::shared_ptr<T>>;
+        };
+
+        template <class CP, class T>
+        struct get_buffer_storage<CP, std::unique_ptr<T>, no_ownership>
+        {
+            using type = xbuffer_smart_pointer<CP, std::unique_ptr<T>>;
+        };
+
+        template <class CP, class A, class O>
+        using buffer_storage_t = typename get_buffer_storage<CP, A, O>::type;
+    }
+
+    /************************
+     * xbuffer_adaptor_base *
+     ************************/
+
+    template <class D>
+    struct buffer_inner_types;
+
+    template <class D>
+    class xbuffer_adaptor_base
+    {
+    public:
+
+        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;
+
+        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:
+
+        xbuffer_adaptor_base() = default;
+        ~xbuffer_adaptor_base() = default;
+
+        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;
+    };
+
+    template <class D>
+    bool operator==(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs);
+
+    template <class D>
+    bool operator!=(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs);
+
+    template <class D>
+    bool operator<(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs);
+
+    template <class D>
+    bool operator<=(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs);
+
+    template <class D>
+    bool operator>(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs);
+
+    template <class D>
+    bool operator>=(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs);
+
+    /*******************
+     * xbuffer_adaptor *
+     *******************/
+
+    template <class CP, class O, class A>
+    struct buffer_inner_types<xbuffer_adaptor<CP, O, A>>
+    {
+        using base_type = detail::buffer_storage_t<CP, A, O>;
+        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 iterator = pointer;
+        using const_iterator = const_pointer;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using index_type = size_type;
+    };
+
+    template <class CP, class O, class A>
+    class xbuffer_adaptor : private detail::buffer_storage_t<CP, A, O>,
+                            public xbuffer_adaptor_base<xbuffer_adaptor<CP, O, A>>
+    {
+    public:
+
+        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>;
+
+        xbuffer_adaptor() = default;
+
+        using base_type::base_type;
+
+        ~xbuffer_adaptor() = default;
+
+        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&&);
+
+        using base_type::data;
+        using base_type::reset_data;
+        using base_type::resize;
+        using base_type::size;
+        using base_type::swap;
+    };
+
+    template <class CP, class O, class A>
+    void swap(xbuffer_adaptor<CP, O, A>& lhs, xbuffer_adaptor<CP, O, A>& rhs) noexcept;
+
+    /*********************
+     * xiterator_adaptor *
+     *********************/
+
+    template <class I, class CI>
+    class xiterator_adaptor;
+
+    template <class I, class CI>
+    struct buffer_inner_types<xiterator_adaptor<I, CI>>
+    {
+        using traits = std::iterator_traits<I>;
+        using const_traits = std::iterator_traits<CI>;
+
+        using value_type = std::common_type_t<typename traits::value_type, typename const_traits::value_type>;
+        using reference = typename traits::reference;
+        using const_reference = typename const_traits::reference;
+        using pointer = typename traits::pointer;
+        using const_pointer = typename const_traits::pointer;
+        using difference_type = std::common_type_t<typename traits::difference_type, typename const_traits::difference_type>;
+        using size_type = std::make_unsigned_t<difference_type>;
+
+        using iterator = I;
+        using const_iterator = CI;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using index_type = difference_type;
+    };
+
+    template <class I, class CI>
+    class xiterator_adaptor : public xbuffer_adaptor_base<xiterator_adaptor<I, CI>>
+    {
+    public:
+
+        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>;
+
+        xiterator_adaptor() = default;
+        xiterator_adaptor(I it, CI cit, size_type size);
+
+        ~xiterator_adaptor() = default;
+
+        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;
+
+    private:
+
+        I m_it;
+        CI m_cit;
+        size_type m_size;
+    };
+
+    template <class I, class CI>
+    void swap(xiterator_adaptor<I, CI>& lhs, xiterator_adaptor<I, CI>& rhs) noexcept;
+
+    template <class I, class CI>
+    struct is_contiguous_container<xiterator_adaptor<I, CI>> : is_contiguous_container<I>
+    {
+    };
+
+    /***************************
+     * xiterator_owner_adaptor *
+     ***************************/
+
+    template <class C, class IG>
+    class xiterator_owner_adaptor;
+
+    template <class C, class IG>
+    struct buffer_inner_types<xiterator_owner_adaptor<C, IG>>
+    {
+        using iterator = typename IG::iterator;
+        using const_iterator = typename IG::const_iterator;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+        using traits = std::iterator_traits<iterator>;
+        using const_traits = std::iterator_traits<const_iterator>;
+
+        using value_type = std::common_type_t<typename traits::value_type, typename const_traits::value_type>;
+        using reference = typename traits::reference;
+        using const_reference = typename const_traits::reference;
+        using pointer = typename traits::pointer;
+        using const_pointer = typename const_traits::pointer;
+        using difference_type = std::common_type_t<typename traits::difference_type, typename const_traits::difference_type>;
+        using size_type = std::make_unsigned_t<difference_type>;
+        using index_type = difference_type;
+    };
+
+    template <class C, class IG>
+    class xiterator_owner_adaptor : public xbuffer_adaptor_base<xiterator_owner_adaptor<C, IG>>
+    {
+    public:
+
+        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>;
+
+        xiterator_owner_adaptor(C&& c);
+
+        ~xiterator_owner_adaptor() = default;
+
+        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;
+
+    private:
+
+        void init_iterators();
+
+        C m_container;
+        iterator m_it;
+        const_iterator m_cit;
+        size_type m_size;
+    };
+
+    template <class C, class IG>
+    void swap(xiterator_owner_adaptor<C, IG>& lhs, xiterator_owner_adaptor<C, IG>& rhs) noexcept;
+
+    template <class C, class IG>
+    struct is_contiguous_container<xiterator_owner_adaptor<C, IG>>
+        : is_contiguous_container<typename IG::iterator>
+    {
+    };
+
+    /**************************
+     * make_xiterator_adaptor *
+     **************************/
+
+    template <class C, class IG>
+    auto make_xiterator_adaptor(C&& container, IG iterator_getter);
+
+    /************************************
+     * temporary_container metafunction *
+     ************************************/
+
+    template <class C>
+    struct temporary_container
+    {
+        using type = C;
+    };
+
+    template <class CP, class O, class A>
+    struct temporary_container<xbuffer_adaptor<CP, O, A>>
+    {
+        using type = typename xbuffer_adaptor<CP, O, A>::temporary_type;
+    };
+
+    template <class I, class CI>
+    struct temporary_container<xiterator_adaptor<I, CI>>
+    {
+        using type = typename xiterator_adaptor<I, CI>::temporary_type;
+    };
+
+    template <class C, class IG>
+    struct temporary_container<xiterator_owner_adaptor<C, IG>>
+    {
+        using type = typename xiterator_owner_adaptor<C, IG>::temporary_type;
+    };
+
+    template <class C>
+    using temporary_container_t = typename temporary_container<C>::type;
+
+    /**********************************
+     * xbuffer_storage implementation *
+     **********************************/
+
+    namespace detail
+    {
+        template <class CP, class A>
+        inline xbuffer_storage<CP, A>::xbuffer_storage()
+            : p_data(nullptr)
+            , m_size(0)
+        {
+        }
+
+        template <class CP, class A>
+        template <class P>
+        inline xbuffer_storage<CP, A>::xbuffer_storage(P&& data, size_type size, const allocator_type&)
+            : p_data(std::forward<P>(data))
+            , m_size(size)
+        {
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_storage<CP, A>::size() const noexcept -> size_type
+        {
+            return m_size;
+        }
+
+        template <class CP, class A>
+        inline void xbuffer_storage<CP, A>::resize(size_type size)
+        {
+            if (size != m_size)
+            {
+                XTENSOR_THROW(std::runtime_error, "xbuffer_storage not resizable");
+            }
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_storage<CP, A>::data() noexcept -> pointer
+        {
+            return p_data;
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_storage<CP, A>::data() const noexcept -> const_pointer
+        {
+            return p_data;
+        }
+
+        template <class CP, class A>
+        inline void xbuffer_storage<CP, A>::swap(self_type& rhs) noexcept
+        {
+            using std::swap;
+            swap(p_data, rhs.p_data);
+            swap(m_size, rhs.m_size);
+        }
+
+        template <class CP, class A>
+        template <class P>
+        inline void xbuffer_storage<CP, A>::reset_data(P&& data, size_type size) noexcept
+        {
+            p_data = std::forward<P>(data);
+            m_size = size;
+        }
+    }
+
+    /****************************************
+     * xbuffer_owner_storage implementation *
+     ****************************************/
+
+    namespace detail
+    {
+        template <class CP, class A>
+        template <class P>
+        inline xbuffer_owner_storage<CP, A>::xbuffer_owner_storage(P&& data, size_type size, const allocator_type& alloc)
+            : m_data(std::forward<P>(data))
+            , m_size(size)
+            , m_moved_from(false)
+            , m_allocator(alloc)
+        {
+        }
+
+        template <class CP, class A>
+        inline xbuffer_owner_storage<CP, A>::~xbuffer_owner_storage()
+        {
+            if (!m_moved_from)
+            {
+                safe_destroy_deallocate(m_allocator, m_data.get(), m_size);
+                m_size = 0;
+            }
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_owner_storage<CP, A>::operator=(const self_type& rhs) -> self_type&
+        {
+            using std::swap;
+            if (this != &rhs)
+            {
+                allocator_type al = std::allocator_traits<allocator_type>::select_on_container_copy_construction(
+                    rhs.get_allocator()
+                );
+                pointer tmp = safe_init_allocate(al, rhs.m_size);
+                if (std::is_trivially_default_constructible<value_type>::value)
+                {
+                    std::uninitialized_copy(rhs.m_data.get(), rhs.m_data.get() + rhs.m_size, tmp);
+                }
+                else
+                {
+                    std::copy(rhs.m_data.get(), rhs.m_data.get() + rhs.m_size, tmp);
+                }
+                swap(m_data.get(), tmp);
+                swap(m_allocator, al);
+                safe_destroy_deallocate(al, tmp, m_size);
+                m_size = rhs.m_size;
+            }
+            return *this;
+        }
+
+        template <class CP, class A>
+        inline xbuffer_owner_storage<CP, A>::xbuffer_owner_storage(self_type&& rhs)
+            : m_data(std::move(rhs.m_data))
+            , m_size(std::move(rhs.m_size))
+            , m_moved_from(std::move(rhs.m_moved_from))
+            , m_allocator(std::move(rhs.m_allocator))
+        {
+            rhs.m_moved_from = true;
+            rhs.m_size = 0;
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_owner_storage<CP, A>::operator=(self_type&& rhs) -> self_type&
+        {
+            swap(rhs);
+            return *this;
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_owner_storage<CP, A>::size() const noexcept -> size_type
+        {
+            return m_size;
+        }
+
+        template <class CP, class A>
+        void xbuffer_owner_storage<CP, A>::resize(size_type size)
+        {
+            using std::swap;
+            if (size != m_size)
+            {
+                pointer tmp = safe_init_allocate(m_allocator, size);
+                swap(m_data.get(), tmp);
+                swap(m_size, size);
+                safe_destroy_deallocate(m_allocator, tmp, size);
+            }
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_owner_storage<CP, A>::data() noexcept -> pointer
+        {
+            return m_data.get();
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_owner_storage<CP, A>::data() const noexcept -> const_pointer
+        {
+            return m_data.get();
+        }
+
+        template <class CP, class A>
+        inline auto xbuffer_owner_storage<CP, A>::get_allocator() const noexcept -> allocator_type
+        {
+            return allocator_type(m_allocator);
+        }
+
+        template <class CP, class A>
+        inline void xbuffer_owner_storage<CP, A>::swap(self_type& rhs) noexcept
+        {
+            using std::swap;
+            swap(m_data, rhs.m_data);
+            swap(m_size, rhs.m_size);
+            swap(m_allocator, rhs.m_allocator);
+        }
+
+        template <class CP, class A>
+        template <class P>
+        inline void
+        xbuffer_owner_storage<CP, A>::reset_data(P&& data, size_type size, const allocator_type& alloc) noexcept
+        {
+            xbuffer_owner_storage<CP, A> tmp(std::forward<P>(data), size, alloc);
+            this->swap(tmp);
+        }
+    }
+
+    /****************************************
+     * xbuffer_smart_pointer implementation *
+     ****************************************/
+
+    namespace detail
+    {
+        template <class CP, class D>
+        template <class P, class DT>
+        xbuffer_smart_pointer<CP, D>::xbuffer_smart_pointer(P&& data_ptr, size_type size, DT&& destruct)
+            : p_data(data_ptr)
+            , m_size(size)
+            , m_destruct(std::forward<DT>(destruct))
+        {
+        }
+
+        template <class CP, class D>
+        auto xbuffer_smart_pointer<CP, D>::size() const noexcept -> size_type
+        {
+            return m_size;
+        }
+
+        template <class CP, class D>
+        void xbuffer_smart_pointer<CP, D>::resize(size_type size)
+        {
+            if (m_size != size)
+            {
+                XTENSOR_THROW(std::runtime_error, "xbuffer_storage not resizeable");
+            }
+        }
+
+        template <class CP, class D>
+        auto xbuffer_smart_pointer<CP, D>::data() noexcept -> pointer
+        {
+            return p_data;
+        }
+
+        template <class CP, class D>
+        auto xbuffer_smart_pointer<CP, D>::data() const noexcept -> const_pointer
+        {
+            return p_data;
+        }
+
+        template <class CP, class D>
+        void xbuffer_smart_pointer<CP, D>::swap(self_type& rhs) noexcept
+        {
+            using std::swap;
+            swap(p_data, rhs.p_data);
+            swap(m_size, rhs.m_size);
+            swap(m_destruct, rhs.m_destruct);
+        }
+
+        template <class CP, class D>
+        template <class P, class DT>
+        void xbuffer_smart_pointer<CP, D>::reset_data(P&& data, size_type size, DT&& destruct) noexcept
+        {
+            p_data = std::forward<P>(data);
+            m_size = size;
+            m_destruct = destruct;
+        }
+    }
+
+    /***************************************
+     * xbuffer_adaptor_base implementation *
+     ***************************************/
+
+    template <class D>
+    inline bool xbuffer_adaptor_base<D>::empty() const noexcept
+    {
+        return derived_cast().size() == size_type(0);
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::operator[](size_type i) -> reference
+    {
+        return derived_cast().data()[static_cast<index_type>(i)];
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::operator[](size_type i) const -> const_reference
+    {
+        return derived_cast().data()[static_cast<index_type>(i)];
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::front() -> reference
+    {
+        return this->operator[](0);
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::front() const -> const_reference
+    {
+        return this->operator[](0);
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::back() -> reference
+    {
+        return this->operator[](derived_cast().size() - 1);
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::back() const -> const_reference
+    {
+        return this->operator[](derived_cast().size() - 1);
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::begin() noexcept -> iterator
+    {
+        return derived_cast().data();
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::end() noexcept -> iterator
+    {
+        return derived_cast().data() + static_cast<index_type>(derived_cast().size());
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::begin() const noexcept -> const_iterator
+    {
+        return derived_cast().data();
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::end() const noexcept -> const_iterator
+    {
+        return derived_cast().data() + static_cast<index_type>(derived_cast().size());
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::cbegin() const noexcept -> const_iterator
+    {
+        return begin();
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::cend() const noexcept -> const_iterator
+    {
+        return end();
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::rbegin() noexcept -> reverse_iterator
+    {
+        return reverse_iterator(end());
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::rend() noexcept -> reverse_iterator
+    {
+        return reverse_iterator(begin());
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::rbegin() const noexcept -> const_reverse_iterator
+    {
+        return const_reverse_iterator(end());
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::rend() const noexcept -> const_reverse_iterator
+    {
+        return const_reverse_iterator(begin());
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::crbegin() const noexcept -> const_reverse_iterator
+    {
+        return rbegin();
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::crend() const noexcept -> const_reverse_iterator
+    {
+        return rend();
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::derived_cast() noexcept -> derived_type&
+    {
+        return *static_cast<derived_type*>(this);
+    }
+
+    template <class D>
+    inline auto xbuffer_adaptor_base<D>::derived_cast() const noexcept -> const derived_type&
+    {
+        return *static_cast<const derived_type*>(this);
+    }
+
+    template <class D>
+    inline bool operator==(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs)
+    {
+        return lhs.derived_cast().size() == rhs.derived_cast().size()
+               && std::equal(lhs.begin(), lhs.end(), rhs.begin());
+    }
+
+    template <class D>
+    inline bool operator!=(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    template <class D>
+    inline bool operator<(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs)
+    {
+        return std::lexicographical_compare(
+            lhs.begin(),
+            lhs.end(),
+            rhs.begin(),
+            rhs.end(),
+            std::less<typename D::value_type>()
+        );
+    }
+
+    template <class D>
+    inline bool operator<=(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs)
+    {
+        return std::lexicographical_compare(
+            lhs.begin(),
+            lhs.end(),
+            rhs.begin(),
+            rhs.end(),
+            std::less_equal<typename D::value_type>()
+        );
+    }
+
+    template <class D>
+    inline bool operator>(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs)
+    {
+        return std::lexicographical_compare(
+            lhs.begin(),
+            lhs.end(),
+            rhs.begin(),
+            rhs.end(),
+            std::greater<typename D::value_type>()
+        );
+    }
+
+    template <class D>
+    inline bool operator>=(const xbuffer_adaptor_base<D>& lhs, const xbuffer_adaptor_base<D>& rhs)
+    {
+        return std::lexicographical_compare(
+            lhs.begin(),
+            lhs.end(),
+            rhs.begin(),
+            rhs.end(),
+            std::greater_equal<typename D::value_type>()
+        );
+    }
+
+    /**********************************
+     * xbuffer_adaptor implementation *
+     **********************************/
+
+    template <class CP, class O, class A>
+    inline auto xbuffer_adaptor<CP, O, A>::operator=(temporary_type&& tmp) -> self_type&
+    {
+        base_type::resize(tmp.size());
+        std::copy(tmp.cbegin(), tmp.cend(), this->begin());
+        return *this;
+    }
+
+    template <class CP, class O, class A>
+    inline void swap(xbuffer_adaptor<CP, O, A>& lhs, xbuffer_adaptor<CP, O, A>& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+
+    /************************************
+     * xiterator_adaptor implementation *
+     ************************************/
+
+    template <class I, class CI>
+    inline xiterator_adaptor<I, CI>::xiterator_adaptor(I it, CI cit, size_type size)
+        : m_it(it)
+        , m_cit(cit)
+        , m_size(size)
+    {
+    }
+
+    template <class I, class CI>
+    inline auto xiterator_adaptor<I, CI>::operator=(const temporary_type& rhs) -> self_type&
+    {
+        resize(rhs.size());
+        std::copy(rhs.cbegin(), rhs.cend(), m_it);
+        return *this;
+    }
+
+    template <class I, class CI>
+    inline auto xiterator_adaptor<I, CI>::operator=(temporary_type&& rhs) -> self_type&
+    {
+        return (*this = rhs);
+    }
+
+    template <class I, class CI>
+    inline auto xiterator_adaptor<I, CI>::size() const noexcept -> size_type
+    {
+        return m_size;
+    }
+
+    template <class I, class CI>
+    inline void xiterator_adaptor<I, CI>::resize(size_type size)
+    {
+        if (m_size != size)
+        {
+            XTENSOR_THROW(std::runtime_error, "xiterator_adaptor not resizeable");
+        }
+    }
+
+    template <class I, class CI>
+    inline auto xiterator_adaptor<I, CI>::data() noexcept -> iterator
+    {
+        return m_it;
+    }
+
+    template <class I, class CI>
+    inline auto xiterator_adaptor<I, CI>::data() const noexcept -> const_iterator
+    {
+        return m_cit;
+    }
+
+    template <class I, class CI>
+    inline void xiterator_adaptor<I, CI>::swap(self_type& rhs) noexcept
+    {
+        using std::swap;
+        swap(m_it, rhs.m_it);
+        swap(m_cit, rhs.m_cit);
+        swap(m_size, rhs.m_size);
+    }
+
+    template <class I, class CI>
+    inline void swap(xiterator_adaptor<I, CI>& lhs, xiterator_adaptor<I, CI>& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+
+    /******************************************
+     * xiterator_owner_adaptor implementation *
+     ******************************************/
+
+    template <class C, class IG>
+    inline xiterator_owner_adaptor<C, IG>::xiterator_owner_adaptor(C&& c)
+        : m_container(std::move(c))
+    {
+        init_iterators();
+    }
+
+    template <class C, class IG>
+    inline xiterator_owner_adaptor<C, IG>::xiterator_owner_adaptor(const self_type& rhs)
+        : m_container(rhs.m_container)
+    {
+        init_iterators();
+    }
+
+    template <class C, class IG>
+    inline xiterator_owner_adaptor<C, IG>& xiterator_owner_adaptor<C, IG>::operator=(const self_type& rhs)
+    {
+        m_container = rhs.m_container;
+        init_iterators();
+    }
+
+    template <class C, class IG>
+    inline xiterator_owner_adaptor<C, IG>::xiterator_owner_adaptor(self_type&& rhs)
+        : m_container(std::move(rhs.m_container))
+    {
+        init_iterators();
+    }
+
+    template <class C, class IG>
+    inline xiterator_owner_adaptor<C, IG>& xiterator_owner_adaptor<C, IG>::operator=(self_type&& rhs)
+    {
+        m_container = std::move(rhs.m_container);
+        init_iterators();
+    }
+
+    template <class C, class IG>
+    inline xiterator_owner_adaptor<C, IG>& xiterator_owner_adaptor<C, IG>::operator=(const temporary_type& rhs)
+    {
+        resize(rhs.size());
+        std::copy(rhs.cbegin(), rhs.cend(), m_it);
+        return *this;
+    }
+
+    template <class C, class IG>
+    inline xiterator_owner_adaptor<C, IG>& xiterator_owner_adaptor<C, IG>::operator=(temporary_type&& rhs)
+    {
+        return (*this = rhs);
+    }
+
+    template <class C, class IG>
+    inline auto xiterator_owner_adaptor<C, IG>::size() const noexcept -> size_type
+    {
+        return m_size;
+    }
+
+    template <class C, class IG>
+    inline void xiterator_owner_adaptor<C, IG>::resize(size_type size)
+    {
+        if (m_size != size)
+        {
+            XTENSOR_THROW(std::runtime_error, "xiterator_owner_adaptor not resizeable");
+        }
+    }
+
+    template <class C, class IG>
+    inline auto xiterator_owner_adaptor<C, IG>::data() noexcept -> iterator
+    {
+        return m_it;
+    }
+
+    template <class C, class IG>
+    inline auto xiterator_owner_adaptor<C, IG>::data() const noexcept -> const_iterator
+    {
+        return m_cit;
+    }
+
+    template <class C, class IG>
+    inline void xiterator_owner_adaptor<C, IG>::swap(self_type& rhs) noexcept
+    {
+        using std::swap;
+        swap(m_container, rhs.m_container);
+        init_iterators();
+        rhs.init_iterators();
+    }
+
+    template <class C, class IG>
+    inline void xiterator_owner_adaptor<C, IG>::init_iterators()
+    {
+        m_it = IG::begin(m_container);
+        m_cit = IG::cbegin(m_container);
+        m_size = IG::size(m_container);
+    }
+
+    template <class C, class IG>
+    inline void swap(xiterator_owner_adaptor<C, IG>& lhs, xiterator_owner_adaptor<C, IG>& rhs) noexcept
+    {
+        lhs.swap(rhs);
+    }
+
+    /*****************************************
+     * make_xiterator_adaptor implementation *
+     *****************************************/
+
+    namespace detail
+    {
+        template <class C, class IG, bool = std::is_lvalue_reference<C>::value>
+        struct xiterator_adaptor_builder
+        {
+            using iterator = decltype(IG::begin(std::declval<C>()));
+            using const_iterator = decltype(IG::cbegin(std::declval<C>()));
+            using type = xiterator_adaptor<iterator, const_iterator>;
+
+            inline static type build(C& c)
+            {
+                return type(IG::begin(c), IG::cbegin(c), IG::size(c));
+            }
+        };
+
+        template <class C, class IG>
+        struct xiterator_adaptor_builder<C, IG, false>
+        {
+            using type = xiterator_owner_adaptor<C, IG>;
+
+            inline static type build(C&& c)
+            {
+                return type(std::move(c));
+            }
+        };
+    }
+
+    template <class C, class IG>
+    inline auto make_xiterator_adaptor(C&& container, IG)
+    {
+        using builder_type = detail::xiterator_adaptor_builder<C, IG>;
+        return builder_type::build(std::forward<C>(container));
+    }
+}
+
+#endif
diff --git a/include/xtensor/xcontainer.hpp b/include/xtensor/containers/xcontainer.hpp
similarity index 65%
rename from include/xtensor/xcontainer.hpp
rename to include/xtensor/containers/xcontainer.hpp
index 91f3e51b8..7f17ffe01 100644
--- a/include/xtensor/xcontainer.hpp
+++ b/include/xtensor/containers/xcontainer.hpp
@@ -1,28 +1,30 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_CONTAINER_HPP
 #define XTENSOR_CONTAINER_HPP
 
 #include <algorithm>
-#include <functional>
-#include <numeric>
+#include <memory>
 #include <stdexcept>
 
 #include <xtl/xmeta_utils.hpp>
 #include <xtl/xsequence.hpp>
 
-#include "xiterable.hpp"
-#include "xiterator.hpp"
-#include "xmath.hpp"
-#include "xoperation.hpp"
-#include "xstrides.hpp"
-#include "xtensor_forward.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xiterator.hpp"
+#include "../core/xmath.hpp"
+#include "../core/xoperation.hpp"
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../core/xtensor_forward.hpp"
 
 namespace xt
 {
@@ -30,7 +32,6 @@ namespace xt
     struct xcontainer_iterable_types
     {
         using inner_shape_type = typename xcontainer_inner_types<D>::inner_shape_type;
-        using storage_type = typename xcontainer_inner_types<D>::storage_type;
         using stepper = xstepper<D>;
         using const_stepper = xstepper<const D>;
     };
@@ -53,7 +54,6 @@ namespace xt
     template <class T>
     using allocator_type_t = typename detail::allocator_type_impl<T>::type;
 
-
     /**
      * @class xcontainer
      * @brief Base class for dense multidimensional containers.
@@ -66,7 +66,8 @@ namespace xt
      *           provides the interface.
      */
     template <class D>
-    class xcontainer : public xcontiguous_iterable<D>
+    class xcontainer : public xcontiguous_iterable<D>,
+                       private xaccessible<D>
     {
     public:
 
@@ -76,15 +77,14 @@ namespace xt
         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 = std::conditional_t<std::is_const<storage_type>::value,
-                                             typename storage_type::const_reference,
-                                             typename storage_type::reference>;
-        using const_reference = typename storage_type::const_reference;
+        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 storage_type::size_type;
+        using size_type = typename inner_types::size_type;
         using difference_type = typename storage_type::difference_type;
-        using simd_value_type = xsimd::simd_type<value_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;
@@ -98,25 +98,27 @@ namespace xt
         using stepper = typename iterable_base::stepper;
         using const_stepper = typename iterable_base::const_stepper;
 
+        using accessible_base = xaccessible<D>;
+
         static constexpr layout_type static_layout = inner_types::layout;
         static constexpr bool contiguous_layout = static_layout != layout_type::dynamic;
-        using data_alignment = xsimd::container_alignment_t<storage_type>;
-        using simd_type = xsimd::simd_type<value_type>;
+        using data_alignment = xt_simd::container_alignment_t<storage_type>;
+        using simd_type = xt_simd::simd_type<value_type>;
 
-        using storage_iterator = typename storage_type::iterator;
-        using const_storage_iterator = typename storage_type::const_iterator;
-        using reverse_storage_iterator = typename storage_type::reverse_iterator;
-        using const_reverse_storage_iterator = typename storage_type::const_reverse_iterator;
+        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;
 
         static_assert(static_layout != layout_type::any, "Container layout can never be layout_type::any!");
 
         size_type size() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN size_type dimension() const noexcept;
+        constexpr size_type dimension() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides() const noexcept;
+        constexpr const inner_shape_type& shape() const noexcept;
+        constexpr const inner_strides_type& strides() const noexcept;
+        constexpr const inner_backstrides_type& backstrides() const noexcept;
 
         template <class T>
         void fill(const T& value);
@@ -127,29 +129,19 @@ namespace xt
         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);
-        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;
+        using accessible_base::at;
+        using accessible_base::shape;
+        using accessible_base::operator[];
+        using accessible_base::back;
+        using accessible_base::front;
+        using accessible_base::in_bounds;
+        using accessible_base::periodic;
 
         template <class It>
         reference element(It first, It last);
@@ -159,8 +151,8 @@ namespace xt
         storage_type& storage() noexcept;
         const storage_type& storage() const noexcept;
 
-        value_type* data() noexcept;
-        const value_type* data() const noexcept;
+        pointer data() noexcept;
+        const_pointer data() const noexcept;
         const size_type data_offset() const noexcept;
 
         template <class S>
@@ -169,7 +161,6 @@ namespace xt
         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 l) noexcept;
@@ -182,33 +173,36 @@ namespace xt
         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 requested_type>
-        using simd_return_type = xsimd::simd_return_type<value_type, requested_type>;
+        using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
 
         template <class align, class simd>
         void store_simd(size_type i, const simd& e);
-        template <class align, class requested_type = value_type,
-                  std::size_t N = xsimd::simd_traits<requested_type>::size>
-        simd_return_type<requested_type> load_simd(size_type i) const;
+        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>
+        /*simd_return_type<requested_type>*/ load_simd(size_type i) const;
 
-        storage_iterator storage_begin() noexcept;
-        storage_iterator storage_end() noexcept;
+        linear_iterator linear_begin() noexcept;
+        linear_iterator linear_end() noexcept;
 
-        const_storage_iterator storage_begin() const noexcept;
-        const_storage_iterator storage_end() const noexcept;
-        const_storage_iterator storage_cbegin() const noexcept;
-        const_storage_iterator storage_cend() const 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_storage_iterator storage_rbegin() noexcept;
-        reverse_storage_iterator storage_rend() noexcept;
+        reverse_linear_iterator linear_rbegin() noexcept;
+        reverse_linear_iterator linear_rend() noexcept;
 
-        const_reverse_storage_iterator storage_rbegin() const noexcept;
-        const_reverse_storage_iterator storage_rend() const noexcept;
-        const_reverse_storage_iterator storage_crbegin() const noexcept;
-        const_reverse_storage_iterator storage_crend() 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;
 
-        using container_iterator = storage_iterator;
-        using const_container_iterator = const_storage_iterator;
+        using container_iterator = linear_iterator;
+        using const_container_iterator = const_linear_iterator;
 
     protected:
 
@@ -223,26 +217,29 @@ namespace xt
 
         container_iterator data_xbegin() noexcept;
         const_container_iterator data_xbegin() const noexcept;
-        container_iterator data_xend(layout_type l) noexcept;
-        const_container_iterator data_xend(layout_type l) 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;
 
     protected:
 
         derived_type& derived_cast() & noexcept;
-        const derived_type& derived_cast() const & noexcept;
+        const derived_type& derived_cast() const& noexcept;
         derived_type derived_cast() && noexcept;
 
     private:
 
-        template <class C>
-        friend class xstepper;
-
         template <class It>
-        It data_xend_impl(It end, layout_type l) const noexcept;
+        It data_xend_impl(It begin, layout_type l, size_type offset) const noexcept;
 
         inner_shape_type& mutable_shape();
         inner_strides_type& mutable_strides();
         inner_backstrides_type& mutable_backstrides();
+
+        template <class C>
+        friend class xstepper;
+
+        friend class xaccessible<D>;
+        friend class xconst_accessible<D>;
     };
 
     /**
@@ -284,9 +281,13 @@ namespace xt
         void resize(S&& shape, const strides_type& strides);
 
         template <class S = shape_type>
-        void reshape(S&& shape, layout_type layout = base_type::static_layout);
+        auto& reshape(S&& shape, layout_type layout = base_type::static_layout) &;
+
+        template <class T>
+        auto& reshape(std::initializer_list<T> shape, layout_type layout = base_type::static_layout) &;
 
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
 
     protected:
 
@@ -316,10 +317,7 @@ namespace xt
         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
-        {
-            return m_layout;
-        }
+        layout_type& mutable_layout() noexcept;
 
     private:
 
@@ -335,9 +333,9 @@ namespace xt
 
     template <class D>
     template <class It>
-    inline It xcontainer<D>::data_xend_impl(It end, layout_type l) const noexcept
+    inline It xcontainer<D>::data_xend_impl(It begin, layout_type l, size_type offset) const noexcept
     {
-        return strided_data_end(*this, end, l);
+        return strided_data_end(*this, begin, l, offset);
     }
 
     template <class D>
@@ -375,7 +373,7 @@ namespace xt
      * Returns the number of dimensions of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::dimension() const noexcept -> size_type
+    constexpr auto xcontainer<D>::dimension() const noexcept -> size_type
     {
         return shape().size();
     }
@@ -384,7 +382,7 @@ namespace xt
      * Returns the shape of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::shape() const noexcept -> const inner_shape_type&
+    constexpr auto xcontainer<D>::shape() const noexcept -> const inner_shape_type&
     {
         return derived_cast().shape_impl();
     }
@@ -393,7 +391,7 @@ namespace xt
      * Returns the strides of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::strides() const noexcept -> const inner_strides_type&
+    constexpr auto xcontainer<D>::strides() const noexcept -> const inner_strides_type&
     {
         return derived_cast().strides_impl();
     }
@@ -402,10 +400,11 @@ namespace xt
      * Returns the backstrides of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::backstrides() const noexcept -> const inner_backstrides_type&
+    constexpr auto xcontainer<D>::backstrides() const noexcept -> const inner_backstrides_type&
     {
         return derived_cast().backstrides_impl();
     }
+
     //@}
 
     /**
@@ -421,7 +420,14 @@ namespace xt
     template <class T>
     inline void xcontainer<D>::fill(const T& value)
     {
-        std::fill(storage_begin(), storage_end(), value);
+        if (contiguous_layout)
+        {
+            std::fill(this->linear_begin(), this->linear_end(), value);
+        }
+        else
+        {
+            std::fill(this->begin(), this->end(), value);
+        }
     }
 
     /**
@@ -436,7 +442,7 @@ namespace xt
     {
         XTENSOR_TRY(check_index(shape(), args...));
         XTENSOR_CHECK_DIMENSION(shape(), args...);
-        size_type index = xt::data_offset<size_type>(strides(), static_cast<std::ptrdiff_t>(args)...);
+        size_type index = xt::data_offset<size_type>(strides(), args...);
         return storage()[index];
     }
 
@@ -452,44 +458,10 @@ namespace xt
     {
         XTENSOR_TRY(check_index(shape(), args...));
         XTENSOR_CHECK_DIMENSION(shape(), args...);
-        size_type index = xt::data_offset<size_type>(strides(), static_cast<std::ptrdiff_t>(args)...);
+        size_type index = xt::data_offset<size_type>(strides(), args...);
         return storage()[index];
     }
 
-    /**
-     * Returns a reference to the element at the specified position in the container,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the container. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the container.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class D>
-    template <class... Args>
-    inline auto xcontainer<D>::at(Args... args) -> reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the container,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the container. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the container.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class D>
-    template <class... Args>
-    inline auto xcontainer<D>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
     /**
      * Returns a reference to the element at the specified position in the container.
      * @param args a list of indices specifying the position in the container. Indices
@@ -498,22 +470,25 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>
     inline auto xcontainer<D>::unchecked(Args... args) -> reference
     {
-        size_type index = xt::unchecked_data_offset<size_type, static_layout>(strides(), static_cast<std::ptrdiff_t>(args)...);
+        size_type index = xt::unchecked_data_offset<size_type, static_layout>(
+            strides(),
+            static_cast<std::ptrdiff_t>(args)...
+        );
         return storage()[index];
     }
 
@@ -525,79 +500,28 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>
     inline auto xcontainer<D>::unchecked(Args... args) const -> const_reference
     {
-        size_type index = xt::unchecked_data_offset<size_type, static_layout>(strides(), static_cast<std::ptrdiff_t>(args)...);
+        size_type index = xt::unchecked_data_offset<size_type, static_layout>(
+            strides(),
+            static_cast<std::ptrdiff_t>(args)...
+        );
         return storage()[index];
     }
 
-    /**
-     * Returns a reference to the element at the specified position in the container.
-     * @param index a 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.
-     */
-    template <class D>
-    template <class S>
-    inline auto xcontainer<D>::operator[](const S& index)
-        -> disable_integral_t<S, reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class D>
-    template <class I>
-    inline auto xcontainer<D>::operator[](std::initializer_list<I> index) -> reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class D>
-    inline auto xcontainer<D>::operator[](size_type i) -> reference
-    {
-        return operator()(i);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the container.
-     * @param index a 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.
-     */
-    template <class D>
-    template <class S>
-    inline auto xcontainer<D>::operator[](const S& index) const
-        -> disable_integral_t<S, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class D>
-    template <class I>
-    inline auto xcontainer<D>::operator[](std::initializer_list<I> index) const -> const_reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class D>
-    inline auto xcontainer<D>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
-    }
-
     /**
      * Returns a reference to the element at the specified position in the container.
      * @param first iterator starting the sequence of indices
@@ -653,18 +577,18 @@ namespace xt
      * container is empty (data() is not is not dereferenceable in that case)
      */
     template <class D>
-    inline auto xcontainer<D>::data() noexcept -> value_type*
+    inline auto xcontainer<D>::data() noexcept -> pointer
     {
         return storage().data();
     }
 
     /**
-    * 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)
-    */
+     * 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)
+     */
     template <class D>
-    inline auto xcontainer<D>::data() const noexcept -> const value_type*
+    inline auto xcontainer<D>::data() const noexcept -> const_pointer
     {
         return storage().data();
     }
@@ -677,6 +601,7 @@ namespace xt
     {
         return size_type(0);
     }
+
     //@}
 
     /**
@@ -705,13 +630,13 @@ namespace xt
     template <class S>
     inline bool xcontainer<D>::has_linear_assign(const S& str) const noexcept
     {
-        return str.size() == strides().size() &&
-            std::equal(str.cbegin(), str.cend(), strides().begin());
+        return str.size() == strides().size() && std::equal(str.cbegin(), str.cend(), strides().begin());
     }
+
     //@}
 
     template <class D>
-    inline auto xcontainer<D>::derived_cast() const & noexcept -> const derived_type&
+    inline auto xcontainer<D>::derived_cast() const& noexcept -> const derived_type&
     {
         return *static_cast<const derived_type*>(this);
     }
@@ -734,6 +659,32 @@ namespace xt
         return storage()[i];
     }
 
+    /**
+     * Returns a reference to the element at the specified position in the container
+     * storage (as if it was one dimensional).
+     * @param i index specifying the position in the storage.
+     * Must be smaller than the number of elements in the container.
+     */
+    template <class D>
+    inline auto xcontainer<D>::flat(size_type i) -> reference
+    {
+        XTENSOR_ASSERT(i < size());
+        return storage()[i];
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the container
+     * storage (as if it was one dimensional).
+     * @param i index specifying the position in the storage.
+     * Must be smaller than the number of elements in the container.
+     */
+    template <class D>
+    inline auto xcontainer<D>::flat(size_type i) const -> const_reference
+    {
+        XTENSOR_ASSERT(i < size());
+        return storage()[i];
+    }
+
     /***************
      * stepper api *
      ***************/
@@ -751,7 +702,7 @@ namespace xt
     inline auto xcontainer<D>::stepper_end(const S& shape, layout_type l) noexcept -> stepper
     {
         size_type offset = shape.size() - dimension();
-        return stepper(static_cast<derived_type*>(this), data_xend(l), offset);
+        return stepper(static_cast<derived_type*>(this), data_xend(l, offset), offset);
     }
 
     template <class D>
@@ -767,7 +718,7 @@ namespace xt
     inline auto xcontainer<D>::stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
     {
         size_type offset = shape.size() - dimension();
-        return const_stepper(static_cast<const derived_type*>(this), data_xend(l), offset);
+        return const_stepper(static_cast<const derived_type*>(this), data_xend(l, offset), offset);
     }
 
     template <class D>
@@ -779,19 +730,20 @@ namespace xt
     template <class D>
     inline auto xcontainer<D>::data_xbegin() const noexcept -> const_container_iterator
     {
-        return storage().begin();
+        return storage().cbegin();
     }
 
     template <class D>
-    inline auto xcontainer<D>::data_xend(layout_type l) noexcept -> container_iterator
+    inline auto xcontainer<D>::data_xend(layout_type l, size_type offset) noexcept -> container_iterator
     {
-        return data_xend_impl(storage().end(), l);
+        return data_xend_impl(storage().begin(), l, offset);
     }
 
     template <class D>
-    inline auto xcontainer<D>::data_xend(layout_type l) const noexcept -> const_container_iterator
+    inline auto xcontainer<D>::data_xend(layout_type l, size_type offset) const noexcept
+        -> const_container_iterator
     {
-        return data_xend_impl(storage().end(), l);
+        return data_xend_impl(storage().cbegin(), l, offset);
     }
 
     template <class D>
@@ -799,86 +751,86 @@ namespace xt
     inline void xcontainer<D>::store_simd(size_type i, const simd& e)
     {
         using align_mode = driven_align_mode_t<alignment, data_alignment>;
-        xsimd::store_simd<value_type, typename simd::value_type>(&(storage()[i]), e, align_mode());
+        xt_simd::store_as(std::addressof(storage()[i]), e, align_mode());
     }
 
     template <class D>
     template <class alignment, class requested_type, std::size_t N>
     inline auto xcontainer<D>::load_simd(size_type i) const
-        -> simd_return_type<requested_type>
+        -> container_simd_return_type_t<storage_type, value_type, requested_type>
     {
         using align_mode = driven_align_mode_t<alignment, data_alignment>;
-        return xsimd::load_simd<value_type, requested_type>(&(storage()[i]), align_mode());
+        return xt_simd::load_as<requested_type>(std::addressof(storage()[i]), align_mode());
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_begin() noexcept -> storage_iterator
+    inline auto xcontainer<D>::linear_begin() noexcept -> linear_iterator
     {
         return storage().begin();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_end() noexcept -> storage_iterator
+    inline auto xcontainer<D>::linear_end() noexcept -> linear_iterator
     {
         return storage().end();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_begin() const noexcept -> const_storage_iterator
+    inline auto xcontainer<D>::linear_begin() const noexcept -> const_linear_iterator
     {
         return storage().begin();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_end() const noexcept -> const_storage_iterator
+    inline auto xcontainer<D>::linear_end() const noexcept -> const_linear_iterator
     {
         return storage().cend();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_cbegin() const noexcept -> const_storage_iterator
+    inline auto xcontainer<D>::linear_cbegin() const noexcept -> const_linear_iterator
     {
         return storage().cbegin();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_cend() const noexcept -> const_storage_iterator
+    inline auto xcontainer<D>::linear_cend() const noexcept -> const_linear_iterator
     {
         return storage().cend();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_rbegin() noexcept -> reverse_storage_iterator
+    inline auto xcontainer<D>::linear_rbegin() noexcept -> reverse_linear_iterator
     {
         return storage().rbegin();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_rend() noexcept -> reverse_storage_iterator
+    inline auto xcontainer<D>::linear_rend() noexcept -> reverse_linear_iterator
     {
         return storage().rend();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_rbegin() const noexcept -> const_reverse_storage_iterator
+    inline auto xcontainer<D>::linear_rbegin() const noexcept -> const_reverse_linear_iterator
     {
         return storage().rbegin();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_rend() const noexcept -> const_reverse_storage_iterator
+    inline auto xcontainer<D>::linear_rend() const noexcept -> const_reverse_linear_iterator
     {
         return storage().rend();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_crbegin() const noexcept -> const_reverse_storage_iterator
+    inline auto xcontainer<D>::linear_crbegin() const noexcept -> const_reverse_linear_iterator
     {
         return storage().crbegin();
     }
 
     template <class D>
-    inline auto xcontainer<D>::storage_crend() const noexcept -> const_reverse_storage_iterator
+    inline auto xcontainer<D>::linear_crend() const noexcept -> const_reverse_linear_iterator
     {
         return storage().crend();
     }
@@ -904,15 +856,26 @@ namespace xt
 
     template <class D>
     inline xstrided_container<D>::xstrided_container(inner_shape_type&& shape, inner_strides_type&& strides) noexcept
-        : base_type(), m_shape(std::move(shape)), m_strides(std::move(strides))
+        : base_type()
+        , m_shape(std::move(shape))
+        , m_strides(std::move(strides))
     {
         m_backstrides = xtl::make_sequence<inner_backstrides_type>(m_shape.size(), 0);
         adapt_strides(m_shape, m_strides, m_backstrides);
     }
 
     template <class D>
-    inline xstrided_container<D>::xstrided_container(inner_shape_type&& shape, inner_strides_type&& strides, inner_backstrides_type&& backstrides, layout_type&& layout) noexcept
-        : base_type(), m_shape(std::move(shape)), m_strides(std::move(strides)), m_backstrides(std::move(backstrides)), m_layout(std::move(layout))
+    inline xstrided_container<D>::xstrided_container(
+        inner_shape_type&& shape,
+        inner_strides_type&& strides,
+        inner_backstrides_type&& backstrides,
+        layout_type&& layout
+    ) noexcept
+        : base_type()
+        , m_shape(std::move(shape))
+        , m_strides(std::move(strides))
+        , m_backstrides(std::move(backstrides))
+        , m_layout(std::move(layout))
     {
     }
 
@@ -957,11 +920,43 @@ namespace xt
      * @return layout_type of the container
      */
     template <class D>
-    layout_type xstrided_container<D>::layout() const noexcept
+    inline layout_type xstrided_container<D>::layout() const noexcept
     {
         return m_layout;
     }
 
+    template <class D>
+    inline bool xstrided_container<D>::is_contiguous() const noexcept
+    {
+        using str_type = typename inner_strides_type::value_type;
+        auto is_zero = [](auto i)
+        {
+            return i == 0;
+        };
+        if (!is_contiguous_container<storage_type>::value)
+        {
+            return false;
+        }
+        // We need to make sure the inner-most non-zero stride is one.
+        // Trailing zero strides are ignored because they indicate bradcasted dimensions.
+        if (m_layout == layout_type::row_major)
+        {
+            auto it = std::find_if_not(m_strides.rbegin(), m_strides.rend(), is_zero);
+            // If the array has strides of zero, it is a constant, and therefore contiguous.
+            return it == m_strides.rend() || *it == str_type(1);
+        }
+        else if (m_layout == layout_type::column_major)
+        {
+            auto it = std::find_if_not(m_strides.begin(), m_strides.end(), is_zero);
+            // If the array has strides of zero, it is a constant, and therefore contiguous.
+            return it == m_strides.end() || *it == str_type(1);
+        }
+        else
+        {
+            return m_strides.empty();
+        }
+    }
+
     namespace detail
     {
         template <class C, class S>
@@ -977,10 +972,24 @@ namespace xt
             (void) size;
             XTENSOR_ASSERT_MSG(c.size() == size, "Trying to resize const data container with wrong size.");
         }
+
+        template <class S, class T>
+        constexpr bool check_resize_dimension(const S&, const T&)
+        {
+            return true;
+        }
+
+        template <class T, size_t N, class S>
+        constexpr bool check_resize_dimension(const std::array<T, N>&, const S& s)
+        {
+            return N == s.size();
+        }
     }
 
     /**
-     * resizes the container.
+     * Resizes the container.
+     * @warning Contrary to STL containers like std::vector, resize
+     * does NOT preserve the container elements.
      * @param shape the new shape
      * @param force force reshaping, even if the shape stays the same (default: false)
      */
@@ -988,14 +997,20 @@ namespace xt
     template <class S>
     inline void xstrided_container<D>::resize(S&& shape, bool force)
     {
+        XTENSOR_PRECONDITION(
+            detail::check_resize_dimension(m_shape, shape),
+            "cannot change the number of dimensions of xtensor"
+        );
         std::size_t dim = shape.size();
-        if (m_shape.size() != dim || !std::equal(std::begin(shape), std::end(shape), std::begin(m_shape)) || force)
+        if (m_shape.size() != dim || !std::equal(std::begin(shape), std::end(shape), std::begin(m_shape))
+            || force)
         {
             if (D::static_layout == layout_type::dynamic && m_layout == layout_type::dynamic)
             {
                 m_layout = XTENSOR_DEFAULT_LAYOUT;  // fall back to default layout
             }
-            m_shape = xtl::forward_sequence<shape_type>(shape);
+            m_shape = xtl::forward_sequence<shape_type, S>(shape);
+
             resize_container(m_strides, dim);
             resize_container(m_backstrides, dim);
             size_type data_size = compute_strides<D::static_layout>(m_shape, m_layout, m_strides, m_backstrides);
@@ -1004,7 +1019,9 @@ namespace xt
     }
 
     /**
-     * resizes the container.
+     * Resizes the container.
+     * @warning Contrary to STL containers like std::vector, resize
+     * does NOT preserve the container elements.
      * @param shape the new shape
      * @param l the new layout_type
      */
@@ -1012,9 +1029,16 @@ namespace xt
     template <class S>
     inline void xstrided_container<D>::resize(S&& shape, layout_type l)
     {
+        XTENSOR_ASSERT_MSG(
+            detail::check_resize_dimension(m_shape, shape),
+            "cannot change the number of dimensions of xtensor"
+        )
         if (base_type::static_layout != layout_type::dynamic && l != base_type::static_layout)
         {
-            throw std::runtime_error("Cannot change layout_type if template parameter not layout_type::dynamic.");
+            XTENSOR_THROW(
+                std::runtime_error,
+                "Cannot change layout_type if template parameter not layout_type::dynamic."
+            );
         }
         m_layout = l;
         resize(std::forward<S>(shape), true);
@@ -1022,6 +1046,8 @@ namespace xt
 
     /**
      * Resizes the container.
+     * @warning Contrary to STL containers like std::vector, resize
+     * does NOT preserve the container elements.
      * @param shape the new shape
      * @param strides the new strides
      */
@@ -1029,11 +1055,18 @@ namespace xt
     template <class S>
     inline void xstrided_container<D>::resize(S&& shape, const strides_type& strides)
     {
+        XTENSOR_ASSERT_MSG(
+            detail::check_resize_dimension(m_shape, shape),
+            "cannot change the number of dimensions of xtensor"
+        )
         if (base_type::static_layout != layout_type::dynamic)
         {
-            throw std::runtime_error("Cannot resize with custom strides when layout() is != layout_type::dynamic.");
+            XTENSOR_THROW(
+                std::runtime_error,
+                "Cannot resize with custom strides when layout() is != layout_type::dynamic."
+            );
         }
-        m_shape = xtl::forward_sequence<shape_type>(shape);
+        m_shape = xtl::forward_sequence<shape_type, S>(shape);
         m_strides = strides;
         resize_container(m_backstrides, m_strides.size());
         adapt_strides(m_shape, m_strides, m_backstrides);
@@ -1042,24 +1075,52 @@ namespace xt
     }
 
     /**
-     * Reshapes the container and keeps old elements
+     * 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`.
+     * @code{.cpp}
+     * xt::xarray<int> a = { 1, 2, 3, 4, 5, 6, 7, 8 };
+     * a.reshape({-1, 4});
+     * //a.shape() is {2, 4}
+     * @endcode
      * @param shape the new shape (has to have same number of elements as the original container)
      * @param layout the layout to compute the strides (defaults to static layout of the container,
      *               or for a container with dynamic layout to XTENSOR_DEFAULT_LAYOUT)
      */
     template <class D>
     template <class S>
-    inline void xstrided_container<D>::reshape(S&& shape, layout_type layout){
-        reshape_impl(std::forward<S>(shape), std::is_signed<std::decay_t<typename std::decay_t<S>::value_type>>(), std::forward<layout_type>(layout));
+    inline auto& xstrided_container<D>::reshape(S&& shape, layout_type layout) &
+    {
+        reshape_impl(
+            std::forward<S>(shape),
+            xtl::is_signed<std::decay_t<typename std::decay_t<S>::value_type>>(),
+            std::forward<layout_type>(layout)
+        );
+        return this->derived_cast();
+    }
+
+    template <class D>
+    template <class T>
+    inline auto& xstrided_container<D>::reshape(std::initializer_list<T> shape, layout_type layout) &
+    {
+        using sh_type = rebind_container_t<T, shape_type>;
+        sh_type sh = xtl::make_sequence<sh_type>(shape.size());
+        std::copy(shape.begin(), shape.end(), sh.begin());
+        reshape_impl(std::move(sh), xtl::is_signed<T>(), std::forward<layout_type>(layout));
+        return this->derived_cast();
     }
 
     template <class D>
     template <class S>
-    inline void xstrided_container<D>::reshape_impl(S&& shape, std::false_type /* is unsigned */, layout_type layout)
+    inline void
+    xstrided_container<D>::reshape_impl(S&& shape, std::false_type /* is unsigned */, layout_type layout)
     {
         if (compute_size(shape) != this->size())
         {
-            throw std::runtime_error("Cannot reshape with incorrect number of elements. Do you mean to resize?");
+            XTENSOR_THROW(
+                std::runtime_error,
+                "Cannot reshape with incorrect number of elements. Do you mean to resize?"
+            );
         }
         if (D::static_layout == layout_type::dynamic && layout == layout_type::dynamic)
         {
@@ -1067,47 +1128,63 @@ namespace xt
         }
         if (D::static_layout != layout_type::dynamic && layout != D::static_layout)
         {
-            throw std::runtime_error("Cannot reshape with different layout if static layout != dynamic.");
+            XTENSOR_THROW(std::runtime_error, "Cannot reshape with different layout if static layout != dynamic.");
         }
         m_layout = layout;
-        m_shape = xtl::forward_sequence<shape_type>(shape);
+        m_shape = xtl::forward_sequence<shape_type, S>(shape);
         resize_container(m_strides, m_shape.size());
         resize_container(m_backstrides, m_shape.size());
         compute_strides<D::static_layout>(m_shape, m_layout, m_strides, m_backstrides);
     }
+
     template <class D>
     template <class S>
-    inline void xstrided_container<D>::reshape_impl(S&& _shape, std::true_type /* is signed */, layout_type layout)
+    inline void
+    xstrided_container<D>::reshape_impl(S&& _shape, std::true_type /* is signed */, layout_type layout)
     {
-        using value_type = typename std::decay_t<S>::value_type;
-        if (this->size() % compute_size(_shape))
+        using tmp_value_type = typename std::decay_t<S>::value_type;
+        auto new_size = compute_size(_shape);
+        if (this->size() % new_size)
         {
-            throw std::runtime_error("Negative axis size cannot be inferred. Shape mismatch.");
+            XTENSOR_THROW(std::runtime_error, "Negative axis size cannot be inferred. Shape mismatch.");
         }
-        std::decay_t<S> shape = _shape; 
-        value_type accumulator = 1;
+        std::decay_t<S> shape = _shape;
+        tmp_value_type accumulator = 1;
         std::size_t neg_idx = 0;
         std::size_t i = 0;
-        for(auto it = shape.begin(); it != shape.end(); ++it, i++)
+        for (auto it = shape.begin(); it != shape.end(); ++it, i++)
         {
             auto&& dim = *it;
-            if(dim < 0)
+            if (dim < 0)
             {
                 XTENSOR_ASSERT(dim == -1 && !neg_idx);
                 neg_idx = i;
             }
             accumulator *= dim;
         }
-        if(accumulator < 0)
+        if (accumulator < 0)
+        {
+            shape[neg_idx] = static_cast<tmp_value_type>(this->size()) / std::abs(accumulator);
+        }
+        else if (this->size() != new_size)
         {
-            shape[neg_idx] = static_cast<value_type>(this->size()) / std::abs(accumulator);
+            XTENSOR_THROW(
+                std::runtime_error,
+                "Cannot reshape with incorrect number of elements. Do you mean to resize?"
+            );
         }
         m_layout = layout;
-        m_shape = xtl::forward_sequence<shape_type>(shape);
+        m_shape = xtl::forward_sequence<shape_type, S>(shape);
         resize_container(m_strides, m_shape.size());
         resize_container(m_backstrides, m_shape.size());
         compute_strides<D::static_layout>(m_shape, m_layout, m_strides, m_backstrides);
     }
+
+    template <class D>
+    inline auto xstrided_container<D>::mutable_layout() noexcept -> layout_type&
+    {
+        return m_layout;
+    }
 }
 
 #endif
diff --git a/include/xtensor/xfixed.hpp b/include/xtensor/containers/xfixed.hpp
similarity index 56%
rename from include/xtensor/xfixed.hpp
rename to include/xtensor/containers/xfixed.hpp
index 89e5eed26..e1b02867d 100644
--- a/include/xtensor/xfixed.hpp
+++ b/include/xtensor/containers/xfixed.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FIXED_HPP
 #define XTENSOR_FIXED_HPP
@@ -13,12 +14,14 @@
 #include <array>
 #include <cstddef>
 #include <utility>
-#include <vector>
 
-#include "xcontainer.hpp"
-#include "xstrides.hpp"
-#include "xstorage.hpp"
-#include "xsemantic.hpp"
+#include <xtl/xsequence.hpp>
+
+#include "../containers/xcontainer.hpp"
+#include "../containers/xstorage.hpp"
+#include "../core/xsemantic.hpp"
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_config.hpp"
 
 namespace xtl
 {
@@ -46,13 +49,13 @@ namespace xt
      * xfixed declaration *
      **********************/
 
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     class xfixed_container;
 
     namespace detail
     {
         /**************************************************************************************
-           The following is something we can currently only dream about -- for when we drop 
+           The following is something we can currently only dream about -- for when we drop
            support for a lot of the old compilers (e.g. GCC 4.9, MSVC 2017 ;)
 
         template <class T>
@@ -95,39 +98,66 @@ namespace xt
         template <std::size_t I, std::size_t Y, std::size_t... X>
         struct calculate_stride<layout_type::column_major, I, Y, X...>
         {
-            constexpr static std::ptrdiff_t value = Y * calculate_stride<layout_type::column_major, I - 1, X...>::value;
+            static constexpr std::ptrdiff_t value = Y
+                                                    * calculate_stride<layout_type::column_major, I - 1, X...>::value;
         };
 
         template <std::size_t Y, std::size_t... X>
         struct calculate_stride<layout_type::column_major, 0, Y, X...>
         {
-            constexpr static std::ptrdiff_t value = 1;
+            static constexpr std::ptrdiff_t value = 1;
         };
 
         template <std::size_t I, std::size_t... X>
         struct calculate_stride_row_major
         {
-            constexpr static std::ptrdiff_t value = at<sizeof...(X) - I, X...>::value * calculate_stride_row_major<I - 1, X...>::value;
+            static constexpr std::ptrdiff_t value = at<sizeof...(X) - I, X...>::value
+                                                    * calculate_stride_row_major<I - 1, X...>::value;
         };
 
         template <std::size_t... X>
         struct calculate_stride_row_major<0, X...>
         {
-            constexpr static std::ptrdiff_t value = 1;
+            static constexpr std::ptrdiff_t value = 1;
         };
 
         template <std::size_t I, std::size_t... X>
         struct calculate_stride<layout_type::row_major, I, X...>
         {
-            constexpr static std::ptrdiff_t value = calculate_stride_row_major<sizeof...(X) - I - 1, X...>::value;
+            static constexpr std::ptrdiff_t value = calculate_stride_row_major<sizeof...(X) - I - 1, X...>::value;
         };
 
+        namespace workaround
+        {
+            template <layout_type L, size_t I, class SEQ>
+            struct computed_strides;
+
+            template <layout_type L, size_t I, size_t... X>
+            struct computed_strides<L, I, std::index_sequence<X...>>
+            {
+                static constexpr std::ptrdiff_t value = calculate_stride<L, I, X...>::value;
+            };
+
+            template <layout_type L, size_t I, class SEQ>
+            constexpr std::ptrdiff_t get_computed_strides(bool cond)
+            {
+                return cond ? 0 : computed_strides<L, I, SEQ>::value;
+            }
+        }
+
         template <layout_type L, class R, std::size_t... X, std::size_t... I>
         constexpr R get_strides_impl(const xt::fixed_shape<X...>& shape, std::index_sequence<I...>)
         {
-            static_assert((L == layout_type::row_major) || (L == layout_type::column_major),
-                          "Layout not supported for fixed array");
+            static_assert(
+                (L == layout_type::row_major) || (L == layout_type::column_major),
+                "Layout not supported for fixed array"
+            );
+#if (_MSC_VER >= 1910)
+            using temp_type = std::index_sequence<X...>;
+            return R({workaround::get_computed_strides<L, I, temp_type>(shape[I] == 1)...});
+#else
             return R({shape[I] == 1 ? 0 : calculate_stride<L, I, X...>::value...});
+#endif
         }
 
         template <class S, class T, std::size_t... I>
@@ -142,20 +172,20 @@ namespace xt
         template <std::size_t Y, std::size_t... X>
         struct fixed_compute_size_impl<Y, X...>
         {
-            constexpr static std::size_t value = Y * fixed_compute_size_impl<X...>::value;
+            static constexpr std::size_t value = Y * fixed_compute_size_impl<X...>::value;
         };
 
         template <std::size_t X>
         struct fixed_compute_size_impl<X>
         {
-            constexpr static std::size_t value = X;
+            static constexpr std::size_t value = X;
         };
 
         template <>
         struct fixed_compute_size_impl<>
         {
             // support for 0D xtensor fixed (empty shape = xshape<>)
-            constexpr static std::size_t value = 1;
+            static constexpr std::size_t value = 1;
         };
 
         // TODO unify with constexpr compute_size when dropping MSVC 2015
@@ -165,7 +195,7 @@ namespace xt
         template <std::size_t... X>
         struct fixed_compute_size<xt::fixed_shape<X...>>
         {
-            constexpr static std::size_t value = fixed_compute_size_impl<X...>::value;
+            static constexpr std::size_t value = fixed_compute_size_impl<X...>::value;
         };
 
         template <class V, std::size_t... X>
@@ -200,8 +230,7 @@ namespace xt
     template <class S, class T>
     constexpr T get_backstrides(const S& shape, const T& strides) noexcept
     {
-        return detail::get_backstrides_impl(shape, strides,
-                                            std::make_index_sequence<std::tuple_size<T>::value>{});
+        return detail::get_backstrides_impl(shape, strides, std::make_index_sequence<std::tuple_size<T>::value>{});
     }
 
     template <class V, class S>
@@ -216,8 +245,8 @@ namespace xt
     template <class V, class S>
     using get_init_type_t = typename get_init_type<V, S>::type;
 
-    template <class ET, class S, layout_type L, class Tag>
-    struct xcontainer_inner_types<xfixed_container<ET, S, L, Tag>>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    struct xcontainer_inner_types<xfixed_container<ET, S, L, SH, Tag>>
     {
         using shape_type = S;
         using inner_shape_type = typename S::cast_type;
@@ -227,20 +256,18 @@ namespace xt
         using inner_backstrides_type = backstrides_type;
 
         // NOTE: 0D (S::size() == 0) results in storage for 1 element (scalar)
-    #if defined(_MSC_VER) && _MSC_VER < 1910 && !defined(_WIN64)
-        // WORKAROUND FOR MSVC 2015 32 bit, fallback to unaligned container for 0D scalar case
-        using storage_type = std::array<ET, detail::fixed_compute_size<S>::value>;
-    #else
         using storage_type = aligned_array<ET, detail::fixed_compute_size<S>::value>;
-    #endif
 
-        using temporary_type = xfixed_container<ET, S, L, Tag>;
+        using reference = typename storage_type::reference;
+        using const_reference = typename storage_type::const_reference;
+        using size_type = typename storage_type::size_type;
+        using temporary_type = xfixed_container<ET, S, L, SH, Tag>;
         static constexpr layout_type layout = L;
     };
 
-    template <class ET, class S, layout_type L, class Tag>
-    struct xiterable_inner_types<xfixed_container<ET, S, L, Tag>>
-        : xcontainer_iterable_types<xfixed_container<ET, S, L, Tag>>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    struct xiterable_inner_types<xfixed_container<ET, S, L, SH, Tag>>
+        : xcontainer_iterable_types<xfixed_container<ET, S, L, SH, Tag>>
     {
     };
 
@@ -253,18 +280,19 @@ namespace xt
      * with tensor semantic and fixed dimension
      *
      * @tparam ET The type of the elements.
-     * @tparam S The xshape template paramter of the container. 
+     * @tparam S The xshape template paramter of the container.
      * @tparam L The layout_type of the tensor.
+     * @tparam SH Wether the tensor can be used as a shared expression.
      * @tparam Tag The expression tag.
      * @sa xtensor_fixed
      */
-    template <class ET, class S, layout_type L, class Tag>
-    class xfixed_container : public xcontainer<xfixed_container<ET, S, L, Tag>>,
-                             public xcontainer_semantic<xfixed_container<ET, S, L, Tag>>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    class xfixed_container : public xcontainer<xfixed_container<ET, S, L, SH, Tag>>,
+                             public xcontainer_semantic<xfixed_container<ET, S, L, SH, Tag>>
     {
     public:
 
-        using self_type = xfixed_container<ET, S, L, Tag>;
+        using self_type = xfixed_container<ET, S, L, SH, Tag>;
         using base_type = xcontainer<self_type>;
         using semantic_base = xcontainer_semantic<self_type>;
 
@@ -283,16 +311,17 @@ namespace xt
         using temporary_type = typename semantic_base::temporary_type;
         using expression_tag = Tag;
 
-        constexpr static std::size_t N = std::tuple_size<shape_type>::value;
+        static constexpr std::size_t N = std::tuple_size<shape_type>::value;
+        static constexpr std::size_t rank = N;
 
         xfixed_container() = default;
         xfixed_container(const value_type& v);
         explicit xfixed_container(const inner_shape_type& shape, layout_type l = L);
         explicit xfixed_container(const inner_shape_type& shape, value_type v, layout_type l = L);
 
-        // remove this enable_if when removing the other value_type constructor
-        template <class IX = std::integral_constant<std::size_t, N>, class EN = std::enable_if_t<IX::value != 0, int>>
-        xfixed_container(nested_initializer_list_t<value_type, N> t);
+        template <class IX = std::integral_constant<std::size_t, N>>
+        xfixed_container(nested_initializer_list_t<value_type, N> t)
+            requires(IX::value != 0);
 
         ~xfixed_container() = default;
 
@@ -319,12 +348,13 @@ namespace xt
         void resize(ST&& shape, const strides_type& strides) const;
 
         template <class ST = std::array<std::size_t, N>>
-        void reshape(ST&& shape, layout_type layout = L) const;
+        const auto& reshape(ST&& shape, layout_type layout = L) const;
 
         template <class ST>
         bool broadcast_shape(ST& s, bool reuse_cache = false) const;
 
         constexpr layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
 
     private:
 
@@ -332,54 +362,46 @@ namespace xt
 
         XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_shape_type m_shape = S();
         XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_strides_type m_strides = get_strides<L, inner_strides_type>(S());
-        XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_backstrides_type m_backstrides = get_backstrides(m_shape, m_strides);
+        XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_backstrides_type
+            m_backstrides = get_backstrides(m_shape, m_strides);
 
         storage_type& storage_impl() noexcept;
         const storage_type& storage_impl() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides_impl() const noexcept;
+        constexpr const inner_shape_type& shape_impl() const noexcept;
+        constexpr const inner_strides_type& strides_impl() const noexcept;
+        constexpr const inner_backstrides_type& backstrides_impl() const noexcept;
 
-        friend class xcontainer<xfixed_container<ET, S, L, Tag>>;
+        friend class xcontainer<xfixed_container<ET, S, L, SH, Tag>>;
     };
 
-#ifdef XTENSOR_HAS_CONSTEXPR_ENHANCED
-    // Out of line definitions to prevent linker errors prior to C++17
-    template <class ET, class S, layout_type L, class Tag>
-    constexpr typename xfixed_container<ET, S, L, Tag>::inner_shape_type xfixed_container<ET, S, L, Tag>::m_shape;
-
-    template <class ET, class S, layout_type L, class Tag>
-    constexpr typename xfixed_container<ET, S, L, Tag>::inner_strides_type xfixed_container<ET, S, L, Tag>::m_strides;
-
-    template <class ET, class S, layout_type L, class Tag>
-    constexpr typename xfixed_container<ET, S, L, Tag>::inner_backstrides_type xfixed_container<ET, S, L, Tag>::m_backstrides;
-#endif
-
     /****************************************
      * xfixed_container_adaptor declaration *
      ****************************************/
 
-    template <class EC, class S, layout_type L, class Tag>
+    template <class EC, class S, layout_type L, bool SH, class Tag>
     class xfixed_adaptor;
 
-    template <class EC, class S, layout_type L, class Tag>
-    struct xcontainer_inner_types<xfixed_adaptor<EC, S, L, Tag>>
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    struct xcontainer_inner_types<xfixed_adaptor<EC, S, L, SH, Tag>>
     {
         using storage_type = std::remove_reference_t<EC>;
+        using reference = typename storage_type::reference;
+        using const_reference = typename storage_type::const_reference;
+        using size_type = typename storage_type::size_type;
         using shape_type = S;
         using inner_shape_type = typename S::cast_type;
         using strides_type = get_strides_t<inner_shape_type>;
         using backstrides_type = strides_type;
         using inner_strides_type = strides_type;
         using inner_backstrides_type = backstrides_type;
-        using temporary_type = xfixed_container<typename storage_type::value_type, S, L, Tag>;
+        using temporary_type = xfixed_container<typename storage_type::value_type, S, L, SH, Tag>;
         static constexpr layout_type layout = L;
     };
 
-    template <class EC, class S, layout_type L, class Tag>
-    struct xiterable_inner_types<xfixed_adaptor<EC, S, L, Tag>>
-        : xcontainer_iterable_types<xfixed_adaptor<EC, S, L, Tag>>
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    struct xiterable_inner_types<xfixed_adaptor<EC, S, L, SH, Tag>>
+        : xcontainer_iterable_types<xfixed_adaptor<EC, S, L, SH, Tag>>
     {
     };
 
@@ -396,17 +418,18 @@ namespace xt
      * @tparam EC The closure for the container type to adapt.
      * @tparam S The xshape template parameter for the fixed shape of the adaptor
      * @tparam L The layout_type of the adaptor.
+     * @tparam SH Wether the adaptor can be used as a shared expression.
      * @tparam Tag The expression tag.
      */
-    template <class EC, class S, layout_type L, class Tag>
-    class xfixed_adaptor : public xcontainer<xfixed_adaptor<EC, S, L, Tag>>,
-                           public xcontainer_semantic<xfixed_adaptor<EC, S, L, Tag>>
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    class xfixed_adaptor : public xcontainer<xfixed_adaptor<EC, S, L, SH, Tag>>,
+                           public xcontainer_semantic<xfixed_adaptor<EC, S, L, SH, Tag>>
     {
     public:
 
         using container_closure_type = EC;
 
-        using self_type = xfixed_adaptor<EC, S, L, Tag>;
+        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;
@@ -419,7 +442,7 @@ namespace xt
         using temporary_type = typename semantic_base::temporary_type;
         using expression_tag = Tag;
 
-        constexpr static std::size_t N = S::size();
+        static constexpr std::size_t N = S::size();
 
         xfixed_adaptor(storage_type&& data);
         xfixed_adaptor(const storage_type& data);
@@ -447,12 +470,13 @@ namespace xt
         void resize(ST&& shape, const strides_type& strides) const;
 
         template <class ST = std::array<std::size_t, N>>
-        void reshape(ST&& shape, layout_type layout = L) const;
+        const auto& reshape(ST&& shape, layout_type layout = L) const;
 
         template <class ST>
         bool broadcast_shape(ST& s, bool reuse_cache = false) const;
 
         constexpr layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
 
     private:
 
@@ -460,30 +484,19 @@ namespace xt
 
         XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_shape_type m_shape = S();
         XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_strides_type m_strides = get_strides<L, inner_strides_type>(S());
-        XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_backstrides_type m_backstrides = get_backstrides(m_shape, m_strides);
+        XTENSOR_CONSTEXPR_ENHANCED_STATIC inner_backstrides_type
+            m_backstrides = get_backstrides(m_shape, m_strides);
 
         storage_type& storage_impl() noexcept;
         const storage_type& storage_impl() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides_impl() const noexcept;
+        constexpr const inner_shape_type& shape_impl() const noexcept;
+        constexpr const inner_strides_type& strides_impl() const noexcept;
+        constexpr const inner_backstrides_type& backstrides_impl() const noexcept;
 
-        friend class xcontainer<xfixed_adaptor<EC, S, L, Tag>>;
+        friend class xcontainer<xfixed_adaptor<EC, S, L, SH, Tag>>;
     };
 
-#ifdef XTENSOR_HAS_CONSTEXPR_ENHANCED
-    // Out of line definitions to prevent linker errors prior to C++17
-    template <class EC, class S, layout_type L, class Tag>
-    constexpr typename xfixed_adaptor<EC, S, L, Tag>::inner_shape_type xfixed_adaptor<EC, S, L, Tag>::m_shape;
-
-    template <class EC, class S, layout_type L, class Tag>
-    constexpr typename xfixed_adaptor<EC, S, L, Tag>::inner_strides_type xfixed_adaptor<EC, S, L, Tag>::m_strides;
-
-    template <class EC, class S, layout_type L, class Tag>
-    constexpr typename xfixed_adaptor<EC, S, L, Tag>::inner_backstrides_type xfixed_adaptor<EC, S, L, Tag>::m_backstrides;
-#endif
-
     /************************************
      * xfixed_container implementation *
      ************************************/
@@ -495,45 +508,49 @@ namespace xt
 
     /**
      * Create an uninitialized xfixed_container.
-     * Note this function is only provided for homogenity, and the shape & layout argument is
+     * Note this function is only provided for homogeneity, and the shape & layout argument is
      * disregarded (the template shape is always used).
      *
      * @param shape the shape of the xfixed_container (unused!)
      * @param l the layout_type of the xfixed_container (unused!)
      */
-    template <class ET, class S, layout_type L, class Tag>
-    inline xfixed_container<ET, S, L, Tag>::xfixed_container(const inner_shape_type& shape, layout_type l)
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    inline xfixed_container<ET, S, L, SH, Tag>::xfixed_container(const inner_shape_type& shape, layout_type l)
     {
-        (void)(shape);
-        (void)(l);
+        (void) (shape);
+        (void) (l);
         XTENSOR_ASSERT(shape.size() == N && std::equal(shape.begin(), shape.end(), m_shape.begin()));
         XTENSOR_ASSERT(L == l);
     }
 
-    template <class ET, class S, layout_type L, class Tag>
-    inline xfixed_container<ET, S, L, Tag>::xfixed_container(const value_type& v)
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    inline xfixed_container<ET, S, L, SH, Tag>::xfixed_container(const value_type& v)
     {
         if (this->size() != 1)
         {
-            throw std::runtime_error("wrong shape for scalar assignment (has to be xshape<>).");
+            XTENSOR_THROW(std::runtime_error, "wrong shape for scalar assignment (has to be xshape<>).");
         }
         m_storage[0] = v;
     }
 
     /**
      * Create an xfixed_container, and initialize with the value of v.
-     * Note, the shape argument to this function is only provided for homogenity,
+     * Note, the shape argument to this function is only provided for homogeneity,
      * and the shape argument is disregarded (the template shape is always used).
      *
      * @param shape the shape of the xfixed_container (unused!)
      * @param v the fill value
      * @param l the layout_type of the xfixed_container (unused!)
      */
-    template <class ET, class S, layout_type L, class Tag>
-    inline xfixed_container<ET, S, L, Tag>::xfixed_container(const inner_shape_type& shape, value_type v, layout_type l)
-    {
-        (void)(shape);
-        (void)(l);
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    inline xfixed_container<ET, S, L, SH, Tag>::xfixed_container(
+        const inner_shape_type& shape,
+        value_type v,
+        layout_type l
+    )
+    {
+        (void) (shape);
+        (void) (l);
         XTENSOR_ASSERT(shape.size() == N && std::equal(shape.begin(), shape.end(), m_shape.begin()));
         XTENSOR_ASSERT(L == l);
         std::fill(m_storage.begin(), m_storage.end(), v);
@@ -568,9 +585,9 @@ namespace xt
         };
     }
 
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline xfixed_container<ET, S, L, Tag> xfixed_container<ET, S, L, Tag>::from_shape(ST&& shape)
+    inline xfixed_container<ET, S, L, SH, Tag> xfixed_container<ET, S, L, SH, Tag>::from_shape(ST&& shape)
     {
         (void) shape;
         self_type tmp;
@@ -580,18 +597,24 @@ namespace xt
 
     /**
      * 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.
+     * 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.
      */
-    template <class ET, class S, layout_type L, class Tag>
-    template <class IX, class EN>
-    inline xfixed_container<ET, S, L, Tag>::xfixed_container(nested_initializer_list_t<value_type, N> t)
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    template <class IX>
+    inline xfixed_container<ET, S, L, SH, Tag>::xfixed_container(nested_initializer_list_t<value_type, N> t)
+        requires(IX::value != 0)
     {
-        XTENSOR_ASSERT_MSG(detail::check_initializer_list_shape<N>::run(t, this->shape()) == true, "initializer list shape does not match fixed shape");
-        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
+        XTENSOR_ASSERT_MSG(
+            detail::check_initializer_list_shape<N>::run(t, this->shape()) == true,
+            "initializer list shape does not match fixed shape"
+        );
+        constexpr auto tmp = layout_type::row_major;
+        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
     }
+
     //@}
 
     /**
@@ -601,9 +624,9 @@ namespace xt
     /**
      * The extended copy constructor.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class E>
-    inline xfixed_container<ET, S, L, Tag>::xfixed_container(const xexpression<E>& e)
+    inline xfixed_container<ET, S, L, SH, Tag>::xfixed_container(const xexpression<E>& e)
     {
         semantic_base::assign(e);
     }
@@ -611,23 +634,24 @@ namespace xt
     /**
      * The extended assignment operator.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class E>
-    inline auto xfixed_container<ET, S, L, Tag>::operator=(const xexpression<E>& e) -> self_type&
+    inline auto xfixed_container<ET, S, L, SH, Tag>::operator=(const xexpression<E>& e) -> self_type&
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     /**
      * Note that the xfixed_container **cannot** be resized. Attempting to resize with a different
      * size throws an assert in debug mode.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_container<ET, S, L, Tag>::resize(ST&& shape, bool) const
+    inline void xfixed_container<ET, S, L, SH, Tag>::resize(ST&& shape, bool) const
     {
-        (void)(shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
+        (void) (shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
         XTENSOR_ASSERT(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size());
     }
 
@@ -635,81 +659,97 @@ namespace xt
      * Note that the xfixed_container **cannot** be resized. Attempting to resize with a different
      * size throws an assert in debug mode.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_container<ET, S, L, Tag>::resize(ST&& shape, layout_type l) const
+    inline void xfixed_container<ET, S, L, SH, Tag>::resize(ST&& shape, layout_type l) const
     {
-        (void)(shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
-        (void)(l);
-        XTENSOR_ASSERT(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size() && L == l);
+        (void) (shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
+        (void) (l);
+        XTENSOR_ASSERT(
+            std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size() && L == l
+        );
     }
 
     /**
      * Note that the xfixed_container **cannot** be resized. Attempting to resize with a different
      * size throws an assert in debug mode.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_container<ET, S, L, Tag>::resize(ST&& shape, const strides_type& strides) const
+    inline void xfixed_container<ET, S, L, SH, Tag>::resize(ST&& shape, const strides_type& strides) const
     {
-        (void)(shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
-        (void)(strides);
+        (void) (shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
+        (void) (strides);
         XTENSOR_ASSERT(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size());
-        XTENSOR_ASSERT(std::equal(strides.begin(), strides.end(), m_strides.begin()) && strides.size() == m_strides.size());
+        XTENSOR_ASSERT(
+            std::equal(strides.begin(), strides.end(), m_strides.begin()) && strides.size() == m_strides.size()
+        );
     }
 
     /**
      * Note that the xfixed_container **cannot** be reshaped to a shape different from ``S``.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_container<ET, S, L, Tag>::reshape(ST&& shape, layout_type layout) const
+    inline const auto& xfixed_container<ET, S, L, SH, Tag>::reshape(ST&& shape, layout_type layout) const
     {
-        if (!(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size() && layout == L))
+        if (!(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size()
+              && layout == L))
         {
-            throw std::runtime_error("Trying to reshape xtensor_fixed with different shape or layout.");
+            XTENSOR_THROW(std::runtime_error, "Trying to reshape xtensor_fixed with different shape or layout.");
         }
+        return *this;
     }
 
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline bool xfixed_container<ET, S, L, Tag>::broadcast_shape(ST& shape, bool) const
+    inline bool xfixed_container<ET, S, L, SH, Tag>::broadcast_shape(ST& shape, bool) const
     {
         return xt::broadcast_shape(m_shape, shape);
     }
 
-    template <class ET, class S, layout_type L, class Tag>
-    constexpr layout_type xfixed_container<ET, S, L, Tag>::layout() const noexcept
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    constexpr layout_type xfixed_container<ET, S, L, SH, Tag>::layout() const noexcept
     {
         return base_type::static_layout;
     }
 
-    template <class ET, class S, layout_type L, class Tag>
-    inline auto xfixed_container<ET, S, L, Tag>::storage_impl() noexcept -> storage_type&
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    inline bool xfixed_container<ET, S, L, SH, Tag>::is_contiguous() const noexcept
+    {
+        using str_type = typename inner_strides_type::value_type;
+        return m_strides.empty() || (layout() == layout_type::row_major && m_strides.back() == str_type(1))
+               || (layout() == layout_type::column_major && m_strides.front() == str_type(1));
+    }
+
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    inline auto xfixed_container<ET, S, L, SH, Tag>::storage_impl() noexcept -> storage_type&
     {
         return m_storage;
     }
 
-    template <class ET, class S, layout_type L, class Tag>
-    inline auto xfixed_container<ET, S, L, Tag>::storage_impl() const noexcept -> const storage_type&
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    inline auto xfixed_container<ET, S, L, SH, Tag>::storage_impl() const noexcept -> const storage_type&
     {
         return m_storage;
     }
 
-    template <class ET, class S, layout_type L, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, Tag>::shape_impl() const noexcept -> const inner_shape_type&
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    constexpr auto xfixed_container<ET, S, L, SH, Tag>::shape_impl() const noexcept -> const inner_shape_type&
     {
         return m_shape;
     }
 
-    template <class ET, class S, layout_type L, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, Tag>::strides_impl() const noexcept -> const inner_strides_type&
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    constexpr auto xfixed_container<ET, S, L, SH, Tag>::strides_impl() const noexcept
+        -> const inner_strides_type&
     {
         return m_strides;
     }
 
-    template <class ET, class S, layout_type L, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, Tag>::backstrides_impl() const noexcept -> const inner_backstrides_type&
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    constexpr auto xfixed_container<ET, S, L, SH, Tag>::backstrides_impl() const noexcept
+        -> const inner_backstrides_type&
     {
         return m_backstrides;
     }
@@ -726,9 +766,10 @@ namespace xt
      * Constructs an xfixed_adaptor of the given stl-like container.
      * @param data the container to adapt
      */
-    template <class EC, class S, layout_type L, class Tag>
-    inline xfixed_adaptor<EC, S, L, Tag>::xfixed_adaptor(storage_type&& data)
-        : base_type(), m_storage(std::move(data))
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline xfixed_adaptor<EC, S, L, SH, Tag>::xfixed_adaptor(storage_type&& data)
+        : base_type()
+        , m_storage(std::move(data))
     {
     }
 
@@ -736,9 +777,10 @@ namespace xt
      * Constructs an xfixed_adaptor of the given stl-like container.
      * @param data the container to adapt
      */
-    template <class EC, class S, layout_type L, class Tag>
-    inline xfixed_adaptor<EC, S, L, Tag>::xfixed_adaptor(const storage_type& data)
-        : base_type(), m_storage(data)
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline xfixed_adaptor<EC, S, L, SH, Tag>::xfixed_adaptor(const storage_type& data)
+        : base_type()
+        , m_storage(data)
     {
     }
 
@@ -747,34 +789,37 @@ namespace xt
      * with the specified shape and layout_type.
      * @param data the container to adapt
      */
-    template <class EC, class S, layout_type L, class Tag>
+    template <class EC, class S, layout_type L, bool SH, class Tag>
     template <class D>
-    inline xfixed_adaptor<EC, S, L, Tag>::xfixed_adaptor(D&& data)
-        : base_type(), m_storage(std::forward<D>(data))
+    inline xfixed_adaptor<EC, S, L, SH, Tag>::xfixed_adaptor(D&& data)
+        : base_type()
+        , m_storage(std::forward<D>(data))
     {
     }
+
     //@}
 
-    template <class EC, class S, layout_type L, class Tag>
-    inline auto xfixed_adaptor<EC, S, L, Tag>::operator=(const xfixed_adaptor& rhs) -> self_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline auto xfixed_adaptor<EC, S, L, SH, Tag>::operator=(const xfixed_adaptor& rhs) -> self_type&
     {
         base_type::operator=(rhs);
         m_storage = rhs.m_storage;
         return *this;
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    inline auto xfixed_adaptor<EC, S, L, Tag>::operator=(xfixed_adaptor&& rhs) -> self_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline auto xfixed_adaptor<EC, S, L, SH, Tag>::operator=(xfixed_adaptor&& rhs) -> self_type&
     {
         base_type::operator=(std::move(rhs));
         m_storage = rhs.m_storage;
         return *this;
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    inline auto xfixed_adaptor<EC, S, L, Tag>::operator=(temporary_type&& rhs) -> self_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline auto xfixed_adaptor<EC, S, L, SH, Tag>::operator=(temporary_type&& rhs) -> self_type&
     {
-        m_storage = xtl::forward_sequence<storage_type>(std::move(rhs.storage()));
+        m_storage.resize(rhs.storage().size());
+        std::copy(rhs.storage().cbegin(), rhs.storage().cend(), m_storage.begin());
         return *this;
     }
 
@@ -785,23 +830,24 @@ namespace xt
     /**
      * The extended assignment operator.
      */
-    template <class EC, class S, layout_type L, class Tag>
+    template <class EC, class S, layout_type L, bool SH, class Tag>
     template <class E>
-    inline auto xfixed_adaptor<EC, S, L, Tag>::operator=(const xexpression<E>& e) -> self_type&
+    inline auto xfixed_adaptor<EC, S, L, SH, Tag>::operator=(const xexpression<E>& e) -> self_type&
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     /**
      * Note that the xfixed_adaptor **cannot** be resized. Attempting to resize with a different
      * size throws an assert in debug mode.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_adaptor<ET, S, L, Tag>::resize(ST&& shape, bool) const
+    inline void xfixed_adaptor<ET, S, L, SH, Tag>::resize(ST&& shape, bool) const
     {
-        (void)(shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
+        (void) (shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
         XTENSOR_ASSERT(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size());
     }
 
@@ -809,81 +855,97 @@ namespace xt
      * Note that the xfixed_adaptor **cannot** be resized. Attempting to resize with a different
      * size throws an assert in debug mode.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_adaptor<ET, S, L, Tag>::resize(ST&& shape, layout_type l) const
+    inline void xfixed_adaptor<ET, S, L, SH, Tag>::resize(ST&& shape, layout_type l) const
     {
-        (void)(shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
-        (void)(l);
-        XTENSOR_ASSERT(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size() && L == l);
+        (void) (shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
+        (void) (l);
+        XTENSOR_ASSERT(
+            std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size() && L == l
+        );
     }
 
     /**
      * Note that the xfixed_adaptor **cannot** be resized. Attempting to resize with a different
      * size throws an assert in debug mode.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_adaptor<ET, S, L, Tag>::resize(ST&& shape, const strides_type& strides) const
+    inline void xfixed_adaptor<ET, S, L, SH, Tag>::resize(ST&& shape, const strides_type& strides) const
     {
-        (void)(shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
-        (void)(strides);
+        (void) (shape);  // remove unused parameter warning if XTENSOR_ASSERT undefined
+        (void) (strides);
         XTENSOR_ASSERT(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size());
-        XTENSOR_ASSERT(std::equal(strides.begin(), strides.end(), m_strides.begin()) && strides.size() == m_strides.size());
+        XTENSOR_ASSERT(
+            std::equal(strides.begin(), strides.end(), m_strides.begin()) && strides.size() == m_strides.size()
+        );
     }
 
     /**
      * Note that the xfixed_container **cannot** be reshaped to a shape different from ``S``.
      */
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline void xfixed_adaptor<ET, S, L, Tag>::reshape(ST&& shape, layout_type layout) const
+    inline const auto& xfixed_adaptor<ET, S, L, SH, Tag>::reshape(ST&& shape, layout_type layout) const
     {
-        if (!(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size() && layout == L))
+        if (!(std::equal(shape.begin(), shape.end(), m_shape.begin()) && shape.size() == m_shape.size()
+              && layout == L))
         {
-            throw std::runtime_error("Trying to reshape xtensor_fixed with different shape or layout.");
+            XTENSOR_THROW(std::runtime_error, "Trying to reshape xtensor_fixed with different shape or layout.");
         }
+        return *this;
     }
 
-    template <class ET, class S, layout_type L, class Tag>
+    template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class ST>
-    inline bool xfixed_adaptor<ET, S, L, Tag>::broadcast_shape(ST& shape, bool) const
+    inline bool xfixed_adaptor<ET, S, L, SH, Tag>::broadcast_shape(ST& shape, bool) const
     {
         return xt::broadcast_shape(m_shape, shape);
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    inline auto xfixed_adaptor<EC, S, L, Tag>::storage_impl() noexcept -> storage_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline auto xfixed_adaptor<EC, S, L, SH, Tag>::storage_impl() noexcept -> storage_type&
     {
         return m_storage;
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    inline auto xfixed_adaptor<EC, S, L, Tag>::storage_impl() const noexcept -> const storage_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline auto xfixed_adaptor<EC, S, L, SH, Tag>::storage_impl() const noexcept -> const storage_type&
     {
         return m_storage;
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    constexpr layout_type xfixed_adaptor<EC, S, L, Tag>::layout() const noexcept
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    constexpr layout_type xfixed_adaptor<EC, S, L, SH, Tag>::layout() const noexcept
     {
         return base_type::static_layout;
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, Tag>::shape_impl() const noexcept -> const inner_shape_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    inline bool xfixed_adaptor<EC, S, L, SH, Tag>::is_contiguous() const noexcept
+    {
+        using str_type = typename inner_strides_type::value_type;
+        return m_strides.empty() || (layout() == layout_type::row_major && m_strides.back() == str_type(1))
+               || (layout() == layout_type::column_major && m_strides.front() == str_type(1));
+    }
+
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::shape_impl() const noexcept -> const inner_shape_type&
     {
         return m_shape;
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, Tag>::strides_impl() const noexcept -> const inner_strides_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::strides_impl() const noexcept
+        -> const inner_strides_type&
     {
         return m_strides;
     }
 
-    template <class EC, class S, layout_type L, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, Tag>::backstrides_impl() const noexcept -> const inner_backstrides_type&
+    template <class EC, class S, layout_type L, bool SH, class Tag>
+    constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::backstrides_impl() const noexcept
+        -> const inner_backstrides_type&
     {
         return m_backstrides;
     }
diff --git a/include/xtensor/xscalar.hpp b/include/xtensor/containers/xscalar.hpp
similarity index 73%
rename from include/xtensor/xscalar.hpp
rename to include/xtensor/containers/xscalar.hpp
index 6002b9a34..106a65923 100644
--- a/include/xtensor/xscalar.hpp
+++ b/include/xtensor/containers/xscalar.hpp
@@ -1,24 +1,25 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SCALAR_HPP
 #define XTENSOR_SCALAR_HPP
 
 #include <array>
 #include <cstddef>
-#include <utility>
 
 #include <xtl/xtype_traits.hpp>
 
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xlayout.hpp"
-#include "xtensor_simd.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xlayout.hpp"
+#include "../utils/xtensor_simd.hpp"
 
 namespace xt
 {
@@ -71,10 +72,19 @@ namespace xt
         using stepper = xscalar_stepper<false, CT>;
     };
 
-#define DL XTENSOR_DEFAULT_LAYOUT
     template <class CT>
-    class xscalar : public xexpression<xscalar<CT>>,
+    struct xcontainer_inner_types<xscalar<CT>>
+    {
+        using value_type = std::decay_t<CT>;
+        using reference = value_type&;
+        using const_reference = const value_type&;
+        using size_type = std::size_t;
+    };
+
+    template <class CT>
+    class xscalar : public xsharable_expression<xscalar<CT>>,
                     private xiterable<xscalar<CT>>,
+                    private xaccessible<xscalar<CT>>,
                     public extension::xscalar_base_t<CT>
     {
     public:
@@ -82,16 +92,19 @@ namespace xt
         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 = std::decay_t<CT>;
-        using reference = value_type&;
-        using const_reference = const value_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 = std::size_t;
+        using size_type = typename inner_types::size_type;
         using difference_type = std::ptrdiff_t;
-        using simd_value_type = xsimd::simd_type<value_type>;
+        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;
@@ -138,33 +151,29 @@ namespace xt
         operator const value_type&() const noexcept;
 
         size_type size() const noexcept;
-        size_type dimension() 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;
+        using accessible_base::dimension;
+        using accessible_base::shape;
 
         template <class... Args>
         reference operator()(Args...) noexcept;
         template <class... Args>
-        reference at(Args...);
-        template <class... Args>
         reference unchecked(Args...) noexcept;
-        template <class S>
-        disable_integral_t<S, reference> operator[](const S&) noexcept;
-        template <class I>
-        reference operator[](std::initializer_list<I>) noexcept;
-        reference operator[](size_type) noexcept;
 
         template <class... Args>
         const_reference operator()(Args...) const noexcept;
         template <class... Args>
-        const_reference at(Args...) const;
-        template <class... Args>
         const_reference unchecked(Args...) const noexcept;
-        template <class S>
-        disable_integral_t<S, const_reference> operator[](const S&) const noexcept;
-        template <class I>
-        const_reference operator[](std::initializer_list<I>) const noexcept;
-        const_reference operator[](size_type) const noexcept;
+
+        using accessible_base::at;
+        using accessible_base::operator[];
+        using accessible_base::back;
+        using accessible_base::front;
+        using accessible_base::in_bounds;
+        using accessible_base::periodic;
 
         template <class It>
         reference element(It, It) noexcept;
@@ -181,78 +190,78 @@ namespace xt
         template <class S>
         bool has_linear_assign(const S& strides) const noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         iterator begin() noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         iterator end() noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_iterator begin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_iterator end() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_iterator cbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_iterator cend() const noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         reverse_iterator rbegin() noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         reverse_iterator rend() noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_iterator rbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_iterator rend() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_iterator crbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_iterator crend() const noexcept;
 
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         broadcast_iterator<S, L> begin(const S& shape) noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         broadcast_iterator<S, L> end(const S& shape) noexcept;
 
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
 
 
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
 
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
 
-        iterator storage_begin() noexcept;
-        iterator storage_end() noexcept;
+        iterator linear_begin() noexcept;
+        iterator linear_end() noexcept;
 
-        const_iterator storage_begin() const noexcept;
-        const_iterator storage_end() const noexcept;
-        const_iterator storage_cbegin() const noexcept;
-        const_iterator storage_cend() const 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 storage_rbegin() noexcept;
-        reverse_iterator storage_rend() noexcept;
+        reverse_iterator linear_rbegin() noexcept;
+        reverse_iterator linear_rend() noexcept;
 
-        const_reverse_iterator storage_rbegin() const noexcept;
-        const_reverse_iterator storage_rend() const noexcept;
-        const_reverse_iterator storage_crbegin() const noexcept;
-        const_reverse_iterator storage_crend() const 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;
@@ -273,12 +282,13 @@ namespace xt
         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 = xsimd::simd_traits<requested_type>::size>
-        xsimd::simd_return_type<value_type, requested_type>
-        load_simd(size_type i) const;
+        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;
 
     private:
 
@@ -286,8 +296,9 @@ namespace xt
 
         friend class xconst_iterable<self_type>;
         friend class xiterable<self_type>;
+        friend class xaccessible<self_type>;
+        friend class xconst_accessible<self_type>;
     };
-#undef DL
 
     namespace detail
     {
@@ -305,18 +316,21 @@ namespace xt
     template <class E>
     using is_xscalar = detail::is_xscalar_impl<E>;
 
+    template <class E>
+    concept xscalar_concept = is_xscalar<std::decay_t<E>>::value;
+
     namespace detail
     {
         template <class... E>
         struct all_xscalar
         {
-            static constexpr bool value = xtl::conjunction<is_xscalar<std::decay_t<E>>...>::value;
+            static constexpr bool value = std::conjunction<is_xscalar<std::decay_t<E>>...>::value;
         };
     }
 
     // Note: MSVC bug workaround. Cannot just define
     // template <class... E>
-    // using all_xscalar = xtl::conjunction<is_xscalar<std::decay_t<E>>...>;
+    // using all_xscalar = std::conjunction<is_xscalar<std::decay_t<E>>...>;
 
     template <class... E>
     using all_xscalar = detail::all_xscalar<E...>;
@@ -341,19 +355,18 @@ namespace xt
     public:
 
         using self_type = xscalar_stepper<is_const, CT>;
-        using storage_type = std::conditional_t<is_const,
-                                                const xscalar<CT>,
-                                                xscalar<CT>>;
+        using storage_type = std::conditional_t<is_const, const xscalar<CT>, xscalar<CT>>;
 
         using value_type = typename storage_type::value_type;
-        using reference = std::conditional_t<is_const,
-                                             typename storage_type::const_reference,
-                                             typename storage_type::reference>;
-        using pointer = std::conditional_t<is_const,
-                                           typename storage_type::const_pointer,
-                                           typename storage_type::pointer>;
+        using reference = std::
+            conditional_t<is_const, typename storage_type::const_reference, typename storage_type::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>;
 
         xscalar_stepper(storage_type* c) noexcept;
 
@@ -367,10 +380,10 @@ namespace xt
         void to_begin() noexcept;
         void to_end(layout_type l) noexcept;
 
-        template <class R>
-        R step_simd();
+        template <class T>
+        simd_return_type<T> step_simd();
 
-        value_type step_leading();
+        void step_leading();
 
     private:
 
@@ -384,30 +397,26 @@ namespace xt
     namespace detail
     {
         template <bool is_const, class CT>
-        using dummy_reference_t = std::conditional_t<is_const,
-                                                     typename xscalar<CT>::const_reference,
-                                                     typename xscalar<CT>::reference>;
+        using dummy_reference_t = std::
+            conditional_t<is_const, typename xscalar<CT>::const_reference, typename xscalar<CT>::reference>;
 
         template <bool is_const, class CT>
-        using dummy_pointer_t = std::conditional_t<is_const,
-                                                   typename xscalar<CT>::const_pointer,
-                                                   typename xscalar<CT>::pointer>;
+        using dummy_pointer_t = std::
+            conditional_t<is_const, typename xscalar<CT>::const_pointer, typename xscalar<CT>::pointer>;
     }
 
     template <bool is_const, class CT>
-    class xdummy_iterator
-        : public xtl::xrandom_access_iterator_base<xdummy_iterator<is_const, CT>,
-                                                   typename xscalar<CT>::value_type,
-                                                   typename xscalar<CT>::difference_type,
-                                                   detail::dummy_pointer_t<is_const, CT>,
-                                                   detail::dummy_reference_t<is_const, CT>>
+    class xdummy_iterator : public xtl::xrandom_access_iterator_base<
+                                xdummy_iterator<is_const, CT>,
+                                typename xscalar<CT>::value_type,
+                                typename xscalar<CT>::difference_type,
+                                detail::dummy_pointer_t<is_const, CT>,
+                                detail::dummy_reference_t<is_const, CT>>
     {
     public:
 
         using self_type = xdummy_iterator<is_const, CT>;
-        using storage_type = std::conditional_t<is_const,
-                                                const xscalar<CT>,
-                                                xscalar<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>;
@@ -436,20 +445,19 @@ namespace xt
     };
 
     template <bool is_const, class CT>
-    bool operator==(const xdummy_iterator<is_const, CT>& lhs,
-                    const xdummy_iterator<is_const, CT>& rhs) noexcept;
+    bool
+    operator==(const xdummy_iterator<is_const, CT>& lhs, const xdummy_iterator<is_const, CT>& rhs) noexcept;
 
     template <bool is_const, class CT>
-    bool operator<(const xdummy_iterator<is_const, CT>& lhs,
-                   const xdummy_iterator<is_const, CT>& rhs) noexcept;
+    bool operator<(const xdummy_iterator<is_const, CT>& lhs, const xdummy_iterator<is_const, CT>& rhs) noexcept;
 
     template <class T>
-    struct is_xdummy_iterator : std::false_type
+    struct is_not_xdummy_iterator : std::true_type
     {
     };
 
     template <bool is_const, class CT>
-    struct is_xdummy_iterator<xdummy_iterator<is_const, CT>> : std::true_type
+    struct is_not_xdummy_iterator<xdummy_iterator<is_const, CT>> : std::false_type
     {
     };
 
@@ -457,31 +465,28 @@ namespace xt
      * linear_begin / linear_end *
      *****************************/
 
-    namespace detail
+    template <class CT>
+    constexpr auto linear_begin(xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
     {
-        template <class CT>
-        constexpr auto linear_begin(xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
-        {
-            return c.dummy_begin();
-        }
+        return c.dummy_begin();
+    }
 
-        template <class CT>
-        constexpr auto linear_end(xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
-        {
-            return c.dummy_end();
-        }
+    template <class CT>
+    constexpr auto linear_end(xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
+    {
+        return c.dummy_end();
+    }
 
-        template <class CT>
-        constexpr auto linear_begin(const xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
-        {
-            return c.dummy_begin();
-        }
+    template <class CT>
+    constexpr auto linear_begin(const xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
+    {
+        return c.dummy_begin();
+    }
 
-        template <class CT>
-        constexpr auto linear_end(const xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
-        {
-            return c.dummy_end();
-        }
+    template <class CT>
+    constexpr auto linear_end(const xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
+    {
+        return c.dummy_end();
     }
 
     /**************************
@@ -519,12 +524,6 @@ namespace xt
         return 1;
     }
 
-    template <class CT>
-    inline auto xscalar<CT>::dimension() const noexcept -> size_type
-    {
-        return 0;
-    }
-
     template <class CT>
     inline auto xscalar<CT>::shape() const noexcept -> const shape_type&
     {
@@ -533,52 +532,34 @@ namespace xt
     }
 
     template <class CT>
-    inline layout_type xscalar<CT>::layout() const noexcept
+    inline auto xscalar<CT>::shape(size_type) const noexcept -> size_type
     {
-        return static_layout;
+        return 0;
     }
 
     template <class CT>
-    template <class... Args>
-    inline auto xscalar<CT>::operator()(Args...) noexcept -> reference
+    inline layout_type xscalar<CT>::layout() const noexcept
     {
-        XTENSOR_CHECK_DIMENSION((std::array<int, 0>()), Args()...);
-        return m_value;
+        return static_layout;
     }
 
     template <class CT>
-    template <class... Args>
-    inline auto xscalar<CT>::at(Args... args) -> reference
+    inline bool xscalar<CT>::is_contiguous() const noexcept
     {
-        check_dimension(shape(), args...);
-        return this->operator()(args...);
+        return true;
     }
 
     template <class CT>
     template <class... Args>
-    inline auto xscalar<CT>::unchecked(Args...) noexcept -> reference
-    {
-        return m_value;
-    }
-
-    template <class CT>
-    template <class S>
-    inline auto xscalar<CT>::operator[](const S&) noexcept
-        -> disable_integral_t<S, reference>
-    {
-        return m_value;
-    }
-
-    template <class CT>
-    template <class I>
-    inline auto xscalar<CT>::operator[](std::initializer_list<I>) noexcept
-        -> reference
+    inline auto xscalar<CT>::operator()(Args...) noexcept -> reference
     {
+        XTENSOR_CHECK_DIMENSION((std::array<int, 0>()), Args()...);
         return m_value;
     }
 
     template <class CT>
-    inline auto xscalar<CT>::operator[](size_type) noexcept -> reference
+    template <class... Args>
+    inline auto xscalar<CT>::unchecked(Args...) noexcept -> reference
     {
         return m_value;
     }
@@ -591,14 +572,6 @@ namespace xt
         return m_value;
     }
 
-    template <class CT>
-    template <class... Args>
-    inline auto xscalar<CT>::at(Args... args) const -> const_reference
-    {
-        check_dimension(shape(), args...);
-        return this->operator()(args...);
-    }
-
     template <class CT>
     template <class... Args>
     inline auto xscalar<CT>::unchecked(Args...) const noexcept -> const_reference
@@ -606,28 +579,6 @@ namespace xt
         return m_value;
     }
 
-    template <class CT>
-    template <class S>
-    inline auto xscalar<CT>::operator[](const S&) const noexcept
-        -> disable_integral_t<S, const_reference>
-    {
-        return m_value;
-    }
-
-    template <class CT>
-    template <class I>
-    inline auto xscalar<CT>::operator[](std::initializer_list<I>) const noexcept
-        -> const_reference
-    {
-        return m_value;
-    }
-
-    template <class CT>
-    inline auto xscalar<CT>::operator[](size_type) const noexcept -> const_reference
-    {
-        return m_value;
-    }
-
     template <class CT>
     template <class It>
     inline auto xscalar<CT>::element(It, It) noexcept -> reference
@@ -714,14 +665,14 @@ namespace xt
     template <layout_type L>
     inline auto xscalar<CT>::rbegin() noexcept -> reverse_iterator
     {
-        return reverse_storage_iterator(end());
+        return reverse_iterator(end());
     }
 
     template <class CT>
     template <layout_type L>
     inline auto xscalar<CT>::rend() noexcept -> reverse_iterator
     {
-        return reverse_storage_iterator(begin());
+        return reverse_iterator(begin());
     }
 
     template <class CT>
@@ -742,19 +693,19 @@ namespace xt
     template <layout_type L>
     inline auto xscalar<CT>::crbegin() const noexcept -> const_reverse_iterator
     {
-        return const_reverse_storage_iterator(cend());
+        return const_reverse_iterator(cend());
     }
 
     template <class CT>
     template <layout_type L>
     inline auto xscalar<CT>::crend() const noexcept -> const_reverse_iterator
     {
-        return const_reverse_storage_iterator(cbegin());
+        return const_reverse_iterator(cbegin());
     }
 
     /*****************************
-    * Broadcasting iterator api *
-    *****************************/
+     * Broadcasting iterator api *
+     *****************************/
 
     template <class CT>
     template <class S, layout_type L>
@@ -841,73 +792,73 @@ namespace xt
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_begin() noexcept -> iterator
+    inline auto xscalar<CT>::linear_begin() noexcept -> iterator
     {
         return this->template begin<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_end() noexcept -> iterator
+    inline auto xscalar<CT>::linear_end() noexcept -> iterator
     {
         return this->template end<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_begin() const noexcept -> const_iterator
+    inline auto xscalar<CT>::linear_begin() const noexcept -> const_iterator
     {
         return this->template begin<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_end() const noexcept -> const_iterator
+    inline auto xscalar<CT>::linear_end() const noexcept -> const_iterator
     {
         return this->template end<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_cbegin() const noexcept -> const_iterator
+    inline auto xscalar<CT>::linear_cbegin() const noexcept -> const_iterator
     {
         return this->template cbegin<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_cend() const noexcept -> const_iterator
+    inline auto xscalar<CT>::linear_cend() const noexcept -> const_iterator
     {
         return this->template cend<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_rbegin() noexcept -> reverse_iterator
+    inline auto xscalar<CT>::linear_rbegin() noexcept -> reverse_iterator
     {
         return this->template rbegin<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_rend() noexcept -> reverse_iterator
+    inline auto xscalar<CT>::linear_rend() noexcept -> reverse_iterator
     {
         return this->template rend<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_rbegin() const noexcept -> const_reverse_iterator
+    inline auto xscalar<CT>::linear_rbegin() const noexcept -> const_reverse_iterator
     {
         return this->template rbegin<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_rend() const noexcept -> const_reverse_iterator
+    inline auto xscalar<CT>::linear_rend() const noexcept -> const_reverse_iterator
     {
         return this->template rend<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_crbegin() const noexcept -> const_reverse_iterator
+    inline auto xscalar<CT>::linear_crbegin() const noexcept -> const_reverse_iterator
     {
         return this->template crbegin<XTENSOR_DEFAULT_LAYOUT>();
     }
 
     template <class CT>
-    inline auto xscalar<CT>::storage_crend() const noexcept -> const_reverse_iterator
+    inline auto xscalar<CT>::linear_crend() const noexcept -> const_reverse_iterator
     {
         return this->template crend<XTENSOR_DEFAULT_LAYOUT>();
     }
@@ -976,6 +927,18 @@ namespace xt
         return m_value;
     }
 
+    template <class CT>
+    inline auto xscalar<CT>::flat(size_type) noexcept -> reference
+    {
+        return m_value;
+    }
+
+    template <class CT>
+    inline auto xscalar<CT>::flat(size_type) const noexcept -> const_reference
+    {
+        return m_value;
+    }
+
     template <class CT>
     template <class align, class simd>
     inline void xscalar<CT>::store_simd(size_type, const simd& e)
@@ -986,9 +949,9 @@ namespace xt
     template <class CT>
     template <class align, class requested_type, std::size_t N>
     inline auto xscalar<CT>::load_simd(size_type) const
-        -> xsimd::simd_return_type<value_type, requested_type>
+        -> xt_simd::simd_return_type<value_type, requested_type>
     {
-        return xsimd::set_simd<value_type, requested_type>(m_value);
+        return xt_simd::broadcast_as<requested_type>(m_value);
     }
 
     template <class T>
@@ -1050,17 +1013,15 @@ namespace xt
     }
 
     template <bool is_const, class CT>
-    template <class R>
-    inline R xscalar_stepper<is_const, CT>::step_simd()
+    template <class T>
+    inline auto xscalar_stepper<is_const, CT>::step_simd() -> simd_return_type<T>
     {
-        return R(p_c->operator()());
+        return simd_return_type<T>(p_c->operator()());
     }
 
     template <bool is_const, class CT>
-    inline auto xscalar_stepper<is_const, CT>::step_leading()
-        -> value_type
+    inline void xscalar_stepper<is_const, CT>::step_leading()
     {
-        return p_c->operator()();
     }
 
     /**********************************
@@ -1122,15 +1083,15 @@ namespace xt
     }
 
     template <bool is_const, class CT>
-    inline bool operator==(const xdummy_iterator<is_const, CT>& lhs,
-                           const xdummy_iterator<is_const, CT>& rhs) noexcept
+    inline bool
+    operator==(const xdummy_iterator<is_const, CT>& lhs, const xdummy_iterator<is_const, CT>& rhs) noexcept
     {
         return lhs.equal(rhs);
     }
 
     template <bool is_const, class CT>
-    inline bool operator<(const xdummy_iterator<is_const, CT>& lhs,
-                          const xdummy_iterator<is_const, CT>& rhs) noexcept
+    inline bool
+    operator<(const xdummy_iterator<is_const, CT>& lhs, const xdummy_iterator<is_const, CT>& rhs) noexcept
     {
         return lhs.less_than(rhs);
     }
diff --git a/include/xtensor/xstorage.hpp b/include/xtensor/containers/xstorage.hpp
similarity index 72%
rename from include/xtensor/xstorage.hpp
rename to include/xtensor/containers/xstorage.hpp
index 190e46c61..26d4a8ccd 100644
--- a/include/xtensor/xstorage.hpp
+++ b/include/xtensor/containers/xstorage.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_STORAGE_HPP
 #define XTENSOR_STORAGE_HPP
@@ -17,44 +18,33 @@
 #include <memory>
 #include <type_traits>
 
-#include "xexception.hpp"
-#include "xtensor_simd.hpp"
-#include "xutils.hpp"
-
-#ifndef XTENSOR_ALIGNMENT
-    #ifdef XTENSOR_USE_XSIMD
-        #include <xsimd/xsimd.hpp>
-        #define XTENSOR_ALIGNMENT XSIMD_DEFAULT_ALIGNMENT
-    #else
-        #define XTENSOR_ALIGNMENT 0
-    #endif
-#endif
+#include "../core/xtensor_config.hpp"
+#include "../utils/xexception.hpp"
+#include "../utils/xtensor_simd.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
-
-    namespace detail
+    template <class C>
+    struct is_contiguous_container : std::true_type
     {
-        template <class It>
-        using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<It>::iterator_category,
-                                                                               std::input_iterator_tag>::value>::type;
-    }
+    };
 
-    template <class T, class Allocator = std::allocator<T>>
+    template <class T, class A = std::allocator<T>>
     class uvector
     {
     public:
 
-        using allocator_type = Allocator;
+        using allocator_type = A;
 
-        using value_type = typename allocator_type::value_type;
-        using reference = typename allocator_type::reference;
-        using const_reference = typename allocator_type::const_reference;
-        using pointer = typename allocator_type::pointer;
-        using const_pointer = typename allocator_type::const_pointer;
+        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 allocator_type::size_type;
-        using difference_type = typename allocator_type::difference_type;
+        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;
@@ -66,7 +56,7 @@ namespace xt
         explicit uvector(size_type count, const allocator_type& alloc = allocator_type());
         uvector(size_type count, const_reference value, const allocator_type& alloc = allocator_type());
 
-        template <class InputIt, class = detail::require_input_iter<InputIt>>
+        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());
@@ -86,10 +76,18 @@ namespace xt
         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;
 
@@ -162,36 +160,43 @@ namespace xt
     namespace detail
     {
         template <class A>
-        inline typename A::pointer safe_init_allocate(A& alloc, typename A::size_type size)
+        inline typename std::allocator_traits<A>::pointer
+        safe_init_allocate(A& alloc, typename std::allocator_traits<A>::size_type size)
         {
-            using pointer = typename A::pointer;
-            using value_type = typename A::value_type;
+            using traits = std::allocator_traits<A>;
+            using pointer = typename traits::pointer;
+            using value_type = typename traits::value_type;
             pointer res = alloc.allocate(size);
-            if (!xtrivially_default_constructible<value_type>::value)
+            if (!std::is_trivially_default_constructible<value_type>::value)
             {
                 for (pointer p = res; p != res + size; ++p)
                 {
-                    alloc.construct(p, value_type());
+                    traits::construct(alloc, p, value_type());
                 }
             }
             return res;
         }
 
         template <class A>
-        inline void safe_destroy_deallocate(A& alloc, typename A::pointer ptr, typename A::size_type size)
+        inline void safe_destroy_deallocate(
+            A& alloc,
+            typename std::allocator_traits<A>::pointer ptr,
+            typename std::allocator_traits<A>::size_type size
+        )
         {
-            using pointer = typename A::pointer;
-            using value_type = typename A::value_type;
+            using traits = std::allocator_traits<A>;
+            using pointer = typename traits::pointer;
+            using value_type = typename traits::value_type;
             if (ptr != nullptr)
             {
-                if (!xtrivially_default_constructible<value_type>::value)
+                if (!std::is_trivially_default_constructible<value_type>::value)
                 {
                     for (pointer p = ptr; p != ptr + size; ++p)
                     {
-                        alloc.destroy(p);
+                        traits::destroy(alloc, p);
                     }
                 }
-                alloc.deallocate(ptr, size);
+                traits::deallocate(alloc, ptr, size);
             }
         }
     }
@@ -230,13 +235,17 @@ namespace xt
 
     template <class T, class A>
     inline uvector<T, A>::uvector(const allocator_type& alloc) noexcept
-        : m_allocator(alloc), p_begin(nullptr), p_end(nullptr)
+        : m_allocator(alloc)
+        , p_begin(nullptr)
+        , p_end(nullptr)
     {
     }
 
     template <class T, class A>
     inline uvector<T, A>::uvector(size_type count, const allocator_type& alloc)
-        : m_allocator(alloc), p_begin(nullptr), p_end(nullptr)
+        : m_allocator(alloc)
+        , p_begin(nullptr)
+        , p_end(nullptr)
     {
         if (count != 0)
         {
@@ -247,7 +256,9 @@ namespace xt
 
     template <class T, class A>
     inline uvector<T, A>::uvector(size_type count, const_reference value, const allocator_type& alloc)
-        : m_allocator(alloc), p_begin(nullptr), p_end(nullptr)
+        : m_allocator(alloc)
+        , p_begin(nullptr)
+        , p_end(nullptr)
     {
         if (count != 0)
         {
@@ -258,16 +269,20 @@ namespace xt
     }
 
     template <class T, class A>
-    template <class InputIt, class>
+    template <std::input_iterator InputIt>
     inline uvector<T, A>::uvector(InputIt first, InputIt last, const allocator_type& alloc)
-        : m_allocator(alloc), p_begin(nullptr), p_end(nullptr)
+        : m_allocator(alloc)
+        , p_begin(nullptr)
+        , p_end(nullptr)
     {
         init_data(first, last);
     }
 
     template <class T, class A>
     inline uvector<T, A>::uvector(std::initializer_list<T> init, const allocator_type& alloc)
-        : m_allocator(alloc), p_begin(nullptr), p_end(nullptr)
+        : m_allocator(alloc)
+        , p_begin(nullptr)
+        , p_end(nullptr)
     {
         init_data(init.begin(), init.end());
     }
@@ -282,15 +297,20 @@ namespace xt
 
     template <class T, class A>
     inline uvector<T, A>::uvector(const uvector& rhs)
-        : m_allocator(std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator())),
-          p_begin(nullptr), p_end(nullptr)
+        : m_allocator(
+            std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator())
+        )
+        , p_begin(nullptr)
+        , p_end(nullptr)
     {
         init_data(rhs.p_begin, rhs.p_end);
     }
 
     template <class T, class A>
     inline uvector<T, A>::uvector(const uvector& rhs, const allocator_type& alloc)
-        : m_allocator(alloc), p_begin(nullptr), p_end(nullptr)
+        : m_allocator(alloc)
+        , p_begin(nullptr)
+        , p_end(nullptr)
     {
         init_data(rhs.p_begin, rhs.p_end);
     }
@@ -301,9 +321,11 @@ namespace xt
         // No copy and swap idiom here due to performance issues
         if (this != &rhs)
         {
-            m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator());
+            m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(
+                rhs.get_allocator()
+            );
             resize_impl(rhs.size());
-            if (xtrivially_default_constructible<value_type>::value)
+            if (std::is_trivially_default_constructible<value_type>::value)
             {
                 std::uninitialized_copy(rhs.p_begin, rhs.p_end, p_begin);
             }
@@ -317,7 +339,9 @@ namespace xt
 
     template <class T, class A>
     inline uvector<T, A>::uvector(uvector&& rhs) noexcept
-        : m_allocator(std::move(rhs.m_allocator)), p_begin(rhs.p_begin), p_end(rhs.p_end)
+        : m_allocator(std::move(rhs.m_allocator))
+        , p_begin(rhs.p_begin)
+        , p_end(rhs.p_end)
     {
         rhs.p_begin = nullptr;
         rhs.p_end = nullptr;
@@ -325,7 +349,9 @@ namespace xt
 
     template <class T, class A>
     inline uvector<T, A>::uvector(uvector&& rhs, const allocator_type& alloc) noexcept
-        : m_allocator(alloc), p_begin(rhs.p_begin), p_end(rhs.p_end)
+        : m_allocator(alloc)
+        , p_begin(rhs.p_begin)
+        , p_end(rhs.p_end)
     {
         rhs.p_begin = nullptr;
         rhs.p_end = nullptr;
@@ -365,6 +391,34 @@ namespace xt
         resize_impl(size);
     }
 
+    template <class T, class A>
+    inline auto uvector<T, A>::max_size() const noexcept -> size_type
+    {
+        return m_allocator.max_size();
+    }
+
+    template <class T, class A>
+    inline void uvector<T, A>::reserve(size_type /*new_cap*/)
+    {
+    }
+
+    template <class T, class A>
+    inline auto uvector<T, A>::capacity() const noexcept -> size_type
+    {
+        return size();
+    }
+
+    template <class T, class A>
+    inline void uvector<T, A>::shrink_to_fit()
+    {
+    }
+
+    template <class T, class A>
+    inline void uvector<T, A>::clear()
+    {
+        resize(size_type(0));
+    }
+
     template <class T, class A>
     inline auto uvector<T, A>::operator[](size_type i) -> reference
     {
@@ -377,6 +431,26 @@ namespace xt
         return p_begin[i];
     }
 
+    template <class T, class A>
+    inline auto uvector<T, A>::at(size_type i) -> reference
+    {
+        if (i >= size())
+        {
+            XTENSOR_THROW(std::out_of_range, "Out of range in uvector access");
+        }
+        return this->operator[](i);
+    }
+
+    template <class T, class A>
+    inline auto uvector<T, A>::at(size_type i) const -> const_reference
+    {
+        if (i >= size())
+        {
+            XTENSOR_THROW(std::out_of_range, "Out of range in uvector access");
+        }
+        return this->operator[](i);
+    }
+
     template <class T, class A>
     inline auto uvector<T, A>::front() -> reference
     {
@@ -509,8 +583,7 @@ namespace xt
     template <class T, class A>
     inline bool operator<(const uvector<T, A>& lhs, const uvector<T, A>& rhs)
     {
-        return std::lexicographical_compare(lhs.begin(), lhs.end(),
-                                            rhs.begin(), rhs.end());
+        return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
     }
 
     template <class T, class A>
@@ -546,13 +619,13 @@ namespace xt
         template <class T>
         struct allocator_alignment
         {
-            constexpr static std::size_t value = 0;
+            static constexpr std::size_t value = 0;
         };
 
         template <class T, std::size_t A>
-        struct allocator_alignment<xsimd::aligned_allocator<T, A>>
+        struct allocator_alignment<xt_simd::aligned_allocator<T, A>>
         {
-            constexpr static std::size_t value = A;
+            static constexpr std::size_t value = A;
         };
     }
 
@@ -563,25 +636,22 @@ namespace xt
 
         using self_type = svector<T, N, A, Init>;
         using allocator_type = A;
-        using size_type = typename A::size_type;
-        using value_type = typename A::value_type;
-        using pointer = typename A::pointer;
-        using const_pointer = typename A::const_pointer;
-        using reference = typename A::reference;
-        using const_reference = typename A::const_reference;
-        using difference_type = typename A::difference_type;
+        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>;
 
-    #if defined(_MSC_VER) && _MSC_VER < 1910
-        constexpr static std::size_t alignment = detail::allocator_alignment<A>::value;
-    #else
-        constexpr static std::size_t alignment = detail::allocator_alignment<A>::value != 0 ?
-                                                    detail::allocator_alignment<A>::value : alignof(T);
-    #endif
+        static constexpr std::size_t alignment = detail::allocator_alignment<A>::value != 0
+                                                     ? detail::allocator_alignment<A>::value
+                                                     : alignof(T);
 
         svector() noexcept;
         ~svector();
@@ -593,22 +663,24 @@ namespace xt
 
         svector(const std::vector<T>& vec);
 
-        template <class IT, class = detail::require_input_iter<IT>>
+        template <std::input_iterator IT>
         svector(IT begin, IT end, const allocator_type& alloc = allocator_type());
 
-        template <std::size_t N2, bool I2, class = std::enable_if_t<N != N2, void>>
-        explicit svector(const svector<T, N2, A, I2>& rhs);
+        template <std::size_t N2, bool I2>
+        explicit svector(const svector<T, N2, A, I2>& rhs)
+            requires(N != N2);
 
         svector& operator=(const svector& rhs);
-        svector& operator=(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, class = std::enable_if_t<N != N2, void>>
-        svector& operator=(const svector<T, N2, A, I2>& rhs);
+        template <std::size_t N2, bool I2>
+        svector& operator=(const svector<T, N2, A, I2>& rhs)
+            requires(N != N2);
 
         svector(const svector& other);
-        svector(svector&& other);
+        svector(svector&& other) noexcept(std::is_nothrow_move_constructible<value_type>::value);
 
         void assign(size_type n, const value_type& v);
 
@@ -621,14 +693,14 @@ namespace xt
         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 resize(size_type n);
-
-        size_type capacity() const;
         void push_back(const T& elt);
-
+        void push_back(T&& elt);
         void pop_back();
 
         iterator begin();
@@ -645,9 +717,14 @@ namespace xt
         const_reverse_iterator rend() const;
         const_reverse_iterator crend() const;
 
-        size_type size() 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;
@@ -661,6 +738,11 @@ namespace xt
 
         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);
 
@@ -717,7 +799,7 @@ namespace xt
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    template <class IT, class>
+    template <std::input_iterator IT>
     inline svector<T, N, A, Init>::svector(IT begin, IT end, const allocator_type& alloc)
         : m_allocator(alloc)
     {
@@ -725,8 +807,9 @@ namespace xt
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    template <std::size_t N2, bool I2, class>
+    template <std::size_t N2, bool I2>
     inline svector<T, N, A, Init>::svector(const svector<T, N2, A, I2>& rhs)
+        requires(N != N2)
         : m_allocator(rhs.get_allocator())
     {
         assign(rhs.begin(), rhs.end());
@@ -760,7 +843,8 @@ namespace xt
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    inline svector<T, N, A, Init>& svector<T, N, A, Init>::operator=(svector&& rhs)
+    inline svector<T, N, A, Init>& svector<T, N, A, Init>::operator=(svector&& rhs
+    ) noexcept(std::is_nothrow_move_assignable<value_type>::value)
     {
         assign(rhs.begin(), rhs.end());
         return *this;
@@ -769,7 +853,9 @@ namespace xt
     template <class T, std::size_t N, class A, bool Init>
     inline svector<T, N, A, Init>& svector<T, N, A, Init>::operator=(const std::vector<T>& rhs)
     {
-        m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator());
+        m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(
+            rhs.get_allocator()
+        );
         assign(rhs.begin(), rhs.end());
         return *this;
     }
@@ -781,23 +867,29 @@ namespace xt
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    template <std::size_t N2, bool I2, class>
+    template <std::size_t N2, bool I2>
     inline svector<T, N, A, Init>& svector<T, N, A, Init>::operator=(const svector<T, N2, A, I2>& rhs)
+        requires(N != N2)
     {
-        m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator());
+        m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(
+            rhs.get_allocator()
+        );
         assign(rhs.begin(), rhs.end());
         return *this;
     }
 
     template <class T, std::size_t N, class A, bool Init>
     inline svector<T, N, A, Init>::svector(const svector& rhs)
-        : m_allocator(std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator()))
+        : m_allocator(
+            std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator())
+        )
     {
         assign(rhs.begin(), rhs.end());
     }
 
     template <class T, std::size_t N, class A, bool Init>
-    inline svector<T, N, A, Init>::svector(svector&& rhs)
+    inline svector<T, N, A, Init>::svector(svector&& rhs
+    ) noexcept(std::is_nothrow_move_constructible<value_type>::value)
     {
         this->swap(rhs);
     }
@@ -845,6 +937,26 @@ namespace xt
         return m_begin[idx];
     }
 
+    template <class T, std::size_t N, class A, bool Init>
+    inline auto svector<T, N, A, Init>::at(size_type idx) -> reference
+    {
+        if (idx >= size())
+        {
+            XTENSOR_THROW(std::out_of_range, "Out of range in svector access");
+        }
+        return this->operator[](idx);
+    }
+
+    template <class T, std::size_t N, class A, bool Init>
+    inline auto svector<T, N, A, Init>::at(size_type idx) const -> const_reference
+    {
+        if (idx >= size())
+        {
+            XTENSOR_THROW(std::out_of_range, "Out of range in svector access");
+        }
+        return this->operator[](idx);
+    }
+
     template <class T, std::size_t N, class A, bool Init>
     inline auto svector<T, N, A, Init>::data() -> pointer
     {
@@ -864,19 +976,47 @@ namespace xt
         {
             grow(n);
         }
+        size_type old_size = size();
         m_end = m_begin + n;
-        if (Init)
+        if (Init && old_size < size())
         {
-            std::fill(begin(), end(), T());
+            std::fill(begin() + old_size, end(), T());
         }
     }
 
+    template <class T, std::size_t N, class A, bool Init>
+    inline auto svector<T, N, A, Init>::max_size() const noexcept -> size_type
+    {
+        return m_allocator.max_size();
+    }
+
     template <class T, std::size_t N, class A, bool Init>
     inline auto svector<T, N, A, Init>::capacity() const -> size_type
     {
         return static_cast<std::size_t>(m_capacity - m_begin);
     }
 
+    template <class T, std::size_t N, class A, bool Init>
+    inline void svector<T, N, A, Init>::reserve(size_type n)
+    {
+        if (n > N && n > capacity())
+        {
+            grow(n);
+        }
+    }
+
+    template <class T, std::size_t N, class A, bool Init>
+    inline void svector<T, N, A, Init>::shrink_to_fit()
+    {
+        // No op for now
+    }
+
+    template <class T, std::size_t N, class A, bool Init>
+    inline void svector<T, N, A, Init>::clear()
+    {
+        resize(size_type(0));
+    }
+
     template <class T, std::size_t N, class A, bool Init>
     void svector<T, N, A, Init>::push_back(const T& elt)
     {
@@ -887,6 +1027,16 @@ namespace xt
         *(m_end++) = elt;
     }
 
+    template <class T, std::size_t N, class A, bool Init>
+    void svector<T, N, A, Init>::push_back(T&& elt)
+    {
+        if (m_end >= m_capacity)
+        {
+            grow();
+        }
+        *(m_end++) = std::move(elt);
+    }
+
     template <class T, std::size_t N, class A, bool Init>
     void svector<T, N, A, Init>::pop_back()
     {
@@ -1066,18 +1216,46 @@ namespace xt
 
         // Update ref if element moved
         const T* elt_ptr = &elt;
-        if (it <= elt_ptr && elt_ptr < m_end)
+        bool cond = it <= elt_ptr && elt_ptr < m_end;
+        // More complicated than incrementing elt_ptr, but this avoids
+        // false positive array-bounds warning on GCC 10
+        const T* src_ptr = cond ? it + (elt_ptr - it) + std::ptrdiff_t(1) : elt_ptr;
+        *it = *src_ptr;
+        return it;
+    }
+
+    template <class T, std::size_t N, class A, bool Init>
+    template <class It>
+    inline auto svector<T, N, A, Init>::insert(const_iterator pos, It first, It last) -> iterator
+    {
+        auto it = const_cast<pointer>(pos);
+        difference_type n = std::distance(first, last);
+        if (n > 0)
         {
-            ++elt_ptr;
+            if (n > m_capacity - m_end)
+            {
+                std::ptrdiff_t elt_no = it - m_begin;
+                grow(static_cast<size_t>((m_capacity - m_begin) + n));
+                it = m_begin + elt_no;
+            }
+
+            std::move_backward(it, m_end, m_end + n);
+            m_end += n;
+            std::copy(first, last, it);
         }
-        *it = *elt_ptr;
         return it;
     }
 
+    template <class T, std::size_t N, class A, bool Init>
+    inline auto svector<T, N, A, Init>::insert(const_iterator pos, std::initializer_list<T> l) -> iterator
+    {
+        return insert(pos, l.begin(), l.end());
+    }
+
     template <class T, std::size_t N, class A, bool Init>
     inline void svector<T, N, A, Init>::destroy_range(T* begin, T* end)
     {
-        if (!xtrivially_default_constructible<T>::value)
+        if (!std::is_trivially_default_constructible<T>::value)
         {
             while (begin != end)
             {
@@ -1091,6 +1269,7 @@ namespace xt
     template <std::size_t ON, class OA, bool InitA>
     inline void svector<T, N, A, Init>::swap(svector<T, ON, OA, InitA>& rhs)
     {
+        using std::swap;
         if (this == &rhs)
         {
             return;
@@ -1099,45 +1278,43 @@ namespace xt
         // We can only avoid copying elements if neither vector is small.
         if (!this->on_stack() && !rhs.on_stack())
         {
-            std::swap(this->m_begin, rhs.m_begin);
-            std::swap(this->m_end, rhs.m_end);
-            std::swap(this->m_capacity, rhs.m_capacity);
+            swap(this->m_begin, rhs.m_begin);
+            swap(this->m_end, rhs.m_end);
+            swap(this->m_capacity, rhs.m_capacity);
             return;
         }
 
-        if (rhs.size() > this->capacity())
+        size_type rhs_old_size = rhs.size();
+        size_type old_size = this->size();
+
+        if (rhs_old_size > old_size)
         {
-            this->resize(rhs.size());
+            this->resize(rhs_old_size);
         }
-        if (this->size() > rhs.capacity())
+        else if (old_size > rhs_old_size)
         {
-            rhs.resize(this->size());
+            rhs.resize(old_size);
         }
 
         // Swap the shared elements.
-        std::size_t num_shared = (std::min)(this->size(), rhs.size());
-
-        for (size_type i = 0; i != num_shared; ++i)
+        size_type min_size = (std::min)(old_size, rhs_old_size);
+        for (size_type i = 0; i < min_size; ++i)
         {
-            std::swap((*this)[i], rhs[i]);
+            swap((*this)[i], rhs[i]);
         }
 
         // Copy over the extra elts.
-        if (this->size() > rhs.size())
+        if (old_size > rhs_old_size)
         {
-            std::size_t elements_diff = this->size() - rhs.size();
-            std::copy(this->begin() + num_shared, this->end(), rhs.end());
-            rhs.m_end = rhs.end() + elements_diff;
-            this->destroy_range(this->begin() + num_shared, this->end());
-            this->m_end = this->begin() + num_shared;
+            std::copy(this->begin() + min_size, this->end(), rhs.begin() + min_size);
+            this->destroy_range(this->begin() + min_size, this->end());
+            this->m_end = this->begin() + min_size;
         }
-        else if (rhs.size() > this->size())
+        else if (rhs_old_size > old_size)
         {
-            std::size_t elements_diff = rhs.size() - this->size();
-            std::uninitialized_copy(rhs.begin() + num_shared, rhs.end(), this->end());
-            this->m_end = this->end() + elements_diff;
-            this->destroy_range(rhs.begin() + num_shared, rhs.end());
-            rhs.m_end = rhs.begin() + num_shared;
+            std::copy(rhs.begin() + min_size, rhs.end(), this->begin() + min_size);
+            this->destroy_range(rhs.begin() + min_size, rhs.end());
+            rhs.m_end = rhs.begin() + min_size;
         }
     }
 
@@ -1199,8 +1376,7 @@ namespace xt
     template <class T, std::size_t N, class A, bool Init>
     inline bool operator<(const svector<T, N, A, Init>& lhs, const svector<T, N, A, Init>& rhs)
     {
-        return std::lexicographical_compare(lhs.begin(), lhs.end(),
-                                            rhs.begin(), rhs.end());
+        return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
     }
 
     template <class T, std::size_t N, class A, bool Init>
@@ -1227,76 +1403,34 @@ namespace xt
         lhs.swap(rhs);
     }
 
-    #define XTENSOR_SELECT_ALIGN (XTENSOR_ALIGNMENT != 0 ? XTENSOR_ALIGNMENT : alignof(T))
-
     template <class X, class T, std::size_t N, class A, bool B>
     struct rebind_container<X, svector<T, N, A, B>>
     {
-        using allocator = typename A::template rebind<X>::other;
+        using traits = std::allocator_traits<A>;
+        using allocator = typename traits::template rebind_alloc<X>;
         using type = svector<X, N, allocator, B>;
     };
 
     /**
-     * This array class is modeled after ``std::array`` but adds optional alignment through a template parameter.
+     * 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
      */
-    template <class T, std::size_t N, std::size_t Align = XTENSOR_SELECT_ALIGN>
+    template <class T, std::size_t N, std::size_t Align = XTENSOR_SELECT_ALIGN(T)>
     class alignas(Align) aligned_array : public std::array<T, N>
     {
     public:
+
         // Note: this is for alignment detection. The allocator serves no other purpose than
         //       that of a trait here.
-        using allocator_type = std::conditional_t<Align != 0,
-                                                  xsimd::aligned_allocator<T, Align>,
-                                                  std::allocator<T>>;
+        using allocator_type = std::conditional_t<Align != 0, xt_simd::aligned_allocator<T, Align>, std::allocator<T>>;
     };
 
 #if defined(_MSC_VER)
-    #define XTENSOR_CONST
+#define XTENSOR_CONST
 #else
-    #define XTENSOR_CONST const
-#endif
-
-#if defined(__GNUC__) && __GNUC__ < 5 && !defined(__clang__)
-    #define GCC4_FALLBACK
-
-    namespace const_array_detail
-    {
-        template <class T, std::size_t N>
-        struct array_traits
-        {
-            using storage_type = T[N];
-
-            static constexpr T& ref(const storage_type& t, std::size_t n) noexcept
-            {
-                return const_cast<T&>(t[n]);
-            }
-
-            static constexpr T* ptr(const storage_type& t) noexcept
-            {
-                return const_cast<T*>(t);
-            }
-        };
-
-        template <class T>
-        struct array_traits<T, 0>
-        {
-            struct empty {};
-
-            using storage_type = empty;
-
-            static constexpr T& ref(const storage_type& /*t*/, std::size_t /*n*/) noexcept
-            {
-                return *static_cast<T*>(nullptr);
-            }
-
-            static constexpr T* ptr(const storage_type& /*t*/) noexcept
-            {
-                return nullptr;
-            }
-        };
-    }
+#define XTENSOR_CONST const
 #endif
 
     /**
@@ -1321,11 +1455,7 @@ namespace xt
 
         constexpr const_reference operator[](std::size_t idx) const
         {
-        #ifdef GCC4_FALLBACK
-            return const_array_detail::array_traits<T, N>::ref(m_data, idx);
-        #else
             return m_data[idx];
-        #endif
         }
 
         constexpr const_iterator begin() const noexcept
@@ -1371,30 +1501,22 @@ namespace xt
 
         constexpr const_pointer data() const noexcept
         {
-        #ifdef GCC4_FALLBACK
-            return const_array_detail::array_traits<T, N>::ptr(m_data);
-        #else
             return m_data;
-        #endif
         }
 
         constexpr const_reference front() const noexcept
         {
-        #ifdef GCC4_FALLBACK
-            return const_array_detail::array_traits<T, N>::ref(m_data, 0);
-        #else
             return m_data[0];
-        #endif
         }
 
         constexpr const_reference back() const noexcept
         {
-        #ifdef GCC4_FALLBACK
-            return N ? const_array_detail::array_traits<T, N>::ref(m_data, N - 1) :
-                       const_array_detail::array_traits<T, N>::ref(m_data, 0);
-        #else
             return m_data[size() - 1];
-        #endif
+        }
+
+        constexpr bool empty() const noexcept
+        {
+            return size() == size_type(0);
         }
 
         constexpr size_type size() const noexcept
@@ -1402,18 +1524,47 @@ namespace xt
             return N;
         }
 
-    #ifdef GCC4_FALLBACK
-        XTENSOR_CONST typename const_array_detail::array_traits<T, N>::storage_type m_data;
-    #else
         XTENSOR_CONST T m_data[N > 0 ? N : 1];
-    #endif
     };
 
-#undef GCC4_FALLBACK
+    template <class T, std::size_t N>
+    inline bool operator==(const const_array<T, N>& lhs, const const_array<T, N>& rhs)
+    {
+        return std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin());
+    }
+
+    template <class T, std::size_t N>
+    inline bool operator!=(const const_array<T, N>& lhs, const const_array<T, N>& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    template <class T, std::size_t N>
+    inline bool operator<(const const_array<T, N>& lhs, const const_array<T, N>& rhs)
+    {
+        return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+    }
+
+    template <class T, std::size_t N>
+    inline bool operator<=(const const_array<T, N>& lhs, const const_array<T, N>& rhs)
+    {
+        return !(lhs > rhs);
+    }
+
+    template <class T, std::size_t N>
+    inline bool operator>(const const_array<T, N>& lhs, const const_array<T, N>& rhs)
+    {
+        return rhs < lhs;
+    }
 
+    template <class T, std::size_t N>
+    inline bool operator>=(const const_array<T, N>& lhs, const const_array<T, N>& rhs)
+    {
+        return !(lhs < rhs);
+    }
 
-// Workaround for rebind_container problems on GCC 8  with C++17 enabled
-#if defined(__GNUC__) && __GNUC__ > 6 && !defined(__clang__) && __cplusplus >= 201703L
+// Workaround for rebind_container problems when C++17 feature is enabled
+#ifdef __cpp_template_template_args
     template <class X, class T, std::size_t N>
     struct rebind_container<X, aligned_array<T, N>>
     {
@@ -1437,32 +1588,34 @@ namespace xt
     {
     public:
 
-#if defined(_MSC_VER)
-        using cast_type = std::array<std::size_t, sizeof...(X)>;
-        #define XTENSOR_FIXED_SHAPE_CONSTEXPR inline
-#else
         using cast_type = const_array<std::size_t, sizeof...(X)>;
-        #define XTENSOR_FIXED_SHAPE_CONSTEXPR constexpr
-#endif
         using value_type = std::size_t;
         using size_type = std::size_t;
+        using const_iterator = typename cast_type::const_iterator;
 
-        constexpr static std::size_t size()
+        static constexpr std::size_t size()
         {
             return sizeof...(X);
         }
 
-        XTENSOR_FIXED_SHAPE_CONSTEXPR operator cast_type() const
+        template <std::size_t idx>
+        static constexpr auto get()
+        {
+            using tmp_cast_type = std::array<std::size_t, sizeof...(X)>;
+            return std::get<idx>(tmp_cast_type{X...});
+        }
+
+        constexpr operator cast_type() const
         {
             return cast_type({X...});
         }
 
-        XTENSOR_FIXED_SHAPE_CONSTEXPR auto begin() const
+        constexpr auto begin() const
         {
             return m_array.begin();
         }
 
-        XTENSOR_FIXED_SHAPE_CONSTEXPR auto end() const
+        constexpr auto end() const
         {
             return m_array.end();
         }
@@ -1477,33 +1630,41 @@ namespace xt
             return m_array.rend();
         }
 
-        XTENSOR_FIXED_SHAPE_CONSTEXPR auto cbegin() const
+        constexpr auto cbegin() const
         {
             return m_array.cbegin();
         }
 
-        XTENSOR_FIXED_SHAPE_CONSTEXPR auto cend() const
+        constexpr auto cend() const
         {
             return m_array.cend();
         }
 
-        XTENSOR_FIXED_SHAPE_CONSTEXPR std::size_t operator[](std::size_t idx) const
+        auto crbegin() const
+        {
+            return m_array.crbegin();
+        }
+
+        auto crend() const
+        {
+            return m_array.crend();
+        }
+
+        constexpr std::size_t operator[](std::size_t idx) const
         {
             return m_array[idx];
         }
 
+        constexpr bool empty() const
+        {
+            return sizeof...(X) == 0;
+        }
+
     private:
 
-         XTENSOR_CONSTEXPR_ENHANCED_STATIC cast_type m_array = cast_type({X...});
+        XTENSOR_CONSTEXPR_ENHANCED_STATIC cast_type m_array = cast_type({X...});
     };
 
-#ifdef XTENSOR_HAS_CONSTEXPR_ENHANCED
-    template <std::size_t... X>
-    constexpr typename fixed_shape<X...>::cast_type fixed_shape<X...>::m_array;
-#endif
-
-#undef XTENSOR_FIXED_SHAPE_CONSTEXPR
-
     template <class E, std::ptrdiff_t Start, std::ptrdiff_t End = -1>
     class sequence_view
     {
@@ -1528,6 +1689,10 @@ namespace xt
         template <std::ptrdiff_t OS, std::ptrdiff_t OE>
         explicit 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;
 
@@ -1547,6 +1712,7 @@ namespace xt
         const E& storage() const;
 
     private:
+
         const E& m_sequence;
     };
 
@@ -1563,6 +1729,21 @@ namespace xt
     {
     }
 
+    template <class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+    template <class T, class R>
+    sequence_view<E, Start, End>::operator T() const
+    {
+        T ret = xtl::make_sequence<T>(this->size());
+        std::copy(this->cbegin(), this->cend(), ret.begin());
+        return ret;
+    }
+
+    template <class E, std::ptrdiff_t Start, std::ptrdiff_t End>
+    bool sequence_view<E, Start, End>::empty() const
+    {
+        return size() == size_type(0);
+    }
+
     template <class E, std::ptrdiff_t Start, std::ptrdiff_t End>
     auto sequence_view<E, Start, End>::size() const -> size_type
     {
@@ -1583,7 +1764,7 @@ namespace xt
     }
 
     template <class E, std::ptrdiff_t Start, std::ptrdiff_t End>
-    auto  sequence_view<E, Start, End>::end() const -> const_iterator
+    auto sequence_view<E, Start, End>::end() const -> const_iterator
     {
         if (End != -1)
         {
@@ -1596,19 +1777,19 @@ namespace xt
     }
 
     template <class E, std::ptrdiff_t Start, std::ptrdiff_t End>
-    auto  sequence_view<E, Start, End>::begin() const -> const_iterator
+    auto sequence_view<E, Start, End>::begin() const -> const_iterator
     {
         return m_sequence.begin() + Start;
     }
 
     template <class E, std::ptrdiff_t Start, std::ptrdiff_t End>
-    auto  sequence_view<E, Start, End>::cend() const -> const_iterator
+    auto sequence_view<E, Start, End>::cend() const -> const_iterator
     {
         return end();
     }
 
     template <class E, std::ptrdiff_t Start, std::ptrdiff_t End>
-    auto  sequence_view<E, Start, End>::cbegin() const -> const_iterator
+    auto sequence_view<E, Start, End>::cbegin() const -> const_iterator
     {
         return begin();
     }
@@ -1662,7 +1843,6 @@ namespace xt
         return m_sequence;
     }
 
-
     template <class T, std::ptrdiff_t TB, std::ptrdiff_t TE>
     inline bool operator==(const sequence_view<T, TB, TE>& lhs, const sequence_view<T, TB, TE>& rhs)
     {
@@ -1684,28 +1864,29 @@ namespace xt
 // G++ 8 C++ library does define it as a struct hence we get
 // clang warnings here
 
+// Do not remove space between "#" and "pragma". This is required for CRAN checks.
+// clang-format off
 #if defined(__clang__)
-    #pragma clang diagnostic push
-    #pragma clang diagnostic ignored "-Wmismatched-tags"
+ # pragma clang diagnostic push
+ # pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
+// clang-format on
 
 namespace std
 {
     template <class T, std::size_t N>
-    class tuple_size<xt::const_array<T, N>> :
-        public integral_constant<std::size_t, N>
+    class tuple_size<xt::const_array<T, N>> : public integral_constant<std::size_t, N>
     {
     };
 
     template <std::size_t... N>
-    class tuple_size<xt::fixed_shape<N...>> :
-        public integral_constant<std::size_t, sizeof...(N)>
+    class tuple_size<xt::fixed_shape<N...>> : public integral_constant<std::size_t, sizeof...(N)>
     {
     };
 
     template <class T, std::ptrdiff_t Start, std::ptrdiff_t End>
-    class tuple_size<xt::sequence_view<T, Start, End>> :
-        public integral_constant<std::size_t, std::size_t(End - Start)>
+    class tuple_size<xt::sequence_view<T, Start, End>>
+        : public integral_constant<std::size_t, std::size_t(End - Start)>
     {
     };
 
@@ -1714,12 +1895,13 @@ namespace std
     class tuple_size<xt::sequence_view<T, Start, -1>>;
 }
 
+// Do not remove space between "#" and "pragma". This is required for CRAN checks.
+// clang-format off
 #if defined(__clang__)
-    #pragma clang diagnostic pop
+ # pragma clang diagnostic pop
 #endif
+// clang-format on
 
 #undef XTENSOR_CONST
-#undef XTENSOR_ALIGNMENT
-#undef XTENSOR_SELECT_ALIGN
 
 #endif
diff --git a/include/xtensor/containers/xtensor.hpp b/include/xtensor/containers/xtensor.hpp
new file mode 100644
index 000000000..db8d92385
--- /dev/null
+++ b/include/xtensor/containers/xtensor.hpp
@@ -0,0 +1,983 @@
+/***************************************************************************
+ * 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_TENSOR_HPP
+#define XTENSOR_TENSOR_HPP
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "../containers/xbuffer_adaptor.hpp"
+#include "../containers/xcontainer.hpp"
+#include "../core/xsemantic.hpp"
+
+namespace xt
+{
+
+    /***********************
+     * xtensor declaration *
+     ***********************/
+
+    namespace extension
+    {
+        template <class EC, std::size_t N, layout_type L, class Tag>
+        struct xtensor_container_base;
+
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_container_base<EC, N, L, xtensor_expression_tag>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class EC, std::size_t N, layout_type L, class Tag>
+        using xtensor_container_base_t = typename xtensor_container_base<EC, N, L, Tag>::type;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    struct xcontainer_inner_types<xtensor_container<EC, N, L, Tag>>
+    {
+        using storage_type = EC;
+        using reference = inner_reference_t<storage_type>;
+        using const_reference = typename storage_type::const_reference;
+        using size_type = typename storage_type::size_type;
+        using shape_type = std::array<typename storage_type::size_type, N>;
+        using strides_type = get_strides_t<shape_type>;
+        using backstrides_type = get_strides_t<shape_type>;
+        using inner_shape_type = shape_type;
+        using inner_strides_type = strides_type;
+        using inner_backstrides_type = backstrides_type;
+        using temporary_type = xtensor_container<EC, N, L, Tag>;
+        static constexpr layout_type layout = L;
+    };
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    struct xiterable_inner_types<xtensor_container<EC, N, L, Tag>>
+        : xcontainer_iterable_types<xtensor_container<EC, N, L, Tag>>
+    {
+    };
+
+    /**
+     * @class xtensor_container
+     * @brief Dense multidimensional container with tensor semantic and fixed
+     * dimension.
+     *
+     * The xtensor_container class implements a dense multidimensional container
+     * with tensor semantics and fixed dimension
+     *
+     * @tparam EC The type of the container holding the elements.
+     * @tparam N The dimension of the container.
+     * @tparam L The layout_type of the tensor.
+     * @tparam Tag The expression tag.
+     * @sa xtensor, xstrided_container, xcontainer
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    class xtensor_container : public xstrided_container<xtensor_container<EC, N, L, Tag>>,
+                              public xcontainer_semantic<xtensor_container<EC, N, L, Tag>>,
+                              public extension::xtensor_container_base_t<EC, N, L, Tag>
+    {
+    public:
+
+        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;
+        static constexpr std::size_t rank = N;
+
+        xtensor_container();
+        xtensor_container(nested_initializer_list_t<value_type, N> t);
+        explicit xtensor_container(const shape_type& shape, layout_type l = L);
+        explicit xtensor_container(const shape_type& shape, const_reference value, layout_type l = L);
+        explicit xtensor_container(const shape_type& shape, const strides_type& strides);
+        explicit xtensor_container(const shape_type& shape, const strides_type& strides, const_reference value);
+        explicit xtensor_container(storage_type&& storage, inner_shape_type&& shape, inner_strides_type&& strides);
+
+        template <class S = shape_type>
+        static xtensor_container from_shape(S&& s);
+
+        ~xtensor_container() = default;
+
+        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>
+        explicit xtensor_container(xarray_container<EC, L, SC, Tag>&&);
+        template <class SC>
+        xtensor_container& operator=(xarray_container<EC, L, SC, Tag>&&);
+
+        template <class E>
+        xtensor_container(const xexpression<E>& e);
+
+        template <class E>
+        xtensor_container& operator=(const xexpression<E>& e);
+
+    private:
+
+        storage_type m_storage;
+
+        storage_type& storage_impl() noexcept;
+        const storage_type& storage_impl() const noexcept;
+
+        friend class xcontainer<xtensor_container<EC, N, L, Tag>>;
+    };
+
+    /*****************************************
+     * xtensor_container_adaptor declaration *
+     *****************************************/
+
+    namespace extension
+    {
+        template <class EC, std::size_t N, layout_type L, class Tag>
+        struct xtensor_adaptor_base;
+
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_adaptor_base<EC, N, L, xtensor_expression_tag>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class EC, std::size_t N, layout_type L, class Tag>
+        using xtensor_adaptor_base_t = typename xtensor_adaptor_base<EC, N, L, Tag>::type;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    struct xcontainer_inner_types<xtensor_adaptor<EC, N, L, Tag>>
+    {
+        using storage_type = std::remove_reference_t<EC>;
+        using reference = inner_reference_t<storage_type>;
+        using const_reference = typename storage_type::const_reference;
+        using size_type = typename storage_type::size_type;
+        using shape_type = std::array<typename storage_type::size_type, N>;
+        using strides_type = get_strides_t<shape_type>;
+        using backstrides_type = get_strides_t<shape_type>;
+        using inner_shape_type = shape_type;
+        using inner_strides_type = strides_type;
+        using inner_backstrides_type = backstrides_type;
+        using temporary_type = xtensor_container<temporary_container_t<storage_type>, N, L, Tag>;
+        static constexpr layout_type layout = L;
+    };
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    struct xiterable_inner_types<xtensor_adaptor<EC, N, L, Tag>>
+        : xcontainer_iterable_types<xtensor_adaptor<EC, N, L, Tag>>
+    {
+    };
+
+    /**
+     * @class xtensor_adaptor
+     * @brief 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.
+     *
+     * @tparam EC The closure for the container type to adapt.
+     * @tparam N The dimension of the adaptor.
+     * @tparam L The layout_type of the adaptor.
+     * @tparam Tag The expression tag.
+     * @sa xstrided_container, xcontainer
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    class xtensor_adaptor : public xstrided_container<xtensor_adaptor<EC, N, L, Tag>>,
+                            public xcontainer_semantic<xtensor_adaptor<EC, N, L, Tag>>,
+                            public extension::xtensor_adaptor_base_t<EC, N, L, Tag>
+    {
+    public:
+
+        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;
+        static constexpr std::size_t rank = N;
+
+        xtensor_adaptor(storage_type&& storage);
+        xtensor_adaptor(const storage_type& storage);
+
+        template <class D>
+        xtensor_adaptor(D&& storage, const shape_type& shape, layout_type l = L);
+
+        template <class D>
+        xtensor_adaptor(D&& storage, const shape_type& shape, const strides_type& strides);
+
+        ~xtensor_adaptor() = default;
+
+        xtensor_adaptor(const xtensor_adaptor&) = default;
+        xtensor_adaptor& operator=(const xtensor_adaptor&);
+
+        xtensor_adaptor(xtensor_adaptor&&) = default;
+        xtensor_adaptor& operator=(xtensor_adaptor&&);
+        xtensor_adaptor& operator=(temporary_type&&);
+
+        template <class E>
+        xtensor_adaptor& operator=(const xexpression<E>& e);
+
+        template <class P, class S>
+        void reset_buffer(P&& pointer, S&& size);
+
+    private:
+
+        container_closure_type m_storage;
+
+        storage_type& storage_impl() noexcept;
+        const storage_type& storage_impl() const noexcept;
+
+        friend class xcontainer<xtensor_adaptor<EC, N, L, Tag>>;
+    };
+
+    /****************************
+     * xtensor_view declaration *
+     ****************************/
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    class xtensor_view;
+
+    namespace extension
+    {
+        template <class EC, std::size_t N, layout_type L, class Tag>
+        struct xtensor_view_base;
+
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_view_base<EC, N, L, xtensor_expression_tag>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class EC, std::size_t N, layout_type L, class Tag>
+        using xtensor_view_base_t = typename xtensor_view_base<EC, N, L, Tag>::type;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    struct xcontainer_inner_types<xtensor_view<EC, N, L, Tag>>
+    {
+        using storage_type = std::remove_reference_t<EC>;
+        using reference = inner_reference_t<storage_type>;
+        using const_reference = typename storage_type::const_reference;
+        using size_type = typename storage_type::size_type;
+        using shape_type = std::array<typename storage_type::size_type, N>;
+        using strides_type = get_strides_t<shape_type>;
+        using backstrides_type = get_strides_t<shape_type>;
+        using inner_shape_type = shape_type;
+        using inner_strides_type = strides_type;
+        using inner_backstrides_type = backstrides_type;
+        using temporary_type = xtensor_container<temporary_container_t<storage_type>, N, L, Tag>;
+        static constexpr layout_type layout = L;
+    };
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    struct xiterable_inner_types<xtensor_view<EC, N, L, Tag>>
+        : xcontainer_iterable_types<xtensor_view<EC, N, L, Tag>>
+    {
+    };
+
+    /**
+     * @class xtensor_view
+     * @brief 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.
+     *
+     * @tparam EC The closure for the container type to adapt.
+     * @tparam N The dimension of the view.
+     * @tparam L The layout_type of the view.
+     * @tparam Tag The expression tag.
+     * @sa xstrided_container, xcontainer
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    class xtensor_view : public xstrided_container<xtensor_view<EC, N, L, Tag>>,
+                         public xview_semantic<xtensor_view<EC, N, L, Tag>>,
+                         public extension::xtensor_view_base_t<EC, N, L, Tag>
+    {
+    public:
+
+        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;
+
+        xtensor_view(storage_type&& storage);
+        xtensor_view(const storage_type& storage);
+
+        template <class D>
+        xtensor_view(D&& storage, const shape_type& shape, layout_type l = L);
+
+        template <class D>
+        xtensor_view(D&& storage, const shape_type& shape, const strides_type& strides);
+
+        ~xtensor_view() = default;
+
+        xtensor_view(const xtensor_view&) = default;
+        xtensor_view& operator=(const xtensor_view&);
+
+        xtensor_view(xtensor_view&&) = default;
+        xtensor_view& operator=(xtensor_view&&);
+
+        template <class E>
+        self_type& operator=(const xexpression<E>& e);
+
+        template <class E>
+        disable_xexpression<E, self_type>& operator=(const E& e);
+
+    private:
+
+        container_closure_type m_storage;
+
+        storage_type& storage_impl() noexcept;
+        const storage_type& storage_impl() const noexcept;
+
+        void assign_temporary_impl(temporary_type&& tmp);
+
+        friend class xcontainer<xtensor_view<EC, N, L, Tag>>;
+        friend class xview_semantic<xtensor_view<EC, N, L, Tag>>;
+    };
+
+    namespace detail
+    {
+        template <class V>
+        struct tensor_view_simd_helper
+        {
+            using valid_return_type = detail::has_simd_interface_impl<V, typename V::value_type>;
+            using valid_reference = std::is_lvalue_reference<typename V::reference>;
+            static constexpr bool value = valid_return_type::value && valid_reference::value;
+            using type = std::integral_constant<bool, value>;
+        };
+    }
+
+    // xtensor_view can be used on pseudo containers, i.e. containers
+    // whose access operator does not return a reference. Since it
+    // is not possible to take the address f a temporary, the load_simd
+    // method implementation leads to a compilation error.
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    struct has_simd_interface<xtensor_view<EC, N, L, Tag>>
+        : detail::tensor_view_simd_helper<xtensor_view<EC, N, L, Tag>>::type
+    {
+    };
+
+    /************************************
+     * xtensor_container implementation *
+     ************************************/
+
+    /**
+     * @name Constructors
+     */
+    //@{
+    /**
+     * Allocates an uninitialized xtensor_container that holds 0 elements.
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container()
+        : base_type()
+        , m_storage(N == 0 ? 1 : 0, value_type())
+    {
+    }
+
+    /**
+     * Allocates an xtensor_container with nested initializer lists.
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(nested_initializer_list_t<value_type, N> t)
+        : base_type()
+    {
+        base_type::resize(xt::shape<shape_type>(t), true);
+        constexpr auto tmp = layout_type::row_major;
+        L == tmp ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<tmp>(), t);
+    }
+
+    /**
+     * Allocates an uninitialized xtensor_container with the specified shape and
+     * layout_type.
+     * @param shape the shape of the xtensor_container
+     * @param l the layout_type of the xtensor_container
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const shape_type& shape, layout_type l)
+        : base_type()
+    {
+        base_type::resize(shape, l);
+    }
+
+    /**
+     * Allocates an xtensor_container with the specified shape and layout_type. Elements
+     * are initialized to the specified value.
+     * @param shape the shape of the xtensor_container
+     * @param value the value of the elements
+     * @param l the layout_type of the xtensor_container
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(
+        const shape_type& shape,
+        const_reference value,
+        layout_type l
+    )
+        : base_type()
+    {
+        base_type::resize(shape, l);
+        std::fill(m_storage.begin(), m_storage.end(), value);
+    }
+
+    /**
+     * Allocates an uninitialized xtensor_container with the specified shape and strides.
+     * @param shape the shape of the xtensor_container
+     * @param strides the strides of the xtensor_container
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const shape_type& shape, const strides_type& strides)
+        : base_type()
+    {
+        base_type::resize(shape, strides);
+    }
+
+    /**
+     * Allocates an uninitialized xtensor_container with the specified shape and strides.
+     * Elements are initialized to the specified value.
+     * @param shape the shape of the xtensor_container
+     * @param strides the strides of the xtensor_container
+     * @param value the value of the elements
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(
+        const shape_type& shape,
+        const strides_type& strides,
+        const_reference value
+    )
+        : base_type()
+    {
+        base_type::resize(shape, strides);
+        std::fill(m_storage.begin(), m_storage.end(), value);
+    }
+
+    /**
+     * Allocates an xtensor_container by moving specified data, shape and strides
+     *
+     * @param storage the data for the xtensor_container
+     * @param shape the shape of the xtensor_container
+     * @param strides the strides of the xtensor_container
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(
+        storage_type&& storage,
+        inner_shape_type&& shape,
+        inner_strides_type&& strides
+    )
+        : base_type(std::move(shape), std::move(strides))
+        , m_storage(std::move(storage))
+    {
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class SC>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(xarray_container<EC, L, SC, Tag>&& rhs)
+        : base_type(
+            xtl::forward_sequence<inner_shape_type, decltype(rhs.shape())>(rhs.shape()),
+            xtl::forward_sequence<inner_strides_type, decltype(rhs.strides())>(rhs.strides()),
+            xtl::forward_sequence<inner_backstrides_type, decltype(rhs.backstrides())>(rhs.backstrides()),
+            std::move(rhs.layout())
+        )
+        , m_storage(std::move(rhs.storage()))
+    {
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class SC>
+    inline xtensor_container<EC, N, L, Tag>&
+    xtensor_container<EC, N, L, Tag>::operator=(xarray_container<EC, L, SC, Tag>&& rhs)
+    {
+        XTENSOR_ASSERT_MSG(N == rhs.dimension(), "Cannot change dimension of xtensor.");
+        std::copy(rhs.shape().begin(), rhs.shape().end(), this->shape_impl().begin());
+        std::copy(rhs.strides().cbegin(), rhs.strides().cend(), this->strides_impl().begin());
+        std::copy(rhs.backstrides().cbegin(), rhs.backstrides().cend(), this->backstrides_impl().begin());
+        this->mutable_layout() = std::move(rhs.layout());
+        m_storage = std::move(std::move(rhs.storage()));
+        return *this;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class S>
+    inline xtensor_container<EC, N, L, Tag> xtensor_container<EC, N, L, Tag>::from_shape(S&& s)
+    {
+        XTENSOR_ASSERT_MSG(s.size() == N, "Cannot change dimension of xtensor.");
+        shape_type shape = xtl::forward_sequence<shape_type, S>(s);
+        return self_type(shape);
+    }
+
+    //@}
+
+    /**
+     * @name Extended copy semantic
+     */
+    //@{
+    /**
+     * The extended copy constructor.
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class E>
+    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const xexpression<E>& e)
+        : base_type()
+    {
+        XTENSOR_ASSERT_MSG(N == e.derived_cast().dimension(), "Cannot change dimension of xtensor.");
+        // Avoids uninitialized data because of (m_shape == shape) condition
+        // in resize (called by assign), which is always true when dimension() == 0.
+        if (e.derived_cast().dimension() == 0)
+        {
+            detail::resize_data_container(m_storage, std::size_t(1));
+        }
+        semantic_base::assign(e);
+    }
+
+    /**
+     * The extended assignment operator.
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class E>
+    inline auto xtensor_container<EC, N, L, Tag>::operator=(const xexpression<E>& e) -> self_type&
+    {
+        return semantic_base::operator=(e);
+    }
+
+    //@}
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_container<EC, N, L, Tag>::storage_impl() noexcept -> storage_type&
+    {
+        return m_storage;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_container<EC, N, L, Tag>::storage_impl() const noexcept -> const storage_type&
+    {
+        return m_storage;
+    }
+
+    /**********************************
+     * xtensor_adaptor implementation *
+     **********************************/
+
+    /**
+     * @name Constructors
+     */
+    //@{
+    /**
+     * Constructs an xtensor_adaptor of the given stl-like container.
+     * @param storage the container to adapt
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(storage_type&& storage)
+        : base_type()
+        , m_storage(std::move(storage))
+    {
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given stl-like container.
+     * @param storage the container to adapt
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(const storage_type& storage)
+        : base_type()
+        , m_storage(storage)
+    {
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given stl-like container,
+     * with the specified shape and layout_type.
+     * @param storage the container to adapt
+     * @param shape the shape of the xtensor_adaptor
+     * @param l the layout_type of the xtensor_adaptor
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class D>
+    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(D&& storage, const shape_type& shape, layout_type l)
+        : base_type()
+        , m_storage(std::forward<D>(storage))
+    {
+        base_type::resize(shape, l);
+    }
+
+    /**
+     * Constructs an xtensor_adaptor of the given stl-like container,
+     * with the specified shape and strides.
+     * @param storage the container to adapt
+     * @param shape the shape of the xtensor_adaptor
+     * @param strides the strides of the xtensor_adaptor
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class D>
+    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(
+        D&& storage,
+        const shape_type& shape,
+        const strides_type& strides
+    )
+        : base_type()
+        , m_storage(std::forward<D>(storage))
+    {
+        base_type::resize(shape, strides);
+    }
+
+    //@}
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(const xtensor_adaptor& rhs) -> self_type&
+    {
+        base_type::operator=(rhs);
+        m_storage = rhs.m_storage;
+        return *this;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(xtensor_adaptor&& rhs) -> self_type&
+    {
+        base_type::operator=(std::move(rhs));
+        m_storage = rhs.m_storage;
+        return *this;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(temporary_type&& rhs) -> self_type&
+    {
+        base_type::shape_impl() = std::move(const_cast<shape_type&>(rhs.shape()));
+        base_type::strides_impl() = std::move(const_cast<strides_type&>(rhs.strides()));
+        base_type::backstrides_impl() = std::move(const_cast<backstrides_type&>(rhs.backstrides()));
+        m_storage = std::move(rhs.storage());
+        return *this;
+    }
+
+    /**
+     * @name Extended copy semantic
+     */
+    //@{
+    /**
+     * The extended assignment operator.
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class E>
+    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(const xexpression<E>& e) -> self_type&
+    {
+        return semantic_base::operator=(e);
+    }
+
+    //@}
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_adaptor<EC, N, L, Tag>::storage_impl() noexcept -> storage_type&
+    {
+        return m_storage;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_adaptor<EC, N, L, Tag>::storage_impl() const noexcept -> const storage_type&
+    {
+        return m_storage;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class P, class S>
+    inline void xtensor_adaptor<EC, N, L, Tag>::reset_buffer(P&& pointer, S&& size)
+    {
+        return m_storage.reset_data(std::forward<P>(pointer), std::forward<S>(size));
+    }
+
+    /*******************************
+     * xtensor_view implementation *
+     *******************************/
+
+    /**
+     * @name Constructors
+     */
+    //@{
+    /**
+     * Constructs an xtensor_view of the given stl-like container.
+     * @param storage the container to adapt
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_view<EC, N, L, Tag>::xtensor_view(storage_type&& storage)
+        : base_type()
+        , m_storage(std::move(storage))
+    {
+    }
+
+    /**
+     * Constructs an xtensor_view of the given stl-like container.
+     * @param storage the container to adapt
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline xtensor_view<EC, N, L, Tag>::xtensor_view(const storage_type& storage)
+        : base_type()
+        , m_storage(storage)
+    {
+    }
+
+    /**
+     * Constructs an xtensor_view of the given stl-like container,
+     * with the specified shape and layout_type.
+     * @param storage the container to adapt
+     * @param shape the shape of the xtensor_view
+     * @param l the layout_type of the xtensor_view
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class D>
+    inline xtensor_view<EC, N, L, Tag>::xtensor_view(D&& storage, const shape_type& shape, layout_type l)
+        : base_type()
+        , m_storage(std::forward<D>(storage))
+    {
+        base_type::resize(shape, l);
+    }
+
+    /**
+     * Constructs an xtensor_view of the given stl-like container,
+     * with the specified shape and strides.
+     * @param storage the container to adapt
+     * @param shape the shape of the xtensor_view
+     * @param strides the strides of the xtensor_view
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class D>
+    inline xtensor_view<EC, N, L, Tag>::xtensor_view(D&& storage, const shape_type& shape, const strides_type& strides)
+        : base_type()
+        , m_storage(std::forward<D>(storage))
+    {
+        base_type::resize(shape, strides);
+    }
+
+    //@}
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_view<EC, N, L, Tag>::operator=(const xtensor_view& rhs) -> self_type&
+    {
+        base_type::operator=(rhs);
+        m_storage = rhs.m_storage;
+        return *this;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_view<EC, N, L, Tag>::operator=(xtensor_view&& rhs) -> self_type&
+    {
+        base_type::operator=(std::move(rhs));
+        m_storage = rhs.m_storage;
+        return *this;
+    }
+
+    /**
+     * @name Extended copy semantic
+     */
+    //@{
+    /**
+     * The extended assignment operator.
+     */
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class E>
+    inline auto xtensor_view<EC, N, L, Tag>::operator=(const xexpression<E>& e) -> self_type&
+    {
+        return semantic_base::operator=(e);
+    }
+
+    //@}
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    template <class E>
+    inline auto xtensor_view<EC, N, L, Tag>::operator=(const E& e) -> disable_xexpression<E, self_type>&
+    {
+        std::fill(m_storage.begin(), m_storage.end(), e);
+        return *this;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_view<EC, N, L, Tag>::storage_impl() noexcept -> storage_type&
+    {
+        return m_storage;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline auto xtensor_view<EC, N, L, Tag>::storage_impl() const noexcept -> const storage_type&
+    {
+        return m_storage;
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    inline void xtensor_view<EC, N, L, Tag>::assign_temporary_impl(temporary_type&& tmp)
+    {
+        std::copy(tmp.cbegin(), tmp.cend(), m_storage.begin());
+    }
+
+    /**
+     * Converts ``std::vector<index_type>`` (returned e.g. from ``xt::argwhere``) to ``xtensor``.
+     *
+     * @param idx vector of indices
+     *
+     * @return ``xt::xtensor<typename index_type::value_type, 2>`` (e.g. ``xt::xtensor<size_t, 2>``)
+     */
+    template <class T>
+    inline auto from_indices(const std::vector<T>& idx)
+    {
+        using return_type = xtensor<typename T::value_type, 2>;
+        using size_type = typename return_type::size_type;
+
+        if (idx.size() == 0)
+        {
+            return return_type::from_shape({size_type(0), size_type(0)});
+        }
+
+        return_type out = return_type::from_shape({idx.size(), idx[0].size()});
+
+        for (size_type i = 0; i < out.shape()[0]; ++i)
+        {
+            for (size_type j = 0; j < out.shape()[1]; ++j)
+            {
+                out(i, j) = idx[i][j];
+            }
+        }
+
+        return out;
+    }
+
+    /**
+     * Converts ``std::vector<index_type>`` (returned e.g. from ``xt::argwhere``) to a flattened
+     * ``xtensor``.
+     *
+     * @param idx a vector of indices
+     *
+     * @return ``xt::xtensor<typename index_type::value_type, 1>`` (e.g. ``xt::xtensor<size_t, 1>``)
+     */
+    template <class T>
+    inline auto flatten_indices(const std::vector<T>& idx)
+    {
+        auto n = idx.size();
+        if (n != 0)
+        {
+            n *= idx[0].size();
+        }
+
+        using return_type = xtensor<typename T::value_type, 1>;
+        return_type out = return_type::from_shape({n});
+        auto iter = out.begin();
+        for_each(
+            idx.begin(),
+            idx.end(),
+            [&iter](const auto& t)
+            {
+                iter = std::copy(t.cbegin(), t.cend(), iter);
+            }
+        );
+
+        return out;
+    }
+
+    struct ravel_vector_tag;
+    struct ravel_tensor_tag;
+
+    namespace detail
+    {
+        template <class C, class Tag>
+        struct ravel_return_type;
+
+        template <class C>
+        struct ravel_return_type<C, ravel_vector_tag>
+        {
+            using index_type = typename C::value_type;
+            using value_type = typename index_type::value_type;
+            using type = std::vector<value_type>;
+
+            template <class T>
+            static std::vector<value_type> init(T n)
+            {
+                return std::vector<value_type>(n);
+            }
+        };
+
+        template <class C>
+        struct ravel_return_type<C, ravel_tensor_tag>
+        {
+            using index_type = typename C::value_type;
+            using value_type = typename index_type::value_type;
+            using type = xt::xtensor<value_type, 1>;
+
+            template <class T>
+            static xt::xtensor<value_type, 1> init(T n)
+            {
+                return xtensor<value_type, 1>::from_shape({n});
+            }
+        };
+    }
+
+    template <class C, class Tag>
+    using ravel_return_type_t = typename detail::ravel_return_type<C, Tag>::type;
+
+    /**
+     * Converts ``std::vector<index_type>`` (returned e.g. from ``xt::argwhere``) to ``xtensor``
+     * whereby the indices are ravelled. For 1-d input there is no conversion.
+     *
+     * @param idx vector of indices
+     * @param shape the shape of the original array
+     * @param l the layout type (row-major or column-major)
+     *
+     * @return ``xt::xtensor<typename index_type::value_type, 1>`` (e.g. ``xt::xtensor<size_t, 1>``)
+     */
+    template <class Tag = ravel_tensor_tag, class C, class S>
+    ravel_return_type_t<C, Tag>
+    ravel_indices(const C& idx, const S& shape, layout_type l = layout_type::row_major)
+    {
+        using return_type = typename detail::ravel_return_type<C, Tag>::type;
+        using value_type = typename detail::ravel_return_type<C, Tag>::value_type;
+        using strides_type = get_strides_t<S>;
+        strides_type strides = xtl::make_sequence<strides_type>(shape.size(), 0);
+        compute_strides(shape, l, strides);
+        return_type out = detail::ravel_return_type<C, Tag>::init(idx.size());
+        auto out_iter = out.begin();
+        auto idx_iter = idx.begin();
+        for (; out_iter != out.end(); ++out_iter, ++idx_iter)
+        {
+            *out_iter = element_offset<value_type>(strides, (*idx_iter).cbegin(), (*idx_iter).cend());
+        }
+        return out;
+    }
+}
+
+#endif
diff --git a/include/xtensor/core/xaccessible.hpp b/include/xtensor/core/xaccessible.hpp
new file mode 100644
index 000000000..8ca55f8a4
--- /dev/null
+++ b/include/xtensor/core/xaccessible.hpp
@@ -0,0 +1,347 @@
+/***************************************************************************
+ * 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_ACCESSIBLE_HPP
+#define XTENSOR_ACCESSIBLE_HPP
+
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../utils/xexception.hpp"
+
+namespace xt
+{
+    /**
+     * @class xconst_accessible
+     * @brief Base class for implementation of common expression constant access methods.
+     *
+     * The xaccessible class implements constant access methods common to all expressions.
+     *
+     * @tparam D The derived type, i.e. the inheriting class for which xconst_accessible
+     *           provides the interface.
+     */
+    template <class D>
+    class xconst_accessible
+    {
+    public:
+
+        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;
+
+        size_type size() const noexcept(noexcept(derived_cast().shape()));
+        size_type dimension() const noexcept;
+        size_type shape(size_type index) const;
+
+        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;
+
+        const_reference front() const;
+        const_reference back() const;
+
+    protected:
+
+        xconst_accessible() = default;
+        ~xconst_accessible() = default;
+
+        xconst_accessible(const xconst_accessible&) = default;
+        xconst_accessible& operator=(const xconst_accessible&) = default;
+
+        xconst_accessible(xconst_accessible&&) = default;
+        xconst_accessible& operator=(xconst_accessible&&) = default;
+
+    private:
+
+        const derived_type& derived_cast() const noexcept;
+    };
+
+    /**
+     * @class xaccessible
+     * @brief Base class for implementation of common expression access methods.
+     *
+     * The xaccessible class implements access methods common to all expressions.
+     *
+     * @tparam D The derived type, i.e. the inheriting class for which xaccessible
+     *           provides the interface.
+     */
+    template <class D>
+    class xaccessible : public xconst_accessible<D>
+    {
+    public:
+
+        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;
+
+        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();
+        reference back();
+
+        using base_type::at;
+        using base_type::operator[];
+        using base_type::back;
+        using base_type::front;
+        using base_type::periodic;
+
+    protected:
+
+        xaccessible() = default;
+        ~xaccessible() = default;
+
+        xaccessible(const xaccessible&) = default;
+        xaccessible& operator=(const xaccessible&) = default;
+
+        xaccessible(xaccessible&&) = default;
+        xaccessible& operator=(xaccessible&&) = default;
+
+    private:
+
+        derived_type& derived_cast() noexcept;
+    };
+
+    /************************************
+     * xconst_accessible implementation *
+     ************************************/
+
+    /**
+     * Returns the size of the expression.
+     */
+    template <class D>
+    inline auto xconst_accessible<D>::size() const noexcept(noexcept(derived_cast().shape())) -> size_type
+    {
+        return compute_size(derived_cast().shape());
+    }
+
+    /**
+     * Returns the number of dimensions of the expression.
+     */
+    template <class D>
+    inline auto xconst_accessible<D>::dimension() const noexcept -> size_type
+    {
+        return derived_cast().shape().size();
+    }
+
+    /**
+     * Returns the i-th dimension of the expression.
+     */
+    template <class D>
+    inline auto xconst_accessible<D>::shape(size_type index) const -> size_type
+    {
+        return derived_cast().shape()[index];
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the expression,
+     * after dimension and bounds checking.
+     * @param args a 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.
+     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
+     * or if indices are out of bounds.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xconst_accessible<D>::at(Args... args) const -> const_reference
+    {
+        check_access(derived_cast().shape(), args...);
+        return derived_cast().operator()(args...);
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the expression.
+     * @param index a 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.
+     */
+    template <class D>
+    template <class S>
+    inline auto xconst_accessible<D>::operator[](const S& index) const
+        -> disable_integral_t<S, const_reference>
+    {
+        return derived_cast().element(index.cbegin(), index.cend());
+    }
+
+    template <class D>
+    template <class I>
+    inline auto xconst_accessible<D>::operator[](std::initializer_list<I> index) const -> const_reference
+    {
+        return derived_cast().element(index.begin(), index.end());
+    }
+
+    template <class D>
+    inline auto xconst_accessible<D>::operator[](size_type i) const -> const_reference
+    {
+        return derived_cast().operator()(i);
+    }
+
+    /**
+     * 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).
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xconst_accessible<D>::periodic(Args... args) const -> const_reference
+    {
+        normalize_periodic(derived_cast().shape(), args...);
+        return derived_cast()(static_cast<size_type>(args)...);
+    }
+
+    /**
+     * Returns a constant reference to first the element of the expression
+     */
+    template <class D>
+    inline auto xconst_accessible<D>::front() const -> const_reference
+    {
+        return *derived_cast().begin();
+    }
+
+    /**
+     * Returns a constant reference to last the element of the expression
+     */
+    template <class D>
+    inline auto xconst_accessible<D>::back() const -> const_reference
+    {
+        return *std::prev(derived_cast().end());
+    }
+
+    /**
+     * Returns ``true`` only if the the specified position is a valid entry in the expression.
+     * @param args a list of indices specifying the position in the expression.
+     * @return bool
+     */
+    template <class D>
+    template <class... Args>
+    inline bool xconst_accessible<D>::in_bounds(Args... args) const
+    {
+        return check_in_bounds(derived_cast().shape(), args...);
+    }
+
+    template <class D>
+    inline auto xconst_accessible<D>::derived_cast() const noexcept -> const derived_type&
+    {
+        return *static_cast<const derived_type*>(this);
+    }
+
+    /******************************
+     * xaccessible implementation *
+     ******************************/
+
+    /**
+     * Returns a reference to the element at the specified position in the expression,
+     * after dimension and bounds checking.
+     * @param args a 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.
+     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
+     * or if indices are out of bounds.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xaccessible<D>::at(Args... args) -> reference
+    {
+        check_access(derived_cast().shape(), args...);
+        return derived_cast().operator()(args...);
+    }
+
+    /**
+     * Returns a reference to the element at the specified position in the expression.
+     * @param index a 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.
+     */
+    template <class D>
+    template <class S>
+    inline auto xaccessible<D>::operator[](const S& index) -> disable_integral_t<S, reference>
+    {
+        return derived_cast().element(index.cbegin(), index.cend());
+    }
+
+    template <class D>
+    template <class I>
+    inline auto xaccessible<D>::operator[](std::initializer_list<I> index) -> reference
+    {
+        return derived_cast().element(index.begin(), index.end());
+    }
+
+    template <class D>
+    inline auto xaccessible<D>::operator[](size_type i) -> reference
+    {
+        return derived_cast().operator()(i);
+    }
+
+    /**
+     * 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).
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xaccessible<D>::periodic(Args... args) -> reference
+    {
+        normalize_periodic(derived_cast().shape(), args...);
+        return derived_cast()(args...);
+    }
+
+    /**
+     * Returns a reference to the first element of the expression.
+     */
+    template <class D>
+    inline auto xaccessible<D>::front() -> reference
+    {
+        return *derived_cast().begin();
+    }
+
+    /**
+     * Returns a reference to the last element of the expression.
+     */
+    template <class D>
+    inline auto xaccessible<D>::back() -> reference
+    {
+        return *std::prev(derived_cast().end());
+    }
+
+    template <class D>
+    inline auto xaccessible<D>::derived_cast() noexcept -> derived_type&
+    {
+        return *static_cast<derived_type*>(this);
+    }
+
+}
+
+#endif
diff --git a/include/xtensor/core/xassign.hpp b/include/xtensor/core/xassign.hpp
new file mode 100644
index 000000000..174ddcdc0
--- /dev/null
+++ b/include/xtensor/core/xassign.hpp
@@ -0,0 +1,1361 @@
+/***************************************************************************
+ * 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_ASSIGN_HPP
+#define XTENSOR_ASSIGN_HPP
+
+#include <algorithm>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include <xtl/xcomplex.hpp>
+#include <xtl/xsequence.hpp>
+
+#include "../core/xexpression.hpp"
+#include "../core/xfunction.hpp"
+#include "../core/xiterator.hpp"
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../utils/xutils.hpp"
+
+#if defined(XTENSOR_USE_TBB)
+#include <tbb/tbb.h>
+#endif
+
+namespace xt
+{
+
+    /********************
+     * Assign functions *
+     ********************/
+
+    template <class E1, class E2>
+    void assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial);
+
+    template <class E1, class E2>
+    void assign_xexpression(xexpression<E1>& e1, const xexpression<E2>& e2);
+
+    template <class E1, class E2>
+    void computed_assign(xexpression<E1>& e1, const xexpression<E2>& e2);
+
+    template <class E1, class E2, class F>
+    void scalar_computed_assign(xexpression<E1>& e1, const E2& e2, F&& f);
+
+    template <class E1, class E2>
+    void assert_compatible_shape(const xexpression<E1>& e1, const xexpression<E2>& e2);
+
+    template <class E1, class E2>
+    void strided_assign(E1& e1, const E2& e2, std::false_type /*disable*/);
+
+    template <class E1, class E2>
+    void strided_assign(E1& e1, const E2& e2, std::true_type /*enable*/);
+
+    /************************
+     * xexpression_assigner *
+     ************************/
+
+    template <class Tag>
+    class xexpression_assigner_base;
+
+    template <>
+    class xexpression_assigner_base<xtensor_expression_tag>
+    {
+    public:
+
+        template <class E1, class E2>
+        static void assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial);
+    };
+
+    template <class Tag>
+    class xexpression_assigner : public xexpression_assigner_base<Tag>
+    {
+    public:
+
+        using base_type = xexpression_assigner_base<Tag>;
+
+        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);
+
+    private:
+
+        template <class E1, class E2>
+        static bool resize(E1& e1, const E2& e2);
+
+        template <class E1, class F, class... CT>
+        static bool resize(E1& e1, const xfunction<F, CT...>& e2);
+    };
+
+    /********************
+     * stepper_assigner *
+     ********************/
+
+    template <class E1, class E2, layout_type L>
+    class stepper_assigner
+    {
+    public:
+
+        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;
+
+        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);
+
+    private:
+
+        E1& m_e1;
+
+        lhs_iterator m_lhs;
+        rhs_iterator m_rhs;
+
+        index_type m_index;
+    };
+
+    /*******************
+     * linear_assigner *
+     *******************/
+
+    template <bool simd_assign>
+    class linear_assigner
+    {
+    public:
+
+        template <class E1, class E2>
+        static void run(E1& e1, const E2& e2);
+    };
+
+    template <>
+    class linear_assigner<false>
+    {
+    public:
+
+        template <class E1, class E2>
+        static void run(E1& e1, const E2& e2);
+
+    private:
+
+        template <class E1, class E2>
+        static void run_impl(E1& e1, const E2& e2, std::true_type);
+
+        template <class E1, class E2>
+        static void run_impl(E1& e1, const E2& e2, std::false_type);
+    };
+
+    /*************************
+     * strided_loop_assigner *
+     *************************/
+
+    namespace strided_assign_detail
+    {
+        struct loop_sizes_t
+        {
+            bool can_do_strided_assign;
+            bool is_row_major;
+            std::size_t inner_loop_size;
+            std::size_t outer_loop_size;
+            std::size_t cut;
+            std::size_t dimension;
+        };
+    }
+
+    template <bool simd>
+    class strided_loop_assigner
+    {
+    public:
+
+        using loop_sizes_t = strided_assign_detail::loop_sizes_t;
+        // is_row_major, inner_loop_size, outer_loop_size, cut
+        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);
+    };
+
+    /***********************************
+     * Assign functions implementation *
+     ***********************************/
+
+    template <class E1, class E2>
+    inline void assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
+    {
+        using tag = xexpression_tag_t<E1, E2>;
+        xexpression_assigner<tag>::assign_data(e1, e2, trivial);
+    }
+
+    template <class E1, class E2>
+    inline void assign_xexpression(xexpression<E1>& e1, const xexpression<E2>& e2)
+    {
+        if constexpr (assignable_to_expression<E1, E2>)
+        {
+            e2.derived_cast().assign_to(e1);
+        }
+        else
+        {
+            using tag = xexpression_tag_t<E1, E2>;
+            xexpression_assigner<tag>::assign_xexpression(e1, e2);
+        }
+    }
+
+    template <class E1, class E2>
+    inline void computed_assign(xexpression<E1>& e1, const xexpression<E2>& e2)
+    {
+        using tag = xexpression_tag_t<E1, E2>;
+        xexpression_assigner<tag>::computed_assign(e1, e2);
+    }
+
+    template <class E1, class E2, class F>
+    inline void scalar_computed_assign(xexpression<E1>& e1, const E2& e2, F&& f)
+    {
+        using tag = xexpression_tag_t<E1, E2>;
+        xexpression_assigner<tag>::scalar_computed_assign(e1, e2, std::forward<F>(f));
+    }
+
+    template <class E1, class E2>
+    inline void assert_compatible_shape(const xexpression<E1>& e1, const xexpression<E2>& e2)
+    {
+        using tag = xexpression_tag_t<E1, E2>;
+        xexpression_assigner<tag>::assert_compatible_shape(e1, e2);
+    }
+
+    /***************************************
+     * xexpression_assigner implementation *
+     ***************************************/
+
+    namespace detail
+    {
+        template <class E1, class E2>
+        constexpr bool linear_static_layout()
+        {
+            // A row_major or column_major container with a dimension <= 1 is computed as
+            // layout any, leading to some performance improvements, for example when
+            // assigning a col-major vector to a row-major vector etc
+            return compute_layout(
+                       select_layout<E1::static_layout, typename E1::shape_type>::value,
+                       select_layout<E2::static_layout, typename E2::shape_type>::value
+                   )
+                   != layout_type::dynamic;
+        }
+
+        template <class E1, class E2>
+        inline auto is_linear_assign(const E1& e1, const E2& e2)
+            -> std::enable_if_t<strided_expression<E1>, bool>
+        {
+            return (E1::contiguous_layout && E2::contiguous_layout && linear_static_layout<E1, E2>())
+                   || (e1.is_contiguous() && e2.has_linear_assign(e1.strides()));
+        }
+
+        template <class E1, class E2>
+        inline auto is_linear_assign(const E1&, const E2&) -> std::enable_if_t<!strided_expression<E1>, bool>
+        {
+            return false;
+        }
+
+        template <class E1, class E2>
+        inline bool linear_dynamic_layout(const E1& e1, const E2& e2)
+        {
+            return e1.is_contiguous() && e2.is_contiguous()
+                   && compute_layout(e1.layout(), e2.layout()) != layout_type::dynamic;
+        }
+
+        template <class E, class = void>
+        struct has_step_leading : std::false_type
+        {
+        };
+
+        template <class E>
+        struct has_step_leading<E, void_t<decltype(std::declval<E>().step_leading())>> : std::true_type
+        {
+        };
+
+        template <class T>
+        struct use_strided_loop
+        {
+            static constexpr bool stepper_deref()
+            {
+                return std::is_reference<typename T::stepper::reference>::value;
+            }
+
+            static constexpr bool value = strided_expression<T>
+                                          && has_step_leading<typename T::stepper>::value && stepper_deref();
+        };
+
+        template <class T>
+        struct use_strided_loop<xscalar<T>>
+        {
+            static constexpr bool value = true;
+        };
+
+        template <class F, class... CT>
+        struct use_strided_loop<xfunction<F, CT...>>
+        {
+            static constexpr bool value = std::conjunction<use_strided_loop<std::decay_t<CT>>...>::value;
+        };
+
+        /**
+         * Considering the assignment LHS = RHS, if the requested value type used for
+         * loading simd from RHS is not complex while LHS value_type is complex,
+         * the assignment fails. The reason is that SIMD batches of complex values cannot
+         * be implicitly instantiated from batches of scalar values.
+         * Making the constructor implicit does not fix the issue since in the end,
+         * the assignment is done with vec.store(buffer) where vec is a batch of scalars
+         * and buffer an array of complex. SIMD batches of scalars do not provide overloads
+         * of store that accept buffer of complex values and that SHOULD NOT CHANGE.
+         * Load and store overloads must accept SCALAR BUFFERS ONLY.
+         * Therefore, the solution is to explicitly force the instantiation of complex
+         * batches in the assignment mechanism. A common situation that triggers this
+         * issue is:
+         * xt::xarray<double> rhs = { 1, 2, 3 };
+         * xt::xarray<std::complex<double>> lhs = rhs;
+         */
+        template <class T1, class T2>
+        struct conditional_promote_to_complex
+        {
+            static constexpr bool cond = xtl::is_gen_complex<T1>::value && !xtl::is_gen_complex<T2>::value;
+            // Alternative: use std::complex<T2> or xcomplex<T2, T2, bool> depending on T1
+            using type = std::conditional_t<cond, T1, T2>;
+        };
+
+        template <class T1, class T2>
+        using conditional_promote_to_complex_t = typename conditional_promote_to_complex<T1, T2>::type;
+    }
+
+    template <class E1, class E2>
+    class xassign_traits
+    {
+    private:
+
+        using e1_value_type = typename E1::value_type;
+        using e2_value_type = typename E2::value_type;
+
+        template <class T>
+        using is_bool = std::is_same<T, bool>;
+
+        static constexpr bool is_bool_conversion()
+        {
+            return is_bool<e2_value_type>::value && !is_bool<e1_value_type>::value;
+        }
+
+        static constexpr bool contiguous_layout()
+        {
+            return E1::contiguous_layout && E2::contiguous_layout;
+        }
+
+        static constexpr bool convertible_types()
+        {
+            return std::is_convertible<e2_value_type, e1_value_type>::value && !is_bool_conversion();
+        }
+
+        static constexpr bool use_xsimd()
+        {
+            return xt_simd::simd_traits<int8_t>::size > 1;
+        }
+
+        template <class T>
+        static constexpr bool simd_size_impl()
+        {
+            return xt_simd::simd_traits<T>::size > 1 || (is_bool<T>::value && use_xsimd());
+        }
+
+        static constexpr bool simd_size()
+        {
+            return simd_size_impl<e1_value_type>() && simd_size_impl<e2_value_type>();
+        }
+
+        static constexpr bool simd_interface()
+        {
+            return has_simd_interface<E1, requested_value_type>()
+                   && has_simd_interface<E2, requested_value_type>();
+        }
+
+    public:
+
+        // constexpr methods instead of constexpr data members avoid the need of definitions at namespace
+        // scope of these data members (since they are odr-used).
+
+        static constexpr bool simd_assign()
+        {
+            return convertible_types() && simd_size() && simd_interface();
+        }
+
+        static constexpr bool linear_assign(const E1& e1, const E2& e2, bool trivial)
+        {
+            return trivial && detail::is_linear_assign(e1, e2);
+        }
+
+        static constexpr bool strided_assign()
+        {
+            return detail::use_strided_loop<E1>::value && detail::use_strided_loop<E2>::value;
+        }
+
+        static constexpr bool simd_linear_assign()
+        {
+            return contiguous_layout() && simd_assign();
+        }
+
+        static constexpr bool simd_strided_assign()
+        {
+            return strided_assign() && simd_assign();
+        }
+
+        static constexpr bool simd_linear_assign(const E1& e1, const E2& e2)
+        {
+            return simd_assign() && detail::linear_dynamic_layout(e1, e2);
+        }
+
+        using e2_requested_value_type = std::
+            conditional_t<is_bool<e2_value_type>::value, typename E2::bool_load_type, e2_value_type>;
+        using requested_value_type = detail::conditional_promote_to_complex_t<e1_value_type, e2_requested_value_type>;
+    };
+
+    template <class E1, class E2>
+    inline void xexpression_assigner_base<xtensor_expression_tag>::assign_data(
+        xexpression<E1>& e1,
+        const xexpression<E2>& e2,
+        bool trivial
+    )
+    {
+        E1& de1 = e1.derived_cast();
+        const E2& de2 = e2.derived_cast();
+        using traits = xassign_traits<E1, E2>;
+
+        bool linear_assign = traits::linear_assign(de1, de2, trivial);
+        constexpr bool simd_assign = traits::simd_assign();
+        constexpr bool simd_linear_assign = traits::simd_linear_assign();
+        constexpr bool simd_strided_assign = traits::simd_strided_assign();
+        if (linear_assign)
+        {
+            if (simd_linear_assign || traits::simd_linear_assign(de1, de2))
+            {
+                // Do not use linear_assigner<true> here since it will make the compiler
+                // instantiate this branch even if the runtime condition is false, resulting
+                // in compilation error for expressions that do not provide a SIMD interface.
+                // simd_assign is true if simd_linear_assign() or simd_linear_assign(de1, de2)
+                // is true.
+                linear_assigner<simd_assign>::run(de1, de2);
+            }
+            else
+            {
+                linear_assigner<false>::run(de1, de2);
+            }
+        }
+        else if (simd_strided_assign)
+        {
+            strided_loop_assigner<simd_strided_assign>::run(de1, de2);
+        }
+        else
+        {
+            stepper_assigner<E1, E2, default_assignable_layout(E1::static_layout)>(de1, de2).run();
+        }
+    }
+
+    template <class Tag>
+    template <class E1, class E2>
+    inline void xexpression_assigner<Tag>::assign_xexpression(E1& e1, const E2& e2)
+    {
+        bool trivial_broadcast = resize(e1.derived_cast(), e2.derived_cast());
+        base_type::assign_data(e1, e2, trivial_broadcast);
+    }
+
+    template <class Tag>
+    template <class E1, class E2>
+    inline void xexpression_assigner<Tag>::computed_assign(xexpression<E1>& e1, const xexpression<E2>& e2)
+    {
+        using shape_type = typename E1::shape_type;
+        using comperator_type = std::greater<typename shape_type::value_type>;
+
+        using size_type = typename E1::size_type;
+
+        E1& de1 = e1.derived_cast();
+        const E2& de2 = e2.derived_cast();
+
+        size_type dim2 = de2.dimension();
+        shape_type shape = uninitialized_shape<shape_type>(dim2);
+
+        bool trivial_broadcast = de2.broadcast_shape(shape, true);
+
+        auto&& de1_shape = de1.shape();
+        if (dim2 > de1.dimension()
+            || std::lexicographical_compare(
+                shape.begin(),
+                shape.end(),
+                de1_shape.begin(),
+                de1_shape.end(),
+                comperator_type()
+            ))
+        {
+            typename E1::temporary_type tmp(shape);
+            base_type::assign_data(tmp, e2, trivial_broadcast);
+            de1.assign_temporary(std::move(tmp));
+        }
+        else
+        {
+            base_type::assign_data(e1, e2, trivial_broadcast);
+        }
+    }
+
+    template <class Tag>
+    template <class E1, class E2, class F>
+    inline void xexpression_assigner<Tag>::scalar_computed_assign(xexpression<E1>& e1, const E2& e2, F&& f)
+    {
+        E1& d = e1.derived_cast();
+        using size_type = typename E1::size_type;
+        auto dst = d.storage().begin();
+        for (size_type i = d.size(); i > 0; --i)
+        {
+            *dst = f(*dst, e2);
+            ++dst;
+        }
+    }
+
+    template <class Tag>
+    template <class E1, class E2>
+    inline void
+    xexpression_assigner<Tag>::assert_compatible_shape(const xexpression<E1>& e1, const xexpression<E2>& e2)
+    {
+        const E1& de1 = e1.derived_cast();
+        const E2& de2 = e2.derived_cast();
+        if (!broadcastable(de2.shape(), de1.shape()))
+        {
+            throw_broadcast_error(de2.shape(), de1.shape());
+        }
+    }
+
+    namespace detail
+    {
+        template <bool B, class... CT>
+        struct static_trivial_broadcast;
+
+        template <class... CT>
+        struct static_trivial_broadcast<true, CT...>
+        {
+            static constexpr bool value = detail::promote_index<typename std::decay_t<CT>::shape_type...>::value;
+        };
+
+        template <class... CT>
+        struct static_trivial_broadcast<false, CT...>
+        {
+            static constexpr bool value = false;
+        };
+    }
+
+    template <class Tag>
+    template <class E1, class E2>
+    inline bool xexpression_assigner<Tag>::resize(E1& e1, const E2& e2)
+    {
+        // If our RHS is not a xfunction, we know that the RHS is at least potentially trivial
+        // We check the strides of the RHS in detail::is_trivial_broadcast to see if they match up!
+        // So we can skip a shape copy and a call to broadcast_shape(...)
+        e1.resize(e2.shape());
+        return true;
+    }
+
+    template <class Tag>
+    template <class E1, class F, class... CT>
+    inline bool xexpression_assigner<Tag>::resize(E1& e1, const xfunction<F, CT...>& e2)
+    {
+        if constexpr (detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value)
+        {
+            /*
+             * If the shape of the xfunction is statically known, we can compute the broadcast triviality
+             * at compile time plus we can resize right away.
+             */
+            // resize in case LHS is not a fixed size container. If it is, this is a NOP
+            e1.resize(typename xfunction<F, CT...>::shape_type{});
+            return detail::static_trivial_broadcast<
+                detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value,
+                CT...>::value;
+        }
+        else
+        {
+            using index_type = xindex_type_t<typename E1::shape_type>;
+            using size_type = typename E1::size_type;
+            size_type size = e2.dimension();
+            index_type shape = uninitialized_shape<index_type>(size);
+            bool trivial_broadcast = e2.broadcast_shape(shape, true);
+            e1.resize(std::move(shape));
+            return trivial_broadcast;
+        }
+    }
+
+    /***********************************
+     * stepper_assigner implementation *
+     ***********************************/
+
+    template <class FROM, class TO>
+    struct is_narrowing_conversion
+    {
+        using argument_type = std::decay_t<FROM>;
+        using result_type = std::decay_t<TO>;
+
+        static const bool value = xtl::is_arithmetic<result_type>::value
+                                  && (sizeof(result_type) < sizeof(argument_type)
+                                      || (xtl::is_integral<result_type>::value
+                                          && std::is_floating_point<argument_type>::value));
+    };
+
+    template <class FROM, class TO>
+    struct has_sign_conversion
+    {
+        using argument_type = std::decay_t<FROM>;
+        using result_type = std::decay_t<TO>;
+
+        static const bool value = xtl::is_signed<argument_type>::value != xtl::is_signed<result_type>::value;
+    };
+
+    template <class FROM, class TO>
+    struct has_assign_conversion
+    {
+        using argument_type = std::decay_t<FROM>;
+        using result_type = std::decay_t<TO>;
+
+        static const bool value = is_narrowing_conversion<argument_type, result_type>::value
+                                  || has_sign_conversion<argument_type, result_type>::value;
+    };
+
+    template <class E1, class E2, layout_type L>
+    inline stepper_assigner<E1, E2, L>::stepper_assigner(E1& e1, const E2& e2)
+        : m_e1(e1)
+        , m_lhs(e1.stepper_begin(e1.shape()))
+        , m_rhs(e2.stepper_begin(e1.shape()))
+        , m_index(xtl::make_sequence<index_type>(e1.shape().size(), size_type(0)))
+    {
+    }
+
+    template <class E1, class E2, layout_type L>
+    inline void stepper_assigner<E1, E2, L>::run()
+    {
+        using tmp_size_type = typename E1::size_type;
+        using argument_type = std::decay_t<decltype(*m_rhs)>;
+        using result_type = std::decay_t<decltype(*m_lhs)>;
+        constexpr bool needs_cast = has_assign_conversion<argument_type, result_type>::value;
+
+        tmp_size_type s = m_e1.size();
+        for (tmp_size_type i = 0; i < s; ++i)
+        {
+            *m_lhs = conditional_cast<needs_cast, result_type>(*m_rhs);
+            stepper_tools<L>::increment_stepper(*this, m_index, m_e1.shape());
+        }
+    }
+
+    template <class E1, class E2, layout_type L>
+    inline void stepper_assigner<E1, E2, L>::step(size_type i)
+    {
+        m_lhs.step(i);
+        m_rhs.step(i);
+    }
+
+    template <class E1, class E2, layout_type L>
+    inline void stepper_assigner<E1, E2, L>::step(size_type i, size_type n)
+    {
+        m_lhs.step(i, n);
+        m_rhs.step(i, n);
+    }
+
+    template <class E1, class E2, layout_type L>
+    inline void stepper_assigner<E1, E2, L>::reset(size_type i)
+    {
+        m_lhs.reset(i);
+        m_rhs.reset(i);
+    }
+
+    template <class E1, class E2, layout_type L>
+    inline void stepper_assigner<E1, E2, L>::to_end(layout_type l)
+    {
+        m_lhs.to_end(l);
+        m_rhs.to_end(l);
+    }
+
+    /**********************************
+     * linear_assigner implementation *
+     **********************************/
+
+    template <bool simd_assign>
+    template <class E1, class E2>
+    inline void linear_assigner<simd_assign>::run(E1& e1, const E2& e2)
+    {
+        using lhs_align_mode = xt_simd::container_alignment_t<E1>;
+        constexpr bool is_aligned = std::is_same<lhs_align_mode, aligned_mode>::value;
+        using rhs_align_mode = std::conditional_t<is_aligned, inner_aligned_mode, unaligned_mode>;
+        using e1_value_type = typename E1::value_type;
+        using e2_value_type = typename E2::value_type;
+        using value_type = typename xassign_traits<E1, E2>::requested_value_type;
+        using simd_type = xt_simd::simd_type<value_type>;
+        using size_type = typename E1::size_type;
+        size_type size = e1.size();
+        constexpr size_type simd_size = simd_type::size;
+        constexpr bool needs_cast = has_assign_conversion<e2_value_type, e1_value_type>::value;
+
+        size_type align_begin = is_aligned ? 0 : xt_simd::get_alignment_offset(e1.data(), size, simd_size);
+        size_type align_end = align_begin + ((size - align_begin) & ~(simd_size - 1));
+
+        for (size_type i = 0; i < align_begin; ++i)
+        {
+            e1.data_element(i) = conditional_cast<needs_cast, e1_value_type>(e2.data_element(i));
+        }
+
+#if defined(XTENSOR_USE_TBB)
+        if (size >= XTENSOR_TBB_THRESHOLD)
+        {
+            tbb::static_partitioner ap;
+            tbb::parallel_for(
+                align_begin,
+                align_end,
+                simd_size,
+                [&e1, &e2](size_t i)
+                {
+                    e1.template store_simd<lhs_align_mode>(
+                        i,
+                        e2.template load_simd<rhs_align_mode, value_type>(i)
+                    );
+                },
+                ap
+            );
+        }
+        else
+        {
+            for (size_type i = align_begin; i < align_end; i += simd_size)
+            {
+                e1.template store_simd<lhs_align_mode>(i, e2.template load_simd<rhs_align_mode, value_type>(i));
+            }
+        }
+#elif defined(XTENSOR_USE_OPENMP)
+        if (size >= size_type(XTENSOR_OPENMP_TRESHOLD))
+        {
+#pragma omp parallel for default(none) shared(align_begin, align_end, e1, e2)
+#ifndef _WIN32
+            for (size_type i = align_begin; i < align_end; i += simd_size)
+            {
+                e1.template store_simd<lhs_align_mode>(i, e2.template load_simd<rhs_align_mode, value_type>(i));
+            }
+#else
+            for (auto i = static_cast<std::ptrdiff_t>(align_begin); i < static_cast<std::ptrdiff_t>(align_end);
+                 i += static_cast<std::ptrdiff_t>(simd_size))
+            {
+                size_type ui = static_cast<size_type>(i);
+                e1.template store_simd<lhs_align_mode>(ui, e2.template load_simd<rhs_align_mode, value_type>(ui));
+            }
+#endif
+        }
+        else
+        {
+            for (size_type i = align_begin; i < align_end; i += simd_size)
+            {
+                e1.template store_simd<lhs_align_mode>(i, e2.template load_simd<rhs_align_mode, value_type>(i));
+            }
+        }
+#else
+        for (size_type i = align_begin; i < align_end; i += simd_size)
+        {
+            e1.template store_simd<lhs_align_mode>(i, e2.template load_simd<rhs_align_mode, value_type>(i));
+        }
+#endif
+        for (size_type i = align_end; i < size; ++i)
+        {
+            e1.data_element(i) = conditional_cast<needs_cast, e1_value_type>(e2.data_element(i));
+        }
+    }
+
+    template <class E1, class E2>
+    inline void linear_assigner<false>::run(E1& e1, const E2& e2)
+    {
+        using is_convertible = std::
+            is_convertible<typename std::decay_t<E2>::value_type, typename std::decay_t<E1>::value_type>;
+        // If the types are not compatible, this function is still instantiated but never called.
+        // To avoid compilation problems in effectively unused code trivial_assigner_run_impl is
+        // empty in this case.
+        run_impl(e1, e2, is_convertible());
+    }
+
+    template <class E1, class E2>
+    inline void linear_assigner<false>::run_impl(E1& e1, const E2& e2, std::true_type /*is_convertible*/)
+    {
+        using value_type = typename E1::value_type;
+        using size_type = typename E1::size_type;
+        auto src = linear_begin(e2);
+        auto dst = linear_begin(e1);
+        size_type n = e1.size();
+#if defined(XTENSOR_USE_TBB)
+        tbb::static_partitioner sp;
+        tbb::parallel_for(
+            std::ptrdiff_t(0),
+            static_cast<std::ptrdiff_t>(n),
+            [&](std::ptrdiff_t i)
+            {
+                *(dst + i) = static_cast<value_type>(*(src + i));
+            },
+            sp
+        );
+#elif defined(XTENSOR_USE_OPENMP)
+        if (n >= XTENSOR_OPENMP_TRESHOLD)
+        {
+#pragma omp parallel for default(none) shared(src, dst, n)
+            for (std::ptrdiff_t i = std::ptrdiff_t(0); i < static_cast<std::ptrdiff_t>(n); i++)
+            {
+                *(dst + i) = static_cast<value_type>(*(src + i));
+            }
+        }
+        else
+        {
+            for (; n > size_type(0); --n)
+            {
+                *dst = static_cast<value_type>(*src);
+                ++src;
+                ++dst;
+            }
+        }
+#else
+        for (; n > size_type(0); --n)
+        {
+            *dst = static_cast<value_type>(*src);
+            ++src;
+            ++dst;
+        }
+#endif
+    }
+
+    template <class E1, class E2>
+    inline void linear_assigner<false>::run_impl(E1&, const E2&, std::false_type /*is_convertible*/)
+    {
+        XTENSOR_PRECONDITION(false, "Internal error: linear_assigner called with unrelated types.");
+    }
+
+    /****************************************
+     * strided_loop_assigner implementation *
+     ****************************************/
+
+    namespace strided_assign_detail
+    {
+        template <layout_type layout>
+        struct idx_tools;
+
+        template <>
+        struct idx_tools<layout_type::row_major>
+        {
+            template <class T>
+            static void next_idx(T& outer_index, T& outer_shape)
+            {
+                auto i = outer_index.size();
+                for (; i > 0; --i)
+                {
+                    if (outer_index[i - 1] + 1 >= outer_shape[i - 1])
+                    {
+                        outer_index[i - 1] = 0;
+                    }
+                    else
+                    {
+                        outer_index[i - 1]++;
+                        break;
+                    }
+                }
+            }
+
+            template <class T>
+            static void nth_idx(size_t n, T& outer_index, const T& outer_shape)
+            {
+                dynamic_shape<std::size_t> stride_sizes;
+                xt::resize_container(stride_sizes, outer_shape.size());
+                // compute strides
+                using size_type = typename T::size_type;
+                for (size_type i = outer_shape.size(); i > 0; i--)
+                {
+                    stride_sizes[i - 1] = (i == outer_shape.size()) ? 1 : stride_sizes[i] * outer_shape[i];
+                }
+
+                // compute index
+                for (size_type i = 0; i < outer_shape.size(); i++)
+                {
+                    auto d_idx = n / stride_sizes[i];
+                    outer_index[i] = d_idx;
+                    n -= d_idx * stride_sizes[i];
+                }
+            }
+        };
+
+        template <>
+        struct idx_tools<layout_type::column_major>
+        {
+            template <class T>
+            static void next_idx(T& outer_index, T& outer_shape)
+            {
+                using size_type = typename T::size_type;
+                size_type i = 0;
+                auto sz = outer_index.size();
+                for (; i < sz; ++i)
+                {
+                    if (outer_index[i] + 1 >= outer_shape[i])
+                    {
+                        outer_index[i] = 0;
+                    }
+                    else
+                    {
+                        outer_index[i]++;
+                        break;
+                    }
+                }
+            }
+
+            template <class T>
+            static void nth_idx(size_t n, T& outer_index, const T& outer_shape)
+            {
+                dynamic_shape<std::size_t> stride_sizes;
+                xt::resize_container(stride_sizes, outer_shape.size());
+
+                using size_type = typename T::size_type;
+
+                // compute required strides
+                for (size_type i = 0; i < outer_shape.size(); i++)
+                {
+                    stride_sizes[i] = (i == 0) ? 1 : stride_sizes[i - 1] * outer_shape[i - 1];
+                }
+
+                // compute index
+                for (size_type i = outer_shape.size(); i > 0;)
+                {
+                    i--;
+                    auto d_idx = n / stride_sizes[i];
+                    outer_index[i] = d_idx;
+                    n -= d_idx * stride_sizes[i];
+                }
+            }
+        };
+
+        template <layout_type L, class S>
+        struct check_strides_functor
+        {
+            using strides_type = S;
+
+            check_strides_functor(const S& strides)
+                : m_cut(L == layout_type::row_major ? 0 : strides.size())
+                , m_strides(strides)
+            {
+            }
+
+            template <class T, layout_type LE = L>
+            std::enable_if_t<LE == layout_type::row_major, std::size_t> operator()(const T& el)
+            {
+                // All dimenions less than var have differing strides
+                auto var = check_strides_overlap<layout_type::row_major>::get(m_strides, el.strides());
+                if (var > m_cut)
+                {
+                    m_cut = var;
+                }
+                return m_cut;
+            }
+
+            template <class T, layout_type LE = L>
+            std::enable_if_t<LE == layout_type::column_major, std::size_t> operator()(const T& el)
+            {
+                auto var = check_strides_overlap<layout_type::column_major>::get(m_strides, el.strides());
+                // All dimensions >= var have differing strides
+                if (var < m_cut)
+                {
+                    m_cut = var;
+                }
+                return m_cut;
+            }
+
+            template <class T>
+            std::size_t operator()(const xt::xscalar<T>& /*el*/)
+            {
+                return m_cut;
+            }
+
+            template <class F, class... CT>
+            std::size_t operator()(const xt::xfunction<F, CT...>& xf)
+            {
+                xt::for_each(*this, xf.arguments());
+                return m_cut;
+            }
+
+        private:
+
+            std::size_t m_cut;
+            const strides_type& m_strides;
+        };
+
+        template <bool possible = true, class E1, class E2, std::enable_if_t<!strided_expression<E1> || !possible, bool> = true>
+        loop_sizes_t get_loop_sizes(const E1& e1, const E2&)
+        {
+            return {false, true, 1, e1.size(), e1.dimension(), e1.dimension()};
+        }
+
+        template <bool possible = true, class E1, class E2, std::enable_if_t<strided_expression<E1> && possible, bool> = true>
+        loop_sizes_t get_loop_sizes(const E1& e1, const E2& e2)
+        {
+            using shape_value_type = typename E1::shape_type::value_type;
+            bool is_row_major = true;
+
+            // Try to find a row-major scheme first, where the outer loop is on the first N = `cut`
+            // dimensions, and the inner loop is
+            is_row_major = true;
+            auto is_zero = [](auto i)
+            {
+                return i == 0;
+            };
+            auto&& strides = e1.strides();
+            auto it_bwd = std::find_if_not(strides.rbegin(), strides.rend(), is_zero);
+            bool de1_row_contiguous = it_bwd != strides.rend() && *it_bwd == 1;
+            auto it_fwd = std::find_if_not(strides.begin(), strides.end(), is_zero);
+            bool de1_col_contiguous = it_fwd != strides.end() && *it_fwd == 1;
+            if (de1_row_contiguous)
+            {
+                is_row_major = true;
+            }
+            else if (de1_col_contiguous)
+            {
+                is_row_major = false;
+            }
+            else
+            {
+                // No strided loop possible.
+                return {false, true, 1, e1.size(), e1.dimension(), e1.dimension()};
+            }
+
+            // Cut is the number of dimensions in the outer loop
+            std::size_t cut = 0;
+
+            if (is_row_major)
+            {
+                auto csf = check_strides_functor<layout_type::row_major, decltype(e1.strides())>(e1.strides());
+                cut = csf(e2);
+                // This makes that only one dimension will be treated in the inner loop.
+                if (cut < e1.strides().size() - 1)
+                {
+                    // Only make the inner loop go over one dimension by default for now
+                    cut = e1.strides().size() - 1;
+                }
+            }
+            else if (!is_row_major)
+            {
+                auto csf = check_strides_functor<layout_type::column_major, decltype(e1.strides())>(e1.strides()
+                );
+                cut = csf(e2);
+                if (cut > 1)
+                {
+                    // Only make the inner loop go over one dimension by default for now
+                    cut = 1;
+                }
+            }  // can't reach here because this would have already triggered the fallback
+
+            std::size_t outer_loop_size = static_cast<std::size_t>(std::accumulate(
+                e1.shape().begin(),
+                e1.shape().begin() + static_cast<std::ptrdiff_t>(cut),
+                shape_value_type(1),
+                std::multiplies<shape_value_type>{}
+            ));
+            std::size_t inner_loop_size = static_cast<std::size_t>(std::accumulate(
+                e1.shape().begin() + static_cast<std::ptrdiff_t>(cut),
+                e1.shape().end(),
+                shape_value_type(1),
+                std::multiplies<shape_value_type>{}
+            ));
+
+            if (!is_row_major)
+            {
+                std::swap(outer_loop_size, inner_loop_size);
+            }
+
+            return {inner_loop_size > 1, is_row_major, inner_loop_size, outer_loop_size, cut, e1.dimension()};
+        }
+    }
+
+    template <bool simd>
+    template <class E1, class E2>
+    inline strided_assign_detail::loop_sizes_t strided_loop_assigner<simd>::get_loop_sizes(E1& e1, const E2& e2)
+    {
+        return strided_assign_detail::get_loop_sizes<simd>(e1, e2);
+    }
+
+#define strided_parallel_assign
+
+    template <bool simd>
+    template <class E1, class E2>
+    inline void strided_loop_assigner<simd>::run(E1& e1, const E2& e2, const loop_sizes_t& loop_sizes)
+    {
+        bool is_row_major = loop_sizes.is_row_major;
+        std::size_t inner_loop_size = loop_sizes.inner_loop_size;
+        std::size_t outer_loop_size = loop_sizes.outer_loop_size;
+        std::size_t cut = loop_sizes.cut;
+
+
+        // TODO can we get rid of this and use `shape_type`?
+        dynamic_shape<std::size_t> idx, max_shape;
+
+        if (is_row_major)
+        {
+            xt::resize_container(idx, cut);
+            max_shape.assign(e1.shape().begin(), e1.shape().begin() + static_cast<std::ptrdiff_t>(cut));
+        }
+        else
+        {
+            xt::resize_container(idx, e1.shape().size() - cut);
+            max_shape.assign(e1.shape().begin() + static_cast<std::ptrdiff_t>(cut), e1.shape().end());
+        }
+
+        // add this when we have std::array index!
+        // std::fill(idx.begin(), idx.end(), 0);
+        using e1_value_type = typename E1::value_type;
+        using e2_value_type = typename E2::value_type;
+        constexpr bool needs_cast = has_assign_conversion<e2_value_type, e1_value_type>::value;
+        using value_type = typename xassign_traits<E1, E2>::requested_value_type;
+        using simd_type = std::conditional_t<
+            std::is_same<e1_value_type, bool>::value,
+            xt_simd::simd_bool_type<value_type>,
+            xt_simd::simd_type<value_type>>;
+
+        std::size_t simd_size = inner_loop_size / simd_type::size;
+        std::size_t simd_rest = inner_loop_size % simd_type::size;
+
+        auto fct_stepper = e2.stepper_begin(e1.shape());
+        auto res_stepper = e1.stepper_begin(e1.shape());
+
+        // TODO in 1D case this is ambiguous -- could be RM or CM.
+        //      Use default layout to make decision
+        std::size_t step_dim = 0;
+        if (!is_row_major)  // row major case
+        {
+            step_dim = cut;
+        }
+#if defined(XTENSOR_USE_OPENMP) && defined(strided_parallel_assign)
+        if (outer_loop_size >= XTENSOR_OPENMP_TRESHOLD / inner_loop_size)
+        {
+            std::size_t first_step = true;
+#pragma omp parallel for schedule(static) firstprivate(first_step, fct_stepper, res_stepper, idx)
+            for (std::size_t ox = 0; ox < outer_loop_size; ++ox)
+            {
+                if (first_step)
+                {
+                    is_row_major
+                        ? strided_assign_detail::idx_tools<layout_type::row_major>::nth_idx(ox, idx, max_shape)
+                        : strided_assign_detail::idx_tools<layout_type::column_major>::nth_idx(ox, idx, max_shape);
+
+                    for (std::size_t i = 0; i < idx.size(); ++i)
+                    {
+                        fct_stepper.step(i + step_dim, idx[i]);
+                        res_stepper.step(i + step_dim, idx[i]);
+                    }
+                    first_step = false;
+                }
+
+                for (std::size_t i = 0; i < simd_size; ++i)
+                {
+                    res_stepper.store_simd(fct_stepper.template step_simd<value_type>());
+                }
+                for (std::size_t i = 0; i < simd_rest; ++i)
+                {
+                    *(res_stepper) = conditional_cast<needs_cast, e1_value_type>(*(fct_stepper));
+                    res_stepper.step_leading();
+                    fct_stepper.step_leading();
+                }
+
+                // next unaligned index
+                is_row_major
+                    ? strided_assign_detail::idx_tools<layout_type::row_major>::next_idx(idx, max_shape)
+                    : strided_assign_detail::idx_tools<layout_type::column_major>::next_idx(idx, max_shape);
+
+                fct_stepper.to_begin();
+
+                // need to step E1 as well if not contigous assign (e.g. view)
+                if (!E1::contiguous_layout)
+                {
+                    res_stepper.to_begin();
+                    for (std::size_t i = 0; i < idx.size(); ++i)
+                    {
+                        fct_stepper.step(i + step_dim, idx[i]);
+                        res_stepper.step(i + step_dim, idx[i]);
+                    }
+                }
+                else
+                {
+                    for (std::size_t i = 0; i < idx.size(); ++i)
+                    {
+                        fct_stepper.step(i + step_dim, idx[i]);
+                    }
+                }
+            }
+        }
+        else
+        {
+#elif defined(strided_parallel_assign) && defined(XTENSOR_USE_TBB)
+        if (outer_loop_size > XTENSOR_TBB_THRESHOLD / inner_loop_size)
+        {
+            tbb::static_partitioner sp;
+            tbb::parallel_for(
+                tbb::blocked_range<size_t>(0ul, outer_loop_size),
+                [&e1, &e2, is_row_major, step_dim, simd_size, simd_rest, &max_shape, &idx_ = idx](
+                    const tbb::blocked_range<size_t>& r
+                )
+                {
+                    auto idx = idx_;
+                    auto fct_stepper = e2.stepper_begin(e1.shape());
+                    auto res_stepper = e1.stepper_begin(e1.shape());
+                    std::size_t first_step = true;
+                    // #pragma omp parallel for schedule(static) firstprivate(first_step, fct_stepper,
+                    // res_stepper, idx)
+                    for (std::size_t ox = r.begin(); ox < r.end(); ++ox)
+                    {
+                        if (first_step)
+                        {
+                            is_row_major
+                                ? strided_assign_detail::idx_tools<layout_type::row_major>::nth_idx(ox, idx, max_shape)
+                                : strided_assign_detail::idx_tools<layout_type::column_major>::nth_idx(
+                                    ox,
+                                    idx,
+                                    max_shape
+                                );
+
+                            for (std::size_t i = 0; i < idx.size(); ++i)
+                            {
+                                fct_stepper.step(i + step_dim, idx[i]);
+                                res_stepper.step(i + step_dim, idx[i]);
+                            }
+                            first_step = false;
+                        }
+
+                        for (std::size_t i = 0; i < simd_size; ++i)
+                        {
+                            res_stepper.store_simd(fct_stepper.template step_simd<value_type>());
+                        }
+                        for (std::size_t i = 0; i < simd_rest; ++i)
+                        {
+                            *(res_stepper) = conditional_cast<needs_cast, e1_value_type>(*(fct_stepper));
+                            res_stepper.step_leading();
+                            fct_stepper.step_leading();
+                        }
+
+                        // next unaligned index
+                        is_row_major
+                            ? strided_assign_detail::idx_tools<layout_type::row_major>::next_idx(idx, max_shape)
+                            : strided_assign_detail::idx_tools<layout_type::column_major>::next_idx(idx, max_shape);
+
+                        fct_stepper.to_begin();
+
+                        // need to step E1 as well if not contigous assign (e.g. view)
+                        if (!E1::contiguous_layout)
+                        {
+                            res_stepper.to_begin();
+                            for (std::size_t i = 0; i < idx.size(); ++i)
+                            {
+                                fct_stepper.step(i + step_dim, idx[i]);
+                                res_stepper.step(i + step_dim, idx[i]);
+                            }
+                        }
+                        else
+                        {
+                            for (std::size_t i = 0; i < idx.size(); ++i)
+                            {
+                                fct_stepper.step(i + step_dim, idx[i]);
+                            }
+                        }
+                    }
+                },
+                sp
+            );
+        }
+        else
+        {
+
+#endif
+            for (std::size_t ox = 0; ox < outer_loop_size; ++ox)
+            {
+                for (std::size_t i = 0; i < simd_size; ++i)
+                {
+                    res_stepper.store_simd(fct_stepper.template step_simd<value_type>());
+                }
+                for (std::size_t i = 0; i < simd_rest; ++i)
+                {
+                    *(res_stepper) = conditional_cast<needs_cast, e1_value_type>(*(fct_stepper));
+                    res_stepper.step_leading();
+                    fct_stepper.step_leading();
+                }
+
+                is_row_major
+                    ? strided_assign_detail::idx_tools<layout_type::row_major>::next_idx(idx, max_shape)
+                    : strided_assign_detail::idx_tools<layout_type::column_major>::next_idx(idx, max_shape);
+
+                fct_stepper.to_begin();
+
+                // need to step E1 as well if not contigous assign (e.g. view)
+                if (!E1::contiguous_layout)
+                {
+                    res_stepper.to_begin();
+                    for (std::size_t i = 0; i < idx.size(); ++i)
+                    {
+                        fct_stepper.step(i + step_dim, idx[i]);
+                        res_stepper.step(i + step_dim, idx[i]);
+                    }
+                }
+                else
+                {
+                    for (std::size_t i = 0; i < idx.size(); ++i)
+                    {
+                        fct_stepper.step(i + step_dim, idx[i]);
+                    }
+                }
+            }
+#if (defined(XTENSOR_USE_OPENMP) || defined(XTENSOR_USE_TBB)) && defined(strided_parallel_assign)
+        }
+#endif
+    }
+
+    template <>
+    template <class E1, class E2>
+    inline void strided_loop_assigner<true>::run(E1& e1, const E2& e2)
+    {
+        strided_assign_detail::loop_sizes_t loop_sizes = strided_loop_assigner<true>::get_loop_sizes(e1, e2);
+        if (loop_sizes.can_do_strided_assign)
+        {
+            run(e1, e2, loop_sizes);
+        }
+        else
+        {
+            // trigger the fallback assigner
+            stepper_assigner<E1, E2, default_assignable_layout(E1::static_layout)>(e1, e2).run();
+        }
+    }
+
+    template <>
+    template <class E1, class E2>
+    inline void strided_loop_assigner<false>::run(E1& /*e1*/, const E2& /*e2*/, const loop_sizes_t&)
+    {
+    }
+
+    template <>
+    template <class E1, class E2>
+    inline void strided_loop_assigner<false>::run(E1& e1, const E2& e2)
+    {
+        // trigger the fallback assigner
+        stepper_assigner<E1, E2, default_assignable_layout(E1::static_layout)>(e1, e2).run();
+    }
+}
+
+#endif
diff --git a/include/xtensor/core/xeval.hpp b/include/xtensor/core/xeval.hpp
new file mode 100644
index 000000000..d0ba070e9
--- /dev/null
+++ b/include/xtensor/core/xeval.hpp
@@ -0,0 +1,177 @@
+/***************************************************************************
+ * 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_EVAL_HPP
+#define XTENSOR_EVAL_HPP
+
+#include "../core/xexpression_traits.hpp"
+#include "../core/xshape.hpp"
+#include "../core/xtensor_forward.hpp"
+
+namespace xt
+{
+
+    /**
+     * @defgroup xt_xeval Evaluation
+     *
+     * Evaluation functions.
+     * Defined in ``xtensor/xeval.hpp``
+     */
+
+    namespace detail
+    {
+        template <class T>
+        using is_container = std::is_base_of<xcontainer<std::remove_const_t<T>>, T>;
+    }
+
+    /**
+     * Force evaluation of xexpression.
+     *
+     * @code{.cpp}
+     * xt::xarray<double> a = {1, 2, 3, 4};
+     * auto&& b = xt::eval(a); // b is a reference to a, no copy!
+     * auto&& c = xt::eval(a + b); // c is xarray<double>, not an xexpression
+     * @endcode
+     *
+     * @ingroup xt_xeval
+     * @return xt::xarray or xt::xtensor depending on shape type
+     */
+    template <class T>
+    inline auto eval(T&& t) -> std::enable_if_t<detail::is_container<std::decay_t<T>>::value, T&&>
+    {
+        return std::forward<T>(t);
+    }
+
+    /// @cond DOXYGEN_INCLUDE_SFINAE
+    template <class T>
+    inline auto eval(T&& t)
+        -> std::enable_if_t<!detail::is_container<std::decay_t<T>>::value, temporary_type_t<T>>
+    {
+        return std::forward<T>(t);
+    }
+
+    /// @endcond
+
+    namespace detail
+    {
+        /**********************************
+         * has_same_layout implementation *
+         **********************************/
+
+        template <layout_type L = layout_type::any, class E>
+        constexpr bool has_same_layout()
+        {
+            return (std::decay_t<E>::static_layout == L) || (L == layout_type::any);
+        }
+
+        template <layout_type L = layout_type::any, class E>
+        constexpr bool has_same_layout(E&&)
+        {
+            return has_same_layout<L, E>();
+        }
+
+        template <class E1, class E2>
+        constexpr bool has_same_layout(E1&&, E2&&)
+        {
+            return has_same_layout<std::decay_t<E1>::static_layout, E2>();
+        }
+
+        /*********************************
+         * has_fixed_dims implementation *
+         *********************************/
+
+        template <class E>
+        constexpr bool has_fixed_dims()
+        {
+            return detail::is_array<typename std::decay_t<E>::shape_type>::value;
+        }
+
+        template <class E>
+        constexpr bool has_fixed_dims(E&&)
+        {
+            return has_fixed_dims<E>();
+        }
+
+        /****************************************
+         * as_xarray_container_t implementation *
+         ****************************************/
+
+        template <class E, layout_type L>
+        using as_xarray_container_t = xarray<typename std::decay_t<E>::value_type, layout_remove_any(L)>;
+
+        /*****************************************
+         * as_xtensor_container_t implementation *
+         *****************************************/
+
+        template <class E, layout_type L>
+        using as_xtensor_container_t = xtensor<
+            typename std::decay_t<E>::value_type,
+            std::tuple_size<typename std::decay_t<E>::shape_type>::value,
+            layout_remove_any(L)>;
+    }
+
+    /**
+     * Force evaluation of xexpression not providing a data interface
+     * and convert to the required layout.
+     *
+     * @code{.cpp}
+     * xt::xarray<double, xt::layout_type::row_major> a = {1, 2, 3, 4};
+     *
+     * // take reference to a (no copy!)
+     * auto&& b = xt::as_strided(a);
+     *
+     * // xarray<double> with the required layout
+     * auto&& c = xt::as_strided<xt::layout_type::column_major>(a);
+     *
+     * // xexpression
+     * auto&& a_cast = xt::cast<int>(a);
+     *
+     * // xarray<int>, not an xexpression
+     * auto&& d = xt::as_strided(a_cast);
+     *
+     * // xarray<int> with the required layout
+     * auto&& e = xt::as_strided<xt::layout_type::column_major>(a_cast);
+     * @endcode
+     *
+     * @warning This function should be used in a local context only.
+     *          Returning the value returned by this function could lead to a dangling reference.
+     * @ingroup xt_xeval
+     * @return The expression when it already provides a data interface with the correct layout,
+     *         an evaluated xt::xarray or xt::xtensor depending on shape type otherwise.
+     */
+    template <layout_type L = layout_type::any, class E>
+    inline auto as_strided(E&& e)
+        -> std::enable_if_t<data_interface_expression<std::decay_t<E>> && detail::has_same_layout<L, E>(), E&&>
+    {
+        return std::forward<E>(e);
+    }
+
+    /// @cond DOXYGEN_INCLUDE_SFINAE
+    template <layout_type L = layout_type::any, class E>
+    inline auto as_strided(E&& e) -> std::enable_if_t<
+        (!(data_interface_expression<std::decay_t<E>> && detail::has_same_layout<L, E>()))
+            && detail::has_fixed_dims<E>(),
+        detail::as_xtensor_container_t<E, L>>
+    {
+        return e;
+    }
+
+    template <layout_type L = layout_type::any, class E>
+    inline auto as_strided(E&& e) -> std::enable_if_t<
+        (!(data_interface_expression<std::decay_t<E>> && detail::has_same_layout<L, E>()))
+            && (!detail::has_fixed_dims<E>()),
+        detail::as_xarray_container_t<E, L>>
+    {
+        return e;
+    }
+
+    /// @endcond
+}
+
+#endif
diff --git a/include/xtensor/core/xexpression.hpp b/include/xtensor/core/xexpression.hpp
new file mode 100644
index 000000000..49a662f17
--- /dev/null
+++ b/include/xtensor/core/xexpression.hpp
@@ -0,0 +1,823 @@
+/***************************************************************************
+ * 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_EXPRESSION_HPP
+#define XTENSOR_EXPRESSION_HPP
+
+#include <iterator>
+#include <type_traits>
+
+#include <xtl/xclosure.hpp>
+#include <xtl/xmeta_utils.hpp>
+#include <xtl/xtype_traits.hpp>
+
+#include "../core/xiterator.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xshape.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../utils/xutils.hpp"
+
+namespace xt
+{
+
+    /***************************
+     * xexpression declaration *
+     ***************************/
+
+    /**
+     * @class xexpression
+     * @brief 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.
+     *
+     * @tparam E The derived type.
+     *
+     */
+    template <class D>
+    class xexpression
+    {
+    public:
+
+        using derived_type = D;
+
+        derived_type& derived_cast() & noexcept;
+        const derived_type& derived_cast() const& noexcept;
+        derived_type derived_cast() && noexcept;
+
+    protected:
+
+        xexpression() = default;
+        ~xexpression() = default;
+
+        xexpression(const xexpression&) = default;
+        xexpression& operator=(const xexpression&) = default;
+
+        xexpression(xexpression&&) = default;
+        xexpression& operator=(xexpression&&) = default;
+    };
+
+    /************************************
+     * xsharable_expression declaration *
+     ************************************/
+
+    template <class E>
+    class xshared_expression;
+
+    template <class E>
+    class xsharable_expression;
+
+    namespace detail
+    {
+        template <class E>
+        xshared_expression<E> make_xshared_impl(xsharable_expression<E>&&);
+    }
+
+    template <class D>
+    class xsharable_expression : public xexpression<D>
+    {
+    protected:
+
+        xsharable_expression();
+        ~xsharable_expression() = default;
+
+        xsharable_expression(const xsharable_expression&) = default;
+        xsharable_expression& operator=(const xsharable_expression&) = default;
+
+        xsharable_expression(xsharable_expression&&) = default;
+        xsharable_expression& operator=(xsharable_expression&&) = default;
+
+    private:
+
+        std::shared_ptr<D> p_shared;
+
+        friend xshared_expression<D> detail::make_xshared_impl<D>(xsharable_expression<D>&&);
+    };
+
+    /******************************
+     * xexpression implementation *
+     ******************************/
+
+    /**
+     * @name Downcast functions
+     */
+    //@{
+    /**
+     * Returns a reference to the actual derived type of the xexpression.
+     */
+    template <class D>
+    inline auto xexpression<D>::derived_cast() & noexcept -> derived_type&
+    {
+        return *static_cast<derived_type*>(this);
+    }
+
+    /**
+     * Returns a constant reference to the actual derived type of the xexpression.
+     */
+    template <class D>
+    inline auto xexpression<D>::derived_cast() const& noexcept -> const derived_type&
+    {
+        return *static_cast<const derived_type*>(this);
+    }
+
+    /**
+     * Returns a constant reference to the actual derived type of the xexpression.
+     */
+    template <class D>
+    inline auto xexpression<D>::derived_cast() && noexcept -> derived_type
+    {
+        return *static_cast<derived_type*>(this);
+    }
+
+    //@}
+
+    /***************************************
+     * xsharable_expression implementation *
+     ***************************************/
+
+    template <class D>
+    inline xsharable_expression<D>::xsharable_expression()
+        : p_shared(nullptr)
+    {
+    }
+
+    /**
+     * is_crtp_base_of<B, E>
+     * Resembles std::is_base_of, but adresses the problem of whether _some_ instantiation
+     * of a CRTP templated class B is a base of class E. A CRTP templated class is correctly
+     * templated with the most derived type in the CRTP hierarchy. Using this assumption,
+     * this implementation deals with either CRTP final classes (checks for inheritance
+     * with E as the CRTP parameter of B) or CRTP base classes (which are singly templated
+     * by the most derived class, and that's pulled out to use as a templete parameter for B).
+     */
+
+    namespace detail
+    {
+        template <template <class> class B, class E>
+        struct is_crtp_base_of_impl : std::is_base_of<B<E>, E>
+        {
+        };
+
+        template <template <class> class B, class E, template <class> class F>
+        struct is_crtp_base_of_impl<B, F<E>>
+            : std::disjunction<std::is_base_of<B<E>, F<E>>, std::is_base_of<B<F<E>>, F<E>>>
+        {
+        };
+    }
+
+    template <template <class> class B, class E>
+    using is_crtp_base_of = detail::is_crtp_base_of_impl<B, std::decay_t<E>>;
+
+    template <class E>
+    using is_xexpression = is_crtp_base_of<xexpression, E>;
+
+    template <class E>
+    concept xexpression_concept = is_xexpression<E>::value;
+
+    template <class E, class R = void>
+    using enable_xexpression = typename std::enable_if<is_xexpression<E>::value, R>::type;
+
+    template <class E, class R = void>
+    using disable_xexpression = typename std::enable_if<!is_xexpression<E>::value, R>::type;
+
+    template <class... E>
+    using has_xexpression = std::disjunction<is_xexpression<E>...>;
+
+    template <class E>
+    using is_xsharable_expression = is_crtp_base_of<xsharable_expression, E>;
+
+    template <class E, class R = void>
+    using enable_xsharable_expression = typename std::enable_if<is_xsharable_expression<E>::value, R>::type;
+
+    template <class E, class R = void>
+    using disable_xsharable_expression = typename std::enable_if<!is_xsharable_expression<E>::value, R>::type;
+
+    template <class LHS, class RHS>
+    struct can_assign : std::is_assignable<LHS, RHS>
+    {
+    };
+
+    template <class LHS, class RHS, class R = void>
+    using enable_assignable_expression = typename std::enable_if<can_assign<LHS, RHS>::value, R>::type;
+
+    template <class LHS, class RHS, class R = void>
+    using enable_not_assignable_expression = typename std::enable_if<!can_assign<LHS, RHS>::value, R>::type;
+
+    /***********************
+     * evaluation_strategy *
+     ***********************/
+
+    namespace detail
+    {
+        struct option_base
+        {
+        };
+    }
+
+    namespace evaluation_strategy
+    {
+
+        struct immediate_type : xt::detail::option_base
+        {
+        };
+
+        constexpr auto immediate = std::tuple<immediate_type>{};
+
+        struct lazy_type : xt::detail::option_base
+        {
+        };
+
+        constexpr auto lazy = std::tuple<lazy_type>{};
+
+        /*
+        struct cached {};
+        */
+    }
+
+    template <class T>
+    struct is_evaluation_strategy : std::is_base_of<detail::option_base, std::decay_t<T>>
+    {
+    };
+
+    /************
+     * xclosure *
+     ************/
+
+    template <class T>
+    class xscalar;
+
+    template <class E, class EN = void>
+    struct xclosure
+    {
+        using type = xtl::closure_type_t<E>;
+    };
+
+    template <class E>
+    struct xclosure<xshared_expression<E>, std::enable_if_t<true>>
+    {
+        using type = xshared_expression<E>;  // force copy
+    };
+
+    template <class E>
+    struct xclosure<E, disable_xexpression<std::decay_t<E>>>
+    {
+        using type = xscalar<xtl::closure_type_t<E>>;
+    };
+
+    template <class E>
+    using xclosure_t = typename xclosure<E>::type;
+
+    template <class E, class EN = void>
+    struct const_xclosure
+    {
+        using type = xtl::const_closure_type_t<E>;
+    };
+
+    template <class E>
+    struct const_xclosure<E, disable_xexpression<std::decay_t<E>>>
+    {
+        using type = xscalar<xtl::const_closure_type_t<E>>;
+    };
+
+    template <class E>
+    struct const_xclosure<xshared_expression<E>&, std::enable_if_t<true>>
+    {
+        using type = xshared_expression<E>;  // force copy
+    };
+
+    template <class E>
+    using const_xclosure_t = typename const_xclosure<E>::type;
+
+    /*************************
+     * expression tag system *
+     *************************/
+
+    struct xtensor_expression_tag
+    {
+    };
+
+    struct xoptional_expression_tag
+    {
+    };
+
+    namespace extension
+    {
+        template <class E, class = void_t<int>>
+        struct get_expression_tag_impl
+        {
+            using type = xtensor_expression_tag;
+        };
+
+        template <class E>
+        struct get_expression_tag_impl<E, void_t<typename std::decay_t<E>::expression_tag>>
+        {
+            using type = typename std::decay_t<E>::expression_tag;
+        };
+
+        template <class E>
+        struct get_expression_tag : get_expression_tag_impl<E>
+        {
+        };
+
+        template <class E>
+        using get_expression_tag_t = typename get_expression_tag<E>::type;
+
+        template <class... T>
+        struct expression_tag_and;
+
+        template <>
+        struct expression_tag_and<>
+        {
+            using type = xtensor_expression_tag;
+        };
+
+        template <class T>
+        struct expression_tag_and<T>
+        {
+            using type = T;
+        };
+
+        template <class T>
+        struct expression_tag_and<T, T>
+        {
+            using type = T;
+        };
+
+        template <class T>
+        struct expression_tag_and<xtensor_expression_tag, T>
+        {
+            using type = T;
+        };
+
+        template <class T>
+        struct expression_tag_and<T, xtensor_expression_tag> : expression_tag_and<xtensor_expression_tag, T>
+        {
+        };
+
+        template <>
+        struct expression_tag_and<xtensor_expression_tag, xtensor_expression_tag>
+        {
+            using type = xtensor_expression_tag;
+        };
+
+        template <class T1, class... T>
+        struct expression_tag_and<T1, T...> : expression_tag_and<T1, typename expression_tag_and<T...>::type>
+        {
+        };
+
+        template <class... T>
+        using expression_tag_and_t = typename expression_tag_and<T...>::type;
+
+        struct xtensor_empty_base
+        {
+            using expression_tag = xtensor_expression_tag;
+        };
+    }
+
+    template <class... T>
+    struct xexpression_tag
+    {
+        using type = extension::expression_tag_and_t<
+            extension::get_expression_tag_t<std::decay_t<const_xclosure_t<T>>>...>;
+    };
+
+    template <class... T>
+    using xexpression_tag_t = typename xexpression_tag<T...>::type;
+
+    template <class E>
+    struct is_xtensor_expression : std::is_same<xexpression_tag_t<E>, xtensor_expression_tag>
+    {
+    };
+
+    template <class E>
+    struct is_xoptional_expression : std::is_same<xexpression_tag_t<E>, xoptional_expression_tag>
+    {
+    };
+
+    /********************************
+     * xoptional_comparable concept *
+     ********************************/
+
+    template <class... E>
+    struct xoptional_comparable
+        : std::conjunction<std::disjunction<is_xtensor_expression<E>, is_xoptional_expression<E>>...>
+    {
+    };
+
+#define XTENSOR_FORWARD_CONST_METHOD(name)                                   \
+    auto name() const -> decltype(std::declval<xtl::constify_t<E>>().name()) \
+    {                                                                        \
+        return m_ptr->name();                                                \
+    }
+
+#define XTENSOR_FORWARD_METHOD(name)                  \
+    auto name() -> decltype(std::declval<E>().name()) \
+    {                                                 \
+        return m_ptr->name();                         \
+    }
+
+#define XTENSOR_FORWARD_CONST_ITERATOR_METHOD(name)                                               \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>                                          \
+    auto name() const noexcept -> decltype(std::declval<xtl::constify_t<E>>().template name<L>()) \
+    {                                                                                             \
+        return m_ptr->template name<L>();                                                         \
+    }                                                                                             \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>                                 \
+    auto name(const S& shape) const noexcept                                                      \
+        -> decltype(std::declval<xtl::constify_t<E>>().template name<L>(shape))                   \
+    {                                                                                             \
+        return m_ptr->template name<L>();                                                         \
+    }
+
+#define XTENSOR_FORWARD_ITERATOR_METHOD(name)                                                 \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>                             \
+    auto name(const S& shape) noexcept -> decltype(std::declval<E>().template name<L>(shape)) \
+    {                                                                                         \
+        return m_ptr->template name<L>();                                                     \
+    }                                                                                         \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>                                      \
+    auto name() noexcept -> decltype(std::declval<E>().template name<L>())                    \
+    {                                                                                         \
+        return m_ptr->template name<L>();                                                     \
+    }
+
+    namespace detail
+    {
+        template <class E>
+        struct expr_strides_type
+        {
+            using type = typename E::strides_type;
+        };
+
+        template <class E>
+        struct expr_inner_strides_type
+        {
+            using type = typename E::inner_strides_type;
+        };
+
+        template <class E>
+        struct expr_backstrides_type
+        {
+            using type = typename E::backstrides_type;
+        };
+
+        template <class E>
+        struct expr_inner_backstrides_type
+        {
+            using type = typename E::inner_backstrides_type;
+        };
+
+        template <class E>
+        struct expr_storage_type
+        {
+            using type = typename E::storage_type;
+        };
+    }
+
+    /**
+     * @class xshared_expression
+     * @brief 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:
+     *
+     * @code{.cpp}
+     * 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.
+     * }
+     * @endcode
+     */
+    template <class E>
+    class xshared_expression : public xexpression<xshared_expression<E>>
+    {
+    public:
+
+        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 = typename std::
+            conditional_t<strided_expression<E>, detail::expr_strides_type<E>, get_strides_type<shape_type>>::type;
+        using backstrides_type = typename std::
+            conditional_t<strided_expression<E>, detail::expr_backstrides_type<E>, get_strides_type<shape_type>>::type;
+        using inner_strides_type = typename std::
+            conditional_t<strided_expression<E>, detail::expr_inner_strides_type<E>, get_strides_type<shape_type>>::type;
+        using inner_backstrides_type = typename std::conditional_t<
+            strided_expression<E>,
+            detail::expr_inner_backstrides_type<E>,
+            get_strides_type<shape_type>>::type;
+        using storage_type = typename std::
+            conditional_t<container_expression<E>, detail::expr_storage_type<E>, make_invalid_type<>>::type;
+
+        using stepper = typename E::stepper;
+        using const_stepper = typename E::const_stepper;
+
+        using linear_iterator = decltype(xt::linear_begin(std::declval<E&>()));
+        using const_linear_iterator = decltype(xt::linear_begin(std::declval<const E&>()));
+        using reverse_linear_iterator = std::reverse_iterator<linear_iterator>;
+        using const_reverse_linear_iterator = std::reverse_iterator<const_linear_iterator>;
+
+        using bool_load_type = typename E::bool_load_type;
+
+        static constexpr layout_type static_layout = E::static_layout;
+        static constexpr bool contiguous_layout = static_layout != layout_type::dynamic;
+
+        explicit xshared_expression(const std::shared_ptr<E>& ptr);
+        long use_count() const noexcept;
+
+        template <class... Args>
+        auto operator()(Args... args) -> decltype(std::declval<E>()(args...))
+        {
+            return m_ptr->operator()(args...);
+        }
+
+        XTENSOR_FORWARD_CONST_METHOD(shape)
+        XTENSOR_FORWARD_CONST_METHOD(dimension)
+        XTENSOR_FORWARD_CONST_METHOD(size)
+        XTENSOR_FORWARD_CONST_METHOD(layout)
+        XTENSOR_FORWARD_CONST_METHOD(is_contiguous)
+
+        XTENSOR_FORWARD_ITERATOR_METHOD(begin)
+        XTENSOR_FORWARD_ITERATOR_METHOD(end)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(begin)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(end)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(cbegin)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(cend)
+
+        XTENSOR_FORWARD_ITERATOR_METHOD(rbegin)
+        XTENSOR_FORWARD_ITERATOR_METHOD(rend)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(rbegin)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(rend)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(crbegin)
+        XTENSOR_FORWARD_CONST_ITERATOR_METHOD(crend)
+
+        linear_iterator linear_begin() noexcept
+        {
+            return xt::linear_begin(*m_ptr);
+        }
+
+        linear_iterator linear_end() noexcept
+        {
+            return xt::linear_end(*m_ptr);
+        }
+
+        const_linear_iterator linear_begin() const noexcept
+        {
+            return xt::linear_begin(*m_ptr);
+        }
+
+        const_linear_iterator linear_end() const noexcept
+        {
+            return xt::linear_end(*m_ptr);
+        }
+
+        const_linear_iterator linear_cbegin() const noexcept
+        {
+            return xt::linear_begin(*m_ptr);
+        }
+
+        const_linear_iterator linear_cend() const noexcept
+        {
+            return xt::linear_end(*m_ptr);
+        }
+
+        reverse_linear_iterator linear_rbegin() noexcept
+        {
+            return reverse_linear_iterator(linear_end());
+        }
+
+        reverse_linear_iterator linear_rend() noexcept
+        {
+            return reverse_linear_iterator(linear_begin());
+        }
+
+        const_reverse_linear_iterator linear_rbegin() const noexcept
+        {
+            return const_reverse_linear_iterator(linear_end());
+        }
+
+        const_reverse_linear_iterator linear_rend() const noexcept
+        {
+            return const_reverse_linear_iterator(linear_begin());
+        }
+
+        const_reverse_linear_iterator linear_crbegin() const noexcept
+        {
+            return const_reverse_linear_iterator(linear_cend());
+        }
+
+        const_reverse_linear_iterator linear_crend() const noexcept
+        {
+            return const_reverse_linear_iterator(linear_cbegin());
+        }
+
+        template <class T = E>
+        std::enable_if_t<strided_expression<T>, const inner_strides_type&> strides() const
+        {
+            return m_ptr->strides();
+        }
+
+        template <class T = E>
+        std::enable_if_t<strided_expression<T>, const inner_strides_type&> backstrides() const
+        {
+            return m_ptr->backstrides();
+        }
+
+        template <class T = E>
+        std::enable_if_t<data_interface_expression<T>, pointer> data() noexcept
+        {
+            return m_ptr->data();
+        }
+
+        template <class T = E>
+        std::enable_if_t<data_interface_expression<T>, pointer> data() const noexcept
+        {
+            return m_ptr->data();
+        }
+
+        template <class T = E>
+        std::enable_if_t<data_interface_expression<T>, size_type> data_offset() const noexcept
+        {
+            return m_ptr->data_offset();
+        }
+
+        template <class T = E>
+        std::enable_if_t<data_interface_expression<T>, typename T::storage_type&> storage() noexcept
+        {
+            return m_ptr->storage();
+        }
+
+        template <class T = E>
+        std::enable_if_t<data_interface_expression<T>, const typename T::storage_type&> storage() const noexcept
+        {
+            return m_ptr->storage();
+        }
+
+        template <class It>
+        reference element(It first, It last)
+        {
+            return m_ptr->element(first, last);
+        }
+
+        template <class It>
+        const_reference element(It first, It last) const
+        {
+            return m_ptr->element(first, last);
+        }
+
+        template <class S>
+        bool broadcast_shape(S& shape, bool reuse_cache = false) const
+        {
+            return m_ptr->broadcast_shape(shape, reuse_cache);
+        }
+
+        template <class S>
+        bool has_linear_assign(const S& strides) const noexcept
+        {
+            return m_ptr->has_linear_assign(strides);
+        }
+
+        template <class S>
+        auto stepper_begin(const S& shape) noexcept -> decltype(std::declval<E>().stepper_begin(shape))
+        {
+            return m_ptr->stepper_begin(shape);
+        }
+
+        template <class S>
+        auto stepper_end(const S& shape, layout_type l) noexcept
+            -> decltype(std::declval<E>().stepper_end(shape, l))
+        {
+            return m_ptr->stepper_end(shape, l);
+        }
+
+        template <class S>
+        auto stepper_begin(const S& shape) const noexcept
+            -> decltype(std::declval<const E>().stepper_begin(shape))
+        {
+            return static_cast<const E*>(m_ptr.get())->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))
+        {
+            return static_cast<const E*>(m_ptr.get())->stepper_end(shape, l);
+        }
+
+    private:
+
+        std::shared_ptr<E> m_ptr;
+    };
+
+    /**
+     * Constructor for xshared expression (note: usually the free function
+     * `make_xshared` is recommended).
+     *
+     * @param ptr shared ptr that contains the expression
+     * @sa make_xshared
+     */
+    template <class E>
+    inline xshared_expression<E>::xshared_expression(const std::shared_ptr<E>& ptr)
+        : m_ptr(ptr)
+    {
+    }
+
+    /**
+     * Return the number of times this expression is referenced.
+     * Internally calls the use_count() function of the std::shared_ptr.
+     */
+    template <class E>
+    inline long xshared_expression<E>::use_count() const noexcept
+    {
+        return m_ptr.use_count();
+    }
+
+    namespace detail
+    {
+        template <class E>
+        inline xshared_expression<E> make_xshared_impl(xsharable_expression<E>&& expr)
+        {
+            if (expr.p_shared == nullptr)
+            {
+                expr.p_shared = std::make_shared<E>(std::move(expr).derived_cast());
+            }
+            return xshared_expression<E>(expr.p_shared);
+        }
+    }
+
+    /**
+     * Helper function to create shared expression from any xexpression
+     *
+     * @param expr rvalue expression that will be shared
+     * @return xshared expression
+     */
+    template <class E>
+    inline xshared_expression<E> make_xshared(xexpression<E>&& expr)
+    {
+        static_assert(
+            is_xsharable_expression<E>::value,
+            "make_shared requires E to inherit from xsharable_expression"
+        );
+        return detail::make_xshared_impl(std::move(expr.derived_cast()));
+    }
+
+    /**
+     * Helper function to create shared expression from any xexpression
+     *
+     * @param expr rvalue expression that will be shared
+     * @return xshared expression
+     * @sa make_xshared
+     */
+    template <class E>
+    inline auto share(xexpression<E>& expr)
+    {
+        return make_xshared(std::move(expr));
+    }
+
+    /**
+     * Helper function to create shared expression from any xexpression
+     *
+     * @param expr rvalue expression that will be shared
+     * @return xshared expression
+     * @sa make_xshared
+     */
+    template <class E>
+    inline auto share(xexpression<E>&& expr)
+    {
+        return make_xshared(std::move(expr));
+    }
+
+#undef XTENSOR_FORWARD_METHOD
+
+}
+
+#endif
diff --git a/include/xtensor/core/xexpression_traits.hpp b/include/xtensor/core/xexpression_traits.hpp
new file mode 100644
index 000000000..5ec0f86fe
--- /dev/null
+++ b/include/xtensor/core/xexpression_traits.hpp
@@ -0,0 +1,197 @@
+/***************************************************************************
+ * 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_EXPRESSION_TRAITS_HPP
+#define XTENSOR_EXPRESSION_TRAITS_HPP
+
+#include "../core/xexpression.hpp"
+
+namespace xt
+{
+    /***************
+     * xvalue_type *
+     ***************/
+
+    namespace detail
+    {
+        template <class E, class enable = void>
+        struct xvalue_type_impl
+        {
+            using type = E;
+        };
+
+        template <class E>
+        struct xvalue_type_impl<E, std::enable_if_t<is_xexpression<E>::value>>
+        {
+            using type = typename E::value_type;
+        };
+    }
+
+    template <class E>
+    using xvalue_type = detail::xvalue_type_impl<E>;
+
+    template <class E>
+    using xvalue_type_t = typename xvalue_type<E>::type;
+
+    /*********************
+     * common_value_type *
+     *********************/
+
+    template <class... C>
+    struct common_value_type
+    {
+        using type = std::common_type_t<typename std::decay_t<C>::value_type...>;
+    };
+
+    template <class... C>
+    using common_value_type_t = typename common_value_type<C...>::type;
+
+    /********************
+     * common_size_type *
+     ********************/
+
+    template <class... Args>
+    struct common_size_type
+    {
+        using type = std::common_type_t<typename Args::size_type...>;
+    };
+
+    template <>
+    struct common_size_type<>
+    {
+        using type = std::size_t;
+    };
+
+    template <class... Args>
+    using common_size_type_t = typename common_size_type<Args...>::type;
+
+    /**************************
+     * common_difference type *
+     **************************/
+
+    template <class... Args>
+    struct common_difference_type
+    {
+        using type = std::common_type_t<typename Args::difference_type...>;
+    };
+
+    template <>
+    struct common_difference_type<>
+    {
+        using type = std::ptrdiff_t;
+    };
+
+    template <class... Args>
+    using common_difference_type_t = typename common_difference_type<Args...>::type;
+
+    /******************
+     * temporary_type *
+     ******************/
+
+    namespace detail
+    {
+        template <class S>
+        struct xtype_for_shape
+        {
+            template <class T, layout_type L>
+            using type = xarray<T, L>;
+        };
+
+// Workaround for rebind_container problems when C++17 feature is enabled
+#ifdef __cpp_template_template_args
+        template <template <class, std::size_t, class, bool> class S, class X, std::size_t N, class A, bool Init>
+        struct xtype_for_shape<S<X, N, A, Init>>
+        {
+            template <class T, layout_type L>
+            using type = xarray<T, L>;
+        };
+#endif  // __cpp_template_template_args
+
+        template <template <class, std::size_t> class S, class X, std::size_t N>
+        struct xtype_for_shape<S<X, N>>
+        {
+            template <class T, layout_type L>
+            using type = xtensor<T, N, L>;
+        };
+
+        template <template <std::size_t...> class S, std::size_t... X>
+        struct xtype_for_shape<S<X...>>
+        {
+            template <class T, layout_type L>
+            using type = xtensor_fixed<T, xshape<X...>, L>;
+        };
+    }
+
+    template <class Tag, class T>
+    struct temporary_type_from_tag;
+
+    template <class T>
+    struct temporary_type_from_tag<xtensor_expression_tag, T>
+    {
+        using I = std::decay_t<T>;
+        using shape_type = typename I::shape_type;
+        using value_type = typename I::value_type;
+        static constexpr layout_type static_layout = XTENSOR_DEFAULT_LAYOUT;
+        using type = typename detail::xtype_for_shape<shape_type>::template type<value_type, static_layout>;
+    };
+
+    template <class T, class = void>
+    struct temporary_type
+    {
+        using type = typename temporary_type_from_tag<xexpression_tag_t<T>, T>::type;
+    };
+
+    template <class T>
+    struct temporary_type<T, void_t<typename std::decay_t<T>::temporary_type>>
+    {
+        using type = typename std::decay_t<T>::temporary_type;
+    };
+
+    template <class T>
+    using temporary_type_t = typename temporary_type<T>::type;
+
+    /**********************
+     * common_tensor_type *
+     **********************/
+
+    namespace detail
+    {
+        template <class... C>
+        struct common_tensor_type_impl
+        {
+            static constexpr layout_type static_layout = compute_layout(std::decay_t<C>::static_layout...);
+            using value_type = common_value_type_t<C...>;
+            using shape_type = promote_shape_t<typename C::shape_type...>;
+            using type = typename xtype_for_shape<shape_type>::template type<value_type, static_layout>;
+        };
+    }
+
+    template <class... C>
+    struct common_tensor_type : detail::common_tensor_type_impl<std::decay_t<C>...>
+    {
+    };
+
+    template <class... C>
+    using common_tensor_type_t = typename common_tensor_type<C...>::type;
+
+    /**************************
+     * big_promote_value_type *
+     **************************/
+
+    template <class E>
+    struct big_promote_value_type
+    {
+        using type = xtl::big_promote_type_t<typename std::decay_t<E>::value_type>;
+    };
+
+    template <class E>
+    using big_promote_value_type_t = typename big_promote_value_type<E>::type;
+}
+
+#endif
diff --git a/include/xtensor/xfunction.hpp b/include/xtensor/core/xfunction.hpp
similarity index 51%
rename from include/xtensor/xfunction.hpp
rename to include/xtensor/core/xfunction.hpp
index 9ec4d99fb..99144b377 100644
--- a/include/xtensor/xfunction.hpp
+++ b/include/xtensor/core/xfunction.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FUNCTION_HPP
 #define XTENSOR_FUNCTION_HPP
@@ -12,7 +13,6 @@
 #include <algorithm>
 #include <cstddef>
 #include <iterator>
-#include <numeric>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -20,82 +20,45 @@
 #include <xtl/xsequence.hpp>
 #include <xtl/xtype_traits.hpp>
 
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xlayout.hpp"
-#include "xscalar.hpp"
-#include "xshape.hpp"
-#include "xstrides.hpp"
-#include "xtensor_simd.hpp"
-#include "xutils.hpp"
+#include "../containers/xscalar.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xexpression_traits.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xiterator.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xshape.hpp"
+#include "../core/xstrides.hpp"
+#include "../utils/xtensor_simd.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
-    template <class F, class... CT>
-    struct has_simd_interface<xfunction<F, CT...>>
-        : xfunction<F, CT...>::has_simd_interface
-    {
-    };
-
     namespace detail
     {
 
-        /********************
-         * common_size_type *
-         ********************/
-
-        template <class... Args>
-        struct common_size_type
-        {
-            using type = std::common_type_t<typename Args::size_type...>;
-        };
-
-        template <>
-        struct common_size_type<>
-        {
-            using type = std::size_t;
-        };
-
-        template <class... Args>
-        using common_size_type_t = typename common_size_type<Args...>::type;
-
         template <bool... B>
-        using conjunction_c = xtl::conjunction<std::integral_constant<bool, B>...>;
-
-        /**************************
-         * common_difference type *
-         **************************/
-
-        template <class... Args>
-        struct common_difference_type
-        {
-            using type = std::common_type_t<typename Args::difference_type...>;
-        };
-
-        template <>
-        struct common_difference_type<>
-        {
-            using type = std::ptrdiff_t;
-        };
-
-        template <class... Args>
-        using common_difference_type_t = typename common_difference_type<Args...>::type;
+        using conjunction_c = std::conjunction<std::integral_constant<bool, B>...>;
 
         /************************
          * xfunction_cache_impl *
          ************************/
 
-        template<class S, class is_shape_trivial>
+        template <class S, class is_shape_trivial>
         struct xfunction_cache_impl
         {
             S shape;
             bool is_trivial;
             bool is_initialized;
 
-            xfunction_cache_impl() : shape(xtl::make_sequence<S>(0, std::size_t(0))), is_initialized(false) {}
+            xfunction_cache_impl()
+                : shape(xtl::make_sequence<S>(0, std::size_t(0)))
+                , is_trivial(false)
+                , is_initialized(false)
+            {
+            }
         };
 
-        template<std::size_t... N, class is_shape_trivial>
+        template <std::size_t... N, class is_shape_trivial>
         struct xfunction_cache_impl<fixed_shape<N...>, is_shape_trivial>
         {
             XTENSOR_CONSTEXPR_ENHANCED_STATIC fixed_shape<N...> shape = fixed_shape<N...>();
@@ -103,69 +66,26 @@ namespace xt
             XTENSOR_CONSTEXPR_ENHANCED_STATIC bool is_initialized = true;
         };
 
-        #ifdef XTENSOR_HAS_CONSTEXPR_ENHANCED
-            // Out of line definitions to prevent linker errors prior to C++17
-            template <std::size_t... N, class is_shape_trivial>
-            constexpr fixed_shape<N...> xfunction_cache_impl<fixed_shape<N...>, is_shape_trivial>::shape;
-
-            template <std::size_t... N, class is_shape_trivial>
-            constexpr bool xfunction_cache_impl<fixed_shape<N...>, is_shape_trivial>::is_trivial;
-
-            template <std::size_t... N, class is_shape_trivial>
-            constexpr bool xfunction_cache_impl<fixed_shape<N...>, is_shape_trivial>::is_initialized;
-        #endif
-
-        /**********************
-         * simd metafunctions *
-         **********************/
-
-        template <class F, class B, class = void>
-        struct has_simd_apply : std::false_type {};
-
-        template <class F, class B>
-        struct has_simd_apply<F, B, void_t<decltype(&F::template simd_apply<B>)>>
-            : std::true_type
+        template <class... CT>
+        struct xfunction_bool_load_type
         {
+            using type = xtl::promote_type_t<typename std::decay_t<CT>::bool_load_type...>;
         };
 
-        template <class V>
-        struct has_simd_type
-            : std::integral_constant<bool, !std::is_same<V, xsimd::simd_type<V>>::value>
-        {
-        };
-
-        template <class T>
-        struct meta_identity
+        template <class CT>
+        struct xfunction_bool_load_type<CT>
         {
-            using type = T;
+            using type = typename std::decay_t<CT>::bool_load_type;
         };
 
-        // This meta struct checks wether SIMD should be activated for our 
-        // functor "F"
-        template <class V, class F, class... CT>
-        struct xsimd_meta_getter
-        {
-            using scalar_result_type = V;
-
-            // check if all arguments are supported by SIMD
-            using simd_arguments_exist = xtl::conjunction<has_simd_type<scalar_result_type>,
-                                                          has_simd_type<xvalue_type_t<std::decay_t<CT>>>...>;
-            // if yes, insert correct type here
-            using simd_value_type = xtl::mpl::eval_if_t<simd_arguments_exist,
-                                                        meta_identity<xsimd::simd_type<scalar_result_type>>,
-                                                        make_invalid_type<>>;
-            // if all types are supported, check that the functor has a working 
-            // simd_apply and all arguments have the simd interface
-            using use_xsimd = xtl::conjunction<simd_arguments_exist,
-                                               has_simd_apply<F, scalar_result_type>,
-                                               has_simd_interface<std::decay_t<CT>>...>;
-        };
+        template <class... CT>
+        using xfunction_bool_load_type_t = typename xfunction_bool_load_type<CT...>::type;
     }
 
     /************************
      * xfunction extensions *
      ************************/
-    
+
     namespace extension
     {
 
@@ -179,8 +99,7 @@ namespace xt
         };
 
         template <class F, class... CT>
-        struct xfunction_base
-            : xfunction_base_impl<xexpression_tag_t<CT...>, F, CT...>
+        struct xfunction_base : xfunction_base_impl<xexpression_tag_t<CT...>, F, CT...>
         {
         };
 
@@ -188,8 +107,10 @@ namespace xt
         using xfunction_base_t = typename xfunction_base<F, CT...>::type;
     }
 
-    template<class promote>
-    struct xfunction_cache : detail::xfunction_cache_impl<typename promote::type, promote> {};
+    template <class promote>
+    struct xfunction_cache : detail::xfunction_cache_impl<typename promote::type, promote>
+    {
+    };
 
     template <class F, class... CT>
     class xfunction_iterator;
@@ -208,12 +129,66 @@ namespace xt
         using stepper = const_stepper;
     };
 
+    template <class F, class... CT>
+    struct xcontainer_inner_types<xfunction<F, CT...>>
+    {
+        // Added indirection for MSVC 2017 bug with the operator value_type()
+        using func_return_type = typename std::type_identity<
+            decltype(std::declval<F>()(std::declval<xvalue_type_t<std::decay_t<CT>>>()...))>::type;
+        using value_type = std::decay_t<func_return_type>;
+        using reference = func_return_type;
+        using const_reference = reference;
+        using size_type = common_size_type_t<std::decay_t<CT>...>;
+    };
+
+    template <class T, class F, class... CT>
+    struct has_simd_interface<xfunction<F, CT...>, T> : std::conjunction<
+                                                            has_simd_type<T>,
+                                                            has_simd_apply<F, xt_simd::simd_type<T>>,
+                                                            has_simd_interface<std::decay_t<CT>, T>...>
+    {
+    };
+
+    /*************************************
+     * overlapping_memory_checker_traits *
+     *************************************/
+
+    template <class E>
+    struct overlapping_memory_checker_traits<
+        E,
+        std::enable_if_t<!addressable_to_expression<E> && is_specialization_of<xfunction, E>::value>>
+    {
+        template <std::size_t I = 0, class... T, std::enable_if_t<(I == sizeof...(T)), int> = 0>
+        static bool check_tuple(const std::tuple<T...>&, const memory_range&)
+        {
+            return false;
+        }
+
+        template <std::size_t I = 0, class... T, std::enable_if_t<(I < sizeof...(T)), int> = 0>
+        static bool check_tuple(const std::tuple<T...>& t, const memory_range& dst_range)
+        {
+            using ChildE = std::decay_t<decltype(std::get<I>(t))>;
+            return overlapping_memory_checker_traits<ChildE>::check_overlap(std::get<I>(t), dst_range)
+                   || check_tuple<I + 1>(t, dst_range);
+        }
+
+        static bool check_overlap(const E& expr, const memory_range& dst_range)
+        {
+            if (expr.size() == 0)
+            {
+                return false;
+            }
+            else
+            {
+                return check_tuple(expr.arguments(), dst_range);
+            }
+        }
+    };
+
     /*************
      * xfunction *
      *************/
 
-#define DL XTENSOR_DEFAULT_LAYOUT
-
     /**
      * @class xfunction
      * @brief Multidimensional function operating on
@@ -227,34 +202,36 @@ namespace xt
      */
     template <class F, class... CT>
     class xfunction : private xconst_iterable<xfunction<F, CT...>>,
-                      public xexpression<xfunction<F, CT...>>,
+                      public xsharable_expression<xfunction<F, CT...>>,
+                      private xconst_accessible<xfunction<F, CT...>>,
                       public extension::xfunction_base_t<F, CT...>
     {
     public:
 
         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...>;
 
-        // Added indirection for MSVC 2017 bug with the operator value_type()
-        using value_type = typename detail::meta_identity<decltype(std::declval<F>()(std::declval<xvalue_type_t<std::decay_t<CT>>>()...))>::type;
-        using reference = value_type;
-        using const_reference = value_type;
+        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 = detail::common_size_type_t<std::decay_t<CT>...>;
-        using difference_type = detail::common_difference_type_t<std::decay_t<CT>...>;
-        using simd_meta_getter = detail::xsimd_meta_getter<value_type, F, CT...>;
+        using size_type = typename inner_types::size_type;
+        using difference_type = common_difference_type_t<std::decay_t<CT>...>;
 
-        using has_simd_interface = typename simd_meta_getter::use_xsimd;
-        using simd_value_type = typename simd_meta_getter::simd_value_type;
-        using simd_argument_type = simd_value_type;
+        using simd_value_type = xt_simd::simd_type<value_type>;
+
+        // xtl::promote_type_t<typename std::decay_t<CT>::bool_load_type...>;
+        using bool_load_type = detail::xfunction_bool_load_type_t<CT...>;
 
         template <class requested_type>
-        using simd_return_type = xsimd::simd_return_type<value_type, 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;
@@ -264,7 +241,7 @@ namespace xt
         using const_stepper = typename iterable_base::const_stepper;
 
         static constexpr layout_type static_layout = compute_layout(std::decay_t<CT>::static_layout...);
-        static constexpr bool contiguous_layout = detail::conjunction_c<std::decay_t<CT>::contiguous_layout...>::value;
+        static constexpr bool contiguous_layout = static_layout != layout_type::dynamic;
 
         template <layout_type L>
         using layout_iterator = typename iterable_base::template layout_iterator<L>;
@@ -284,10 +261,10 @@ namespace xt
         template <class S, layout_type L>
         using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>;
 
-        using const_storage_iterator = xfunction_iterator<F, CT...>;
-        using storage_iterator = const_storage_iterator;
-        using const_reverse_storage_iterator = std::reverse_iterator<const_storage_iterator>;
-        using reverse_storage_iterator = std::reverse_iterator<storage_iterator>;
+        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;
@@ -297,6 +274,9 @@ namespace xt
         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;
 
+        template <class FA, class... CTA>
+        xfunction(xfunction<FA, CTA...> xf) noexcept;
+
         ~xfunction() = default;
 
         xfunction(const xfunction&) = default;
@@ -305,25 +285,25 @@ namespace xt
         xfunction(xfunction&&) = default;
         xfunction& operator=(xfunction&&) = default;
 
-        size_type size() const noexcept;
+        using accessible_base::size;
         size_type dimension() const noexcept;
         const inner_shape_type& shape() const;
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+        using accessible_base::shape;
 
         template <class... Args>
         const_reference operator()(Args... args) const;
 
-        template <class... Args>
-        const_reference at(Args... args) const;
-
         template <class... Args>
         const_reference unchecked(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;
+        using accessible_base::at;
+        using accessible_base::operator[];
+        using accessible_base::back;
+        using accessible_base::front;
+        using accessible_base::in_bounds;
+        using accessible_base::periodic;
 
         template <class It>
         const_reference element(It first, It last) const;
@@ -335,23 +315,23 @@ namespace xt
         bool has_linear_assign(const S& strides) const noexcept;
 
         using iterable_base::begin;
-        using iterable_base::end;
         using iterable_base::cbegin;
         using iterable_base::cend;
-        using iterable_base::rbegin;
-        using iterable_base::rend;
         using iterable_base::crbegin;
         using iterable_base::crend;
+        using iterable_base::end;
+        using iterable_base::rbegin;
+        using iterable_base::rend;
 
-        const_storage_iterator storage_begin() const noexcept;
-        const_storage_iterator storage_end() const noexcept;
-        const_storage_iterator storage_cbegin() const noexcept;
-        const_storage_iterator storage_cend() const 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;
 
-        const_reverse_storage_iterator storage_rbegin() const noexcept;
-        const_reverse_storage_iterator storage_rend() const noexcept;
-        const_reverse_storage_iterator storage_crbegin() const noexcept;
-        const_reverse_storage_iterator storage_crend() 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;
 
         template <class S>
         const_stepper stepper_begin(const S& shape) const noexcept;
@@ -360,34 +340,19 @@ namespace xt
 
         const_reference data_element(size_type i) const;
 
+        const_reference flat(size_type i) const;
+
         template <class UT = self_type, class = typename std::enable_if<UT::only_scalar::value>::type>
         operator value_type() const;
 
-        template <class align, class requested_type = value_type,
-                  std::size_t N = xsimd::simd_traits<requested_type>::size>
+        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;
 
         const tuple_type& arguments() const noexcept;
 
-    private:
-
-        template <std::size_t... I>
-        layout_type layout_impl(std::index_sequence<I...>) const noexcept;
-
-        template <std::size_t... I, class... Args>
-        const_reference access_impl(std::index_sequence<I...>, Args... args) const;
-
-        template <std::size_t... I, class... Args>
-        const_reference unchecked_impl(std::index_sequence<I...>, Args... args) const;
+        const functor_type& functor() const noexcept;
 
-        template <std::size_t... I, class It>
-        const_reference element_access_impl(std::index_sequence<I...>, It first, It last) const;
-
-        template <std::size_t... I>
-        const_reference data_element_impl(std::index_sequence<I...>, size_type i) const;
-
-        template <class align, class requested_type, std::size_t N, std::size_t... I>
-        auto load_simd_impl(std::index_sequence<I...>, size_type i) const;
+    private:
 
         template <class Func, std::size_t... I>
         const_stepper build_stepper(Func&& f, std::index_sequence<I...>) const noexcept;
@@ -406,53 +371,20 @@ namespace xt
         friend class xfunction_iterator<F, CT...>;
         friend class xfunction_stepper<F, CT...>;
         friend class xconst_iterable<self_type>;
+        friend class xconst_accessible<self_type>;
     };
 
-#undef DL
-
     /**********************
      * xfunction_iterator *
      **********************/
 
-    template <class CT>
-    class xscalar;
-
-    namespace detail
-    {
-        template <class C>
-        struct get_iterator_impl
-        {
-            using type = typename C::storage_iterator;
-        };
-
-        template <class C>
-        struct get_iterator_impl<const C>
-        {
-            using type = typename C::const_storage_iterator;
-        };
-
-        template <class CT>
-        struct get_iterator_impl<xscalar<CT>>
-        {
-            using type = typename xscalar<CT>::dummy_iterator;
-        };
-
-        template <class CT>
-        struct get_iterator_impl<const xscalar<CT>>
-        {
-            using type = typename xscalar<CT>::const_dummy_iterator;
-        };
-    }
-
-    template <class C>
-    using get_iterator = typename detail::get_iterator_impl<C>::type;
-
     template <class F, class... CT>
-    class xfunction_iterator : public xtl::xrandom_access_iterator_base<xfunction_iterator<F, CT...>,
-                                                                        typename xfunction<F, CT...>::value_type,
-                                                                        typename xfunction<F, CT...>::difference_type,
-                                                                        typename xfunction<F, CT...>::pointer,
-                                                                        typename xfunction<F, CT...>::reference>
+    class xfunction_iterator : public xtl::xrandom_access_iterator_base<
+                                   xfunction_iterator<F, CT...>,
+                                   typename xfunction<F, CT...>::value_type,
+                                   typename xfunction<F, CT...>::difference_type,
+                                   typename xfunction<F, CT...>::pointer,
+                                   typename xfunction<F, CT...>::reference>
     {
     public:
 
@@ -484,27 +416,21 @@ namespace xt
 
     private:
 
-        using data_type = std::tuple<get_iterator<const std::decay_t<CT>>...>;
-
-        template <std::size_t... I>
-        reference deref_impl(std::index_sequence<I...>) const;
+        using data_type = std::tuple<decltype(xt::linear_begin(std::declval<const std::decay_t<CT>>()))...>;
 
         template <std::size_t... I>
-        difference_type tuple_max_diff(std::index_sequence<I...>,
-                                       const data_type& lhs,
-                                       const data_type& rhs) const;
+        difference_type
+        tuple_max_diff(std::index_sequence<I...>, const data_type& lhs, const data_type& rhs) const;
 
         const xfunction_type* p_f;
         data_type m_it;
     };
 
     template <class F, class... CT>
-    bool operator==(const xfunction_iterator<F, CT...>& it1,
-                    const xfunction_iterator<F, CT...>& it2);
+    bool operator==(const xfunction_iterator<F, CT...>& it1, const xfunction_iterator<F, CT...>& it2);
 
     template <class F, class... CT>
-    bool operator<(const xfunction_iterator<F, CT...>& it1,
-                   const xfunction_iterator<F, CT...>& it2);
+    bool operator<(const xfunction_iterator<F, CT...>& it1, const xfunction_iterator<F, CT...>& it2);
 
     /*********************
      * xfunction_stepper *
@@ -520,15 +446,18 @@ namespace xt
         using xfunction_type = xfunction<F, CT...>;
 
         using value_type = typename xfunction_type::value_type;
-        using reference = 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... It>
-        xfunction_stepper(const xfunction_type* func, It&&... it) noexcept;
+        template <class requested_type>
+        using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
+
+        template <class... St>
+        xfunction_stepper(const xfunction_type* func, St&&... st) noexcept;
 
         void step(size_type dim);
         void step_back(size_type dim);
@@ -542,24 +471,15 @@ namespace xt
 
         reference operator*() const;
 
-        template <class ST>
-        ST step_simd();
+        template <class T>
+        simd_return_type<T> step_simd();
 
-        value_type step_leading();
+        void step_leading();
 
     private:
 
-        template <std::size_t... I>
-        reference deref_impl(std::index_sequence<I...>) const;
-
-        template <class ST, std::size_t... I>
-        ST step_simd_impl(std::index_sequence<I...>);
-
-        template <std::size_t... I>
-        value_type step_leading_impl(std::index_sequence<I...>);
-
         const xfunction_type* p_f;
-        std::tuple<typename std::decay_t<CT>::const_stepper...> m_it;
+        std::tuple<typename std::decay_t<CT>::const_stepper...> m_st;
     };
 
     /*********************************
@@ -579,22 +499,30 @@ namespace xt
     template <class F, class... CT>
     template <class Func, class... CTA, class U>
     inline xfunction<F, CT...>::xfunction(Func&& f, CTA&&... e) noexcept
-        : m_e(std::forward<CTA>(e)...), m_f(std::forward<Func>(f)) {}
-    //@}
+        : m_e(std::forward<CTA>(e)...)
+        , m_f(std::forward<Func>(f))
+    {
+    }
 
     /**
-     * @name Size and shape
-     */
-    //@{
-    /**
-     * Returns the size of the expression.
+     * Constructs an xfunction applying the specified function given by another
+     * xfunction with its arguments.
+     * @param xf the xfunction to apply
      */
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::size() const noexcept -> size_type
+    template <class FA, class... CTA>
+    inline xfunction<F, CT...>::xfunction(xfunction<FA, CTA...> xf) noexcept
+        : m_e(xf.arguments())
+        , m_f(xf.functor())
     {
-        return compute_size(shape());
     }
 
+    //@}
+
+    /**
+     * @name Size and shape
+     */
+    //@{
     /**
      * Returns the number of dimensions of the function.
      */
@@ -610,7 +538,7 @@ namespace xt
     {
         static_assert(!detail::is_fixed<shape_type>::value, "Calling compute_cached_shape on fixed!");
 
-        m_cache.shape = xtl::make_sequence<xindex_type_t<inner_shape_type>>(compute_dimension(), size_type(0));
+        m_cache.shape = uninitialized_shape<xindex_type_t<inner_shape_type>>(compute_dimension());
         m_cache.is_trivial = broadcast_shape(m_cache.shape, false);
         m_cache.is_initialized = true;
     }
@@ -621,14 +549,13 @@ namespace xt
     template <class F, class... CT>
     inline auto xfunction<F, CT...>::shape() const -> const inner_shape_type&
     {
-        xtl::mpl::static_if<!detail::is_fixed<inner_shape_type>::value>([&](auto self)
+        if constexpr (!detail::is_fixed<inner_shape_type>::value)
         {
-            if(!m_cache.is_initialized)
+            if (!m_cache.is_initialized)
             {
-                self(this)->compute_cached_shape();
+                compute_cached_shape();
             }
-        },
-        [](auto /*self*/){});
+        }
         return m_cache.shape;
     }
 
@@ -638,13 +565,35 @@ namespace xt
     template <class F, class... CT>
     inline layout_type xfunction<F, CT...>::layout() const noexcept
     {
-        return layout_impl(std::make_index_sequence<sizeof...(CT)>());
+        return std::apply(
+            [&](auto&... e)
+            {
+                return compute_layout(e.layout()...);
+            },
+            m_e
+        );
     }
+
+    template <class F, class... CT>
+    inline bool xfunction<F, CT...>::is_contiguous() const noexcept
+    {
+        return layout() != layout_type::dynamic
+               && accumulate(
+                   [](bool r, const auto& exp)
+                   {
+                       return r && exp.is_contiguous();
+                   },
+                   true,
+                   m_e
+               );
+    }
+
     //@}
 
     /**
      * @name Data
      */
+
     /**
      * Returns a constant reference to the element at the specified position in the function.
      * @param args a list of indices specifying the position in the function. Indices
@@ -657,24 +606,37 @@ namespace xt
     {
         // The static cast prevents the compiler from instantiating the template methods with signed integers,
         // leading to warning about signed/unsigned conversions in the deeper layers of the access methods
-        return access_impl(std::make_index_sequence<sizeof...(CT)>(), static_cast<size_type>(args)...);
+
+        return std::apply(
+            [&](auto&... e) -> const_reference
+            {
+                XTENSOR_TRY(check_index(shape(), args...));
+                XTENSOR_CHECK_DIMENSION(shape(), args...);
+                return m_f(e(args...)...);
+            },
+            m_e
+        );
     }
 
     /**
-     * Returns a constant reference to the element at the specified position in the expression,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
+     * @name Data
+     */
+
+    /**
+     * Returns a constant reference to the element at the specified position of the underlying
+     * contiguous storage of the function.
+     * @param index index to underlying flat storage.
      */
     template <class F, class... CT>
-    template <class... Args>
-    inline auto xfunction<F, CT...>::at(Args... args) const -> const_reference
+    inline auto xfunction<F, CT...>::flat(size_type index) const -> const_reference
     {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
+        return std::apply(
+            [&](auto&... e) -> const_reference
+            {
+                return m_f(e.data_element(index)...);
+            },
+            m_e
+        );
     }
 
     /**
@@ -685,16 +647,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
-     * double res = fd.uncheked(0, 1);
-     * \endcode
+     * double res = fd.unchecked(0, 1);
+     * @endcode
      */
     template <class F, class... CT>
     template <class... Args>
@@ -702,28 +664,13 @@ namespace xt
     {
         // The static cast prevents the compiler from instantiating the template methods with signed integers,
         // leading to warning about signed/unsigned conversions in the deeper layers of the access methods
-        return unchecked_impl(std::make_index_sequence<sizeof...(CT)>(), static_cast<size_type>(args)...);
-    }
-
-    template <class F, class... CT>
-    template <class S>
-    inline auto xfunction<F, CT...>::operator[](const S& index) const
-        -> disable_integral_t<S, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class F, class... CT>
-    template <class I>
-    inline auto xfunction<F, CT...>::operator[](std::initializer_list<I> index) const -> const_reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class F, class... CT>
-    inline auto xfunction<F, CT...>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
+        return std::apply(
+            [&](const auto&... e) -> const_reference
+            {
+                return m_f(e.unchecked(static_cast<size_type>(args)...)...);
+            },
+            m_e
+        );
     }
 
     /**
@@ -737,8 +684,16 @@ namespace xt
     template <class It>
     inline auto xfunction<F, CT...>::element(It first, It last) const -> const_reference
     {
-        return element_access_impl(std::make_index_sequence<sizeof...(CT)>(), first, last);
+        return std::apply(
+            [&](auto&... e) -> const_reference
+            {
+                XTENSOR_TRY(check_element_index(shape(), first, last));
+                return m_f(e.element(first, last)...);
+            },
+            m_e
+        );
     }
+
     //@}
 
     /**
@@ -755,7 +710,7 @@ namespace xt
     template <class S>
     inline bool xfunction<F, CT...>::broadcast_shape(S& shape, bool reuse_cache) const
     {
-        if(m_cache.is_initialized && reuse_cache)
+        if (m_cache.is_initialized && reuse_cache)
         {
             std::copy(m_cache.shape.cbegin(), m_cache.shape.cend(), shape.begin());
             return m_cache.is_trivial;
@@ -763,80 +718,96 @@ namespace xt
         else
         {
             // e.broadcast_shape must be evaluated even if b is false
-            auto func = [&shape](bool b, auto&& e) { return e.broadcast_shape(shape) && b; };
+            auto func = [&shape](bool b, auto&& e)
+            {
+                return e.broadcast_shape(shape) && b;
+            };
             return accumulate(func, true, m_e);
         }
     }
 
     /**
-    * Checks whether the xfunction can be linearly assigned to an expression
-    * with the specified strides.
-    * @return a boolean indicating whether a linear assign is possible
-    */
+     * Checks whether the xfunction can be linearly assigned to an expression
+     * with the specified strides.
+     * @return a boolean indicating whether a linear assign is possible
+     */
     template <class F, class... CT>
     template <class S>
     inline bool xfunction<F, CT...>::has_linear_assign(const S& strides) const noexcept
     {
-        auto func = [&strides](bool b, auto&& e) { return b && e.has_linear_assign(strides); };
+        auto func = [&strides](bool b, auto&& e)
+        {
+            return b && e.has_linear_assign(strides);
+        };
         return accumulate(func, true, m_e);
     }
+
     //@}
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_begin() const noexcept -> const_storage_iterator
+    inline auto xfunction<F, CT...>::linear_begin() const noexcept -> const_linear_iterator
     {
-        return storage_cbegin();
+        return linear_cbegin();
     }
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_end() const noexcept -> const_storage_iterator
+    inline auto xfunction<F, CT...>::linear_end() const noexcept -> const_linear_iterator
     {
-        return storage_cend();
+        return linear_cend();
     }
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_cbegin() const noexcept -> const_storage_iterator
+    inline auto xfunction<F, CT...>::linear_cbegin() const noexcept -> const_linear_iterator
     {
-        auto f = [](const auto& e) noexcept { return detail::linear_begin(e); };
+        auto f = [](const auto& e) noexcept
+        {
+            return xt::linear_begin(e);
+        };
         return build_iterator(f, std::make_index_sequence<sizeof...(CT)>());
     }
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_cend() const noexcept -> const_storage_iterator
+    inline auto xfunction<F, CT...>::linear_cend() const noexcept -> const_linear_iterator
     {
-        auto f = [](const auto& e) noexcept { return detail::linear_end(e); };
+        auto f = [](const auto& e) noexcept
+        {
+            return xt::linear_end(e);
+        };
         return build_iterator(f, std::make_index_sequence<sizeof...(CT)>());
     }
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_rbegin() const noexcept -> const_reverse_storage_iterator
+    inline auto xfunction<F, CT...>::linear_rbegin() const noexcept -> const_reverse_linear_iterator
     {
-        return storage_crbegin();
+        return linear_crbegin();
     }
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_rend() const noexcept -> const_reverse_storage_iterator
+    inline auto xfunction<F, CT...>::linear_rend() const noexcept -> const_reverse_linear_iterator
     {
-        return storage_crend();
+        return linear_crend();
     }
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_crbegin() const noexcept -> const_reverse_storage_iterator
+    inline auto xfunction<F, CT...>::linear_crbegin() const noexcept -> const_reverse_linear_iterator
     {
-        return const_reverse_storage_iterator(storage_cend());
+        return const_reverse_linear_iterator(linear_cend());
     }
 
     template <class F, class... CT>
-    inline auto xfunction<F, CT...>::storage_crend() const noexcept -> const_reverse_storage_iterator
+    inline auto xfunction<F, CT...>::linear_crend() const noexcept -> const_reverse_linear_iterator
     {
-        return const_reverse_storage_iterator(storage_cbegin());
+        return const_reverse_linear_iterator(linear_cbegin());
     }
 
     template <class F, class... CT>
     template <class S>
     inline auto xfunction<F, CT...>::stepper_begin(const S& shape) const noexcept -> const_stepper
     {
-        auto f = [&shape](const auto& e) noexcept { return e.stepper_begin(shape); };
+        auto f = [&shape](const auto& e) noexcept
+        {
+            return e.stepper_begin(shape);
+        };
         return build_stepper(f, std::make_index_sequence<sizeof...(CT)>());
     }
 
@@ -844,14 +815,23 @@ namespace xt
     template <class S>
     inline auto xfunction<F, CT...>::stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
     {
-        auto f = [&shape, l](const auto& e) noexcept { return e.stepper_end(shape, l); };
+        auto f = [&shape, l](const auto& e) noexcept
+        {
+            return e.stepper_end(shape, l);
+        };
         return build_stepper(f, std::make_index_sequence<sizeof...(CT)>());
     }
 
     template <class F, class... CT>
     inline auto xfunction<F, CT...>::data_element(size_type i) const -> const_reference
     {
-        return data_element_impl(std::make_index_sequence<sizeof...(CT)>(), i);
+        return std::apply(
+            [&](auto&... e) -> const_reference
+            {
+                return m_f(e.data_element(i)...);
+            },
+            m_e
+        );
     }
 
     template <class F, class... CT>
@@ -863,10 +843,15 @@ namespace xt
 
     template <class F, class... CT>
     template <class align, class requested_type, std::size_t N>
-    inline auto xfunction<F, CT...>::load_simd(size_type i) const
-        -> simd_return_type<requested_type>
+    inline auto xfunction<F, CT...>::load_simd(size_type i) const -> simd_return_type<requested_type>
     {
-        return load_simd_impl<align, requested_type, N>(std::make_index_sequence<sizeof...(CT)>(), i);
+        return std::apply(
+            [&](auto&... e)
+            {
+                return m_f.simd_apply((e.template load_simd<align, requested_type>(i))...);
+            },
+            m_e
+        );
     }
 
     template <class F, class... CT>
@@ -876,77 +861,15 @@ namespace xt
     }
 
     template <class F, class... CT>
-    template <std::size_t... I>
-    inline layout_type xfunction<F, CT...>::layout_impl(std::index_sequence<I...>) const noexcept
-    {
-        return compute_layout(std::get<I>(m_e).layout()...);
-    }
-
-    template <class F, class... CT>
-    template <std::size_t... I, class... Args>
-    inline auto xfunction<F, CT...>::access_impl(std::index_sequence<I...>, Args... args) const -> const_reference
-    {
-        XTENSOR_TRY(check_index(shape(), args...));
-        XTENSOR_CHECK_DIMENSION(shape(), args...);
-        return m_f(std::get<I>(m_e)(args...)...);
-    }
-
-    template <class F, class... CT>
-    template <std::size_t... I, class... Args>
-    inline auto xfunction<F, CT...>::unchecked_impl(std::index_sequence<I...>, Args... args) const -> const_reference
-    {
-        return m_f(std::get<I>(m_e).unchecked(args...)...);
-    }
-
-    template <class F, class... CT>
-    template <std::size_t... I, class It>
-    inline auto xfunction<F, CT...>::element_access_impl(std::index_sequence<I...>, It first, It last) const -> const_reference
-    {
-        XTENSOR_TRY(check_element_index(shape(), first, last));
-        return m_f((std::get<I>(m_e).element(first, last))...);
-    }
-
-    template <class F, class... CT>
-    template <std::size_t... I>
-    inline auto xfunction<F, CT...>::data_element_impl(std::index_sequence<I...>, size_type i) const -> const_reference
-    {
-        return m_f((std::get<I>(m_e).data_element(i))...);
-    }
-
-    namespace detail
-    {
-        // This metafunction avoids loading boolean values as batches of floating points and
-        // reciprocally. However, we cannot always load data as batches of their scalar type
-        // since this prevents mixed arithmetic.
-        template <class T, class simd, class common_simd>
-        struct get_simd_type
-        {
-            using simd_value_type = typename std::decay_t<T>::simd_value_type;
-            static constexpr bool is_arg_bool = ::xsimd::is_batch_bool<simd_value_type>::value;
-            static constexpr bool is_res_bool = ::xsimd::is_batch_bool<simd>::value;
-            static constexpr bool is_arg_cplx = ::xsimd::is_batch_complex<simd_value_type>::value;
-            using type = std::conditional_t<is_res_bool,
-                                            common_simd,
-                                            std::conditional_t<is_arg_bool || is_arg_cplx,
-                                                               simd_value_type,
-                                                               simd>>;
-        };
-
-        template <class T, class simd, class common_simd>
-        using get_simd_type_t = typename get_simd_type<T, simd, common_simd>::type;
-    }
-
-    template <class F, class... CT>
-    template <class align, class requested_type, std::size_t N, std::size_t... I>
-    inline auto xfunction<F, CT...>::load_simd_impl(std::index_sequence<I...>, size_type i) const
+    inline auto xfunction<F, CT...>::functor() const noexcept -> const functor_type&
     {
-        return m_f.simd_apply((std::get<I>(m_e)
-            .template load_simd<align, requested_type>(i))...);
+        return m_f;
     }
 
     template <class F, class... CT>
     template <class Func, std::size_t... I>
-    inline auto xfunction<F, CT...>::build_stepper(Func&& f, std::index_sequence<I...>) const noexcept -> const_stepper
+    inline auto xfunction<F, CT...>::build_stepper(Func&& f, std::index_sequence<I...>) const noexcept
+        -> const_stepper
     {
         return const_stepper(this, f(std::get<I>(m_e))...);
     }
@@ -955,13 +878,16 @@ namespace xt
     template <class Func, std::size_t... I>
     inline auto xfunction<F, CT...>::build_iterator(Func&& f, std::index_sequence<I...>) const noexcept
     {
-        return const_storage_iterator(this, f(std::get<I>(m_e))...);
+        return const_linear_iterator(this, f(std::get<I>(m_e))...);
     }
 
     template <class F, class... CT>
     inline auto xfunction<F, CT...>::compute_dimension() const noexcept -> size_type
     {
-        auto func = [](size_type d, auto&& e) noexcept { return (std::max)(d, e.dimension()); };
+        auto func = [](size_type d, auto&& e) noexcept
+        {
+            return (std::max)(d, e.dimension());
+        };
         return accumulate(func, size_type(0), m_e);
     }
 
@@ -972,14 +898,18 @@ namespace xt
     template <class F, class... CT>
     template <class... It>
     inline xfunction_iterator<F, CT...>::xfunction_iterator(const xfunction_type* func, It&&... it) noexcept
-        : p_f(func), m_it(std::forward<It>(it)...)
+        : p_f(func)
+        , m_it(std::forward<It>(it)...)
     {
     }
 
     template <class F, class... CT>
     inline auto xfunction_iterator<F, CT...>::operator++() -> self_type&
     {
-        auto f = [](auto& it) { ++it; };
+        auto f = [](auto& it)
+        {
+            ++it;
+        };
         for_each(f, m_it);
         return *this;
     }
@@ -987,7 +917,10 @@ namespace xt
     template <class F, class... CT>
     inline auto xfunction_iterator<F, CT...>::operator--() -> self_type&
     {
-        auto f = [](auto& it) { return --it; };
+        auto f = [](auto& it)
+        {
+            return --it;
+        };
         for_each(f, m_it);
         return *this;
     }
@@ -995,7 +928,10 @@ namespace xt
     template <class F, class... CT>
     inline auto xfunction_iterator<F, CT...>::operator+=(difference_type n) -> self_type&
     {
-        auto f = [n](auto& it) { it += n; };
+        auto f = [n](auto& it)
+        {
+            it += n;
+        };
         for_each(f, m_it);
         return *this;
     }
@@ -1003,7 +939,10 @@ namespace xt
     template <class F, class... CT>
     inline auto xfunction_iterator<F, CT...>::operator-=(difference_type n) -> self_type&
     {
-        auto f = [n](auto& it) { it -= n; };
+        auto f = [n](auto& it)
+        {
+            it -= n;
+        };
         for_each(f, m_it);
         return *this;
     }
@@ -1017,7 +956,13 @@ namespace xt
     template <class F, class... CT>
     inline auto xfunction_iterator<F, CT...>::operator*() const -> reference
     {
-        return deref_impl(std::make_index_sequence<sizeof...(CT)>());
+        return std::apply(
+            [&](auto&... it) -> reference
+            {
+                return (p_f->m_f)(*it...);
+            },
+            m_it
+        );
     }
 
     template <class F, class... CT>
@@ -1025,7 +970,8 @@ namespace xt
     {
         // Optimization: no need to compare each subiterator since they all
         // are incremented decremented together.
-        constexpr std::size_t index = xtl::mpl::find_if<is_xdummy_iterator, data_type>::value;
+        constexpr std::size_t temp = xtl::mpl::find_if<is_not_xdummy_iterator, data_type>::value;
+        constexpr std::size_t index = (temp == std::tuple_size<data_type>::value) ? 0 : temp;
         return std::get<index>(m_it) == std::get<index>(rhs.m_it);
     }
 
@@ -1034,38 +980,35 @@ namespace xt
     {
         // Optimization: no need to compare each subiterator since they all
         // are incremented decremented together.
-        constexpr std::size_t index = xtl::mpl::find_if<is_xdummy_iterator, data_type>::value;
+        constexpr std::size_t temp = xtl::mpl::find_if<is_not_xdummy_iterator, data_type>::value;
+        constexpr std::size_t index = (temp == std::tuple_size<data_type>::value) ? 0 : temp;
         return std::get<index>(m_it) < std::get<index>(rhs.m_it);
     }
 
     template <class F, class... CT>
     template <std::size_t... I>
-    inline auto xfunction_iterator<F, CT...>::deref_impl(std::index_sequence<I...>) const -> reference
-    {
-        return (p_f->m_f)(*std::get<I>(m_it)...);
-    }
-
-    template <class F, class... CT>
-    template <std::size_t... I>
-    inline auto xfunction_iterator<F, CT...>::tuple_max_diff(std::index_sequence<I...>,
-                                                                const data_type& lhs,
-                                                                const data_type& rhs) const -> difference_type
+    inline auto xfunction_iterator<F, CT...>::tuple_max_diff(
+        std::index_sequence<I...>,
+        const data_type& lhs,
+        const data_type& rhs
+    ) const -> difference_type
     {
         auto diff = std::make_tuple((std::get<I>(lhs) - std::get<I>(rhs))...);
-        auto func = [](difference_type n, auto&& v) { return (std::max)(n, v); };
+        auto func = [](difference_type n, auto&& v)
+        {
+            return (std::max)(n, v);
+        };
         return accumulate(func, difference_type(0), diff);
     }
 
     template <class F, class... CT>
-    inline bool operator==(const xfunction_iterator<F, CT...>& it1,
-                           const xfunction_iterator<F, CT...>& it2)
+    inline bool operator==(const xfunction_iterator<F, CT...>& it1, const xfunction_iterator<F, CT...>& it2)
     {
         return it1.equal(it2);
     }
 
     template <class F, class... CT>
-    inline bool operator<(const xfunction_iterator<F, CT...>& it1,
-                          const xfunction_iterator<F, CT...>& it2)
+    inline bool operator<(const xfunction_iterator<F, CT...>& it1, const xfunction_iterator<F, CT...>& it2)
     {
         return it1.less_than(it2);
     }
@@ -1075,112 +1018,126 @@ namespace xt
      ************************************/
 
     template <class F, class... CT>
-    template <class... It>
-    inline xfunction_stepper<F, CT...>::xfunction_stepper(const xfunction_type* func, It&&... it) noexcept
-        : p_f(func), m_it(std::forward<It>(it)...)
+    template <class... St>
+    inline xfunction_stepper<F, CT...>::xfunction_stepper(const xfunction_type* func, St&&... st) noexcept
+        : p_f(func)
+        , m_st(std::forward<St>(st)...)
     {
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::step(size_type dim)
     {
-        auto f = [dim](auto& it) { it.step(dim); };
-        for_each(f, m_it);
+        auto f = [dim](auto& st)
+        {
+            st.step(dim);
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::step_back(size_type dim)
     {
-        auto f = [dim](auto& it) { it.step_back(dim); };
-        for_each(f, m_it);
+        auto f = [dim](auto& st)
+        {
+            st.step_back(dim);
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::step(size_type dim, size_type n)
     {
-        auto f = [dim, n](auto& it) { it.step(dim, n); };
-        for_each(f, m_it);
+        auto f = [dim, n](auto& st)
+        {
+            st.step(dim, n);
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::step_back(size_type dim, size_type n)
     {
-        auto f = [dim, n](auto& it) { it.step_back(dim, n); };
-        for_each(f, m_it);
+        auto f = [dim, n](auto& st)
+        {
+            st.step_back(dim, n);
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::reset(size_type dim)
     {
-        auto f = [dim](auto& it) { it.reset(dim); };
-        for_each(f, m_it);
+        auto f = [dim](auto& st)
+        {
+            st.reset(dim);
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::reset_back(size_type dim)
     {
-        auto f = [dim](auto& it) { it.reset_back(dim); };
-        for_each(f, m_it);
+        auto f = [dim](auto& st)
+        {
+            st.reset_back(dim);
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::to_begin()
     {
-        auto f = [](auto& it) { it.to_begin(); };
-        for_each(f, m_it);
+        auto f = [](auto& st)
+        {
+            st.to_begin();
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline void xfunction_stepper<F, CT...>::to_end(layout_type l)
     {
-        auto f = [l](auto& it) { it.to_end(l); };
-        for_each(f, m_it);
+        auto f = [l](auto& st)
+        {
+            st.to_end(l);
+        };
+        for_each(f, m_st);
     }
 
     template <class F, class... CT>
     inline auto xfunction_stepper<F, CT...>::operator*() const -> reference
     {
-        return deref_impl(std::make_index_sequence<sizeof...(CT)>());
-    }
-
-    template <class F, class... CT>
-    template <std::size_t... I>
-    inline auto xfunction_stepper<F, CT...>::deref_impl(std::index_sequence<I...>) const -> reference
-    {
-        return (p_f->m_f)(*std::get<I>(m_it)...);
-    }
-
-    template <class F, class... CT>
-    template <class ST, std::size_t... I>
-    inline ST xfunction_stepper<F, CT...>::step_simd_impl(std::index_sequence<I...>)
-    {
-        return (p_f->m_f.simd_apply)(std::get<I>(m_it).template
-            step_simd<detail::get_simd_type_t<std::tuple_element_t<I, typename xfunction_type::tuple_type>,
-                                              ST,
-                                              typename xfunction_type::simd_argument_type
-                                              >>()...);
-    }
-
-    template <class F, class... CT>
-    template <class ST>
-    inline ST xfunction_stepper<F, CT...>::step_simd()
-    {
-        return step_simd_impl<ST>(std::make_index_sequence<sizeof...(CT)>());
+        return std::apply(
+            [&](auto&... e) -> reference
+            {
+                return (p_f->m_f)(*e...);
+            },
+            m_st
+        );
     }
 
     template <class F, class... CT>
-    template <std::size_t... I>
-    inline auto xfunction_stepper<F, CT...>::step_leading_impl(std::index_sequence<I...>)
-        -> value_type
+    template <class T>
+    inline auto xfunction_stepper<F, CT...>::step_simd() -> simd_return_type<T>
     {
-        return (p_f->m_f)(std::get<I>(m_it).step_leading()...);
+        return std::apply(
+            [&](auto&... st)
+            {
+                return (p_f->m_f.simd_apply)(st.template step_simd<T>()...);
+            },
+            m_st
+        );
     }
 
     template <class F, class... CT>
-    inline auto xfunction_stepper<F, CT...>::step_leading()
-        -> value_type
+    inline void xfunction_stepper<F, CT...>::step_leading()
     {
-        return step_leading_impl(std::make_index_sequence<sizeof...(CT)>());
+        auto step_leading_lambda = [](auto&& st)
+        {
+            st.step_leading();
+        };
+        for_each(step_leading_lambda, m_st);
     }
 }
 
diff --git a/include/xtensor/xiterable.hpp b/include/xtensor/core/xiterable.hpp
similarity index 70%
rename from include/xtensor/xiterable.hpp
rename to include/xtensor/core/xiterable.hpp
index febfba8ee..62f48173a 100644
--- a/include/xtensor/xiterable.hpp
+++ b/include/xtensor/core/xiterable.hpp
@@ -1,15 +1,16 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ITERABLE_HPP
 #define XTENSOR_ITERABLE_HPP
 
-#include "xiterator.hpp"
+#include "../core/xiterator.hpp"
 
 namespace xt
 {
@@ -21,8 +22,6 @@ namespace xt
     template <class D>
     struct xiterable_inner_types;
 
-#define DL XTENSOR_DEFAULT_LAYOUT
-
     /**
      * @class xconst_iterable
      * @brief Base class for multidimensional iterable constant expressions
@@ -55,10 +54,10 @@ namespace xt
         template <layout_type L>
         using const_reverse_layout_iterator = std::reverse_iterator<const_layout_iterator<L>>;
 
-        using storage_iterator = layout_iterator<DL>;
-        using const_storage_iterator = const_layout_iterator<DL>;
-        using reverse_storage_iterator = reverse_layout_iterator<DL>;
-        using const_reverse_storage_iterator = const_reverse_layout_iterator<DL>;
+        using linear_iterator = layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using const_linear_iterator = const_layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using reverse_linear_iterator = reverse_layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using const_reverse_linear_iterator = const_reverse_layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
 
         template <class S, layout_type L>
         using broadcast_iterator = xiterator<stepper, S, L>;
@@ -69,45 +68,45 @@ namespace xt
         template <class S, layout_type L>
         using const_reverse_broadcast_iterator = std::reverse_iterator<const_broadcast_iterator<S, L>>;
 
-        using iterator = layout_iterator<DL>;
-        using const_iterator = const_layout_iterator<DL>;
-        using reverse_iterator = reverse_layout_iterator<DL>;
-        using const_reverse_iterator = const_reverse_layout_iterator<DL>;
+        using iterator = layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using const_iterator = const_layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using reverse_iterator = reverse_layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using const_reverse_iterator = const_reverse_layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_layout_iterator<L> begin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_layout_iterator<L> end() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_layout_iterator<L> cbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_layout_iterator<L> cend() const noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_layout_iterator<L> rbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_layout_iterator<L> rend() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_layout_iterator<L> crbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         const_reverse_layout_iterator<L> crend() const noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
 
     protected:
@@ -161,8 +160,8 @@ namespace xt
         using stepper = typename base_type::stepper;
         using const_stepper = typename base_type::const_stepper;
 
-        using storage_iterator = typename base_type::storage_iterator;
-        using reverse_storage_iterator = typename base_type::reverse_storage_iterator;
+        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>;
@@ -192,24 +191,24 @@ namespace xt
         using base_type::rbegin;
         using base_type::rend;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         layout_iterator<L> begin() noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         layout_iterator<L> end() noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         reverse_layout_iterator<L> rbegin() noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         reverse_layout_iterator<L> rend() noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         broadcast_iterator<S, L> begin(const S& shape) noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         broadcast_iterator<S, L> end(const S& shape) noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
 
     private:
@@ -244,6 +243,59 @@ namespace xt
     template <class D>
     struct xcontainer_inner_types;
 
+    namespace detail
+    {
+        template <class T, bool is_const>
+        struct get_storage_iterator;
+
+        template <class T>
+        struct get_storage_iterator<T, true>
+        {
+            using iterator = typename T::const_iterator;
+            using const_iterator = typename T::const_iterator;
+            using reverse_iterator = typename T::const_reverse_iterator;
+            using const_reverse_iterator = typename T::const_reverse_iterator;
+        };
+
+        template <class T>
+        struct get_storage_iterator<T, false>
+        {
+            using iterator = typename T::iterator;
+            using const_iterator = typename T::const_iterator;
+            using reverse_iterator = typename T::reverse_iterator;
+            using const_reverse_iterator = typename T::const_reverse_iterator;
+        };
+
+        template <class D, bool has_storage_type>
+        struct linear_iterator_traits_impl;
+
+        template <class D>
+        struct linear_iterator_traits_impl<D, true>
+        {
+            using inner_types = xcontainer_inner_types<D>;
+            using storage_type = typename inner_types::storage_type;
+            using iterator_type = get_storage_iterator<storage_type, std::is_const<storage_type>::value>;
+            using linear_iterator = typename iterator_type::iterator;
+            using const_linear_iterator = typename iterator_type::const_iterator;
+            using reverse_linear_iterator = typename iterator_type::reverse_iterator;
+            using const_reverse_linear_iterator = typename iterator_type::const_reverse_iterator;
+        };
+
+        template <class D>
+        struct linear_iterator_traits_impl<D, false>
+        {
+            using inner_types = xcontainer_inner_types<D>;
+            using xexpression_type = typename inner_types::xexpression_type;
+            using linear_iterator = typename xexpression_type::linear_iterator;
+            using const_linear_iterator = typename xexpression_type::const_linear_iterator;
+            using reverse_linear_iterator = typename xexpression_type::reverse_linear_iterator;
+            using const_reverse_linear_iterator = typename xexpression_type::const_reverse_linear_iterator;
+        };
+
+        template <class D>
+        using linear_iterator_traits = linear_iterator_traits_impl<D, container_expression<D>>;
+    }
+
     /**
      * @class xcontiguous_iterable
      * @brief Base class for multidimensional iterable expressions with
@@ -263,7 +315,6 @@ namespace xt
         using derived_type = D;
 
         using inner_types = xcontainer_inner_types<D>;
-        using storage_type = typename inner_types::storage_type;
 
         using iterable_base = xiterable<D>;
         using stepper = typename iterable_base::stepper;
@@ -271,17 +322,6 @@ namespace xt
 
         static constexpr layout_type static_layout = inner_types::layout;
 
-#if defined(_MSC_VER) && _MSC_VER >= 1910
-        // Workaround for compiler bug in Visual Studio 2017 with respect to alias templates with non-type parameters.
-        template <layout_type L>
-        using layout_iterator = xiterator<typename iterable_base::stepper, typename iterable_base::inner_shape_type*, L>;
-        template <layout_type L>
-        using const_layout_iterator = xiterator<typename iterable_base::const_stepper, typename iterable_base::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>>;
-#else
         template <layout_type L>
         using layout_iterator = typename iterable_base::template layout_iterator<L>;
         template <layout_type L>
@@ -290,7 +330,6 @@ namespace xt
         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>;
-#endif
 
         template <class S, layout_type L>
         using broadcast_iterator = typename iterable_base::template broadcast_iterator<S, L>;
@@ -301,82 +340,86 @@ namespace xt
         template <class S, layout_type L>
         using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>;
 
-        using storage_iterator = typename storage_type::iterator;
-        using const_storage_iterator = typename storage_type::const_iterator;
-        using reverse_storage_iterator = typename storage_type::reverse_iterator;
-        using const_reverse_storage_iterator = typename storage_type::const_reverse_iterator;
+        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, storage_iterator, layout_iterator<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_storage_iterator, const_layout_iterator<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_storage_iterator, reverse_layout_iterator<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 = select_iterator_impl<L, const_reverse_storage_iterator, const_reverse_layout_iterator<L>>;
+        using select_const_reverse_iterator = select_iterator_impl<
+            L,
+            const_reverse_linear_iterator,
+            const_reverse_layout_iterator<L>>;
 
-        using iterator = select_iterator<DL>;
-        using const_iterator = select_const_iterator<DL>;
-        using reverse_iterator = select_reverse_iterator<DL>;
-        using const_reverse_iterator = select_const_reverse_iterator<DL>;
+        using iterator = select_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using const_iterator = select_const_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using reverse_iterator = select_reverse_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
+        using const_reverse_iterator = select_const_reverse_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_iterator<L> begin() noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_iterator<L> end() noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_iterator<L> begin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_iterator<L> end() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_iterator<L> cbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_iterator<L> cend() const noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_reverse_iterator<L> rbegin() noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_reverse_iterator<L> rend() noexcept;
 
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_reverse_iterator<L> rbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_reverse_iterator<L> rend() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_reverse_iterator<L> crbegin() const noexcept;
-        template <layout_type L = DL>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
         select_const_reverse_iterator<L> crend() const noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         broadcast_iterator<S, L> begin(const S& shape) noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         broadcast_iterator<S, L> end(const S& shape) noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
 
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
-        template <layout_type L = DL, class S>
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
         const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
 
     private:
@@ -388,8 +431,6 @@ namespace xt
         friend class xconst_iterable<D>;
     };
 
-#undef DL
-
     /**********************************
      * xconst_iterable implementation *
      **********************************/
@@ -400,7 +441,7 @@ namespace xt
     //@{
     /**
      * Returns a constant iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -412,7 +453,7 @@ namespace xt
     /**
      * Returns a constant iterator to the element following the last element
      * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -423,7 +464,7 @@ namespace xt
 
     /**
      * Returns a constant iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -435,7 +476,7 @@ namespace xt
     /**
      * Returns a constant iterator to the element following the last element
      * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -443,6 +484,7 @@ namespace xt
     {
         return this->template get_cend<L>(true);
     }
+
     //@}
 
     /**
@@ -451,7 +493,7 @@ namespace xt
     //@{
     /**
      * Returns a constant iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -463,7 +505,7 @@ namespace xt
     /**
      * Returns a constant iterator to the element following the last element
      * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -474,7 +516,7 @@ namespace xt
 
     /**
      * Returns a constant iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -486,7 +528,7 @@ namespace xt
     /**
      * Returns a constant iterator to the element following the last element
      * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -494,6 +536,7 @@ namespace xt
     {
         return const_reverse_layout_iterator<L>(get_cbegin<L>(false));
     }
+
     //@}
 
     /**
@@ -505,7 +548,7 @@ namespace xt
      * iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -519,7 +562,7 @@ namespace xt
      * expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -533,7 +576,7 @@ namespace xt
      * iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -547,7 +590,7 @@ namespace xt
      * expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -555,6 +598,7 @@ namespace xt
     {
         return get_cend<L, S>(shape, true);
     }
+
     //@}
 
     /**
@@ -566,11 +610,12 @@ namespace xt
      * The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::rbegin(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::rbegin(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return crbegin<L, S>(shape);
     }
@@ -580,11 +625,12 @@ namespace xt
      * reversed expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::rend(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::rend(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return crend<L, S>(shape);
     }
@@ -594,11 +640,12 @@ namespace xt
      * The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::crbegin(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::crbegin(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return const_reverse_broadcast_iterator<S, L>(get_cend<L, S>(shape, true));
     }
@@ -608,14 +655,16 @@ namespace xt
      * reversed expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::crend(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::crend(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return const_reverse_broadcast_iterator<S, L>(get_cbegin<L, S>(shape, false));
     }
+
     //@}
 
     template <class D>
@@ -634,14 +683,16 @@ namespace xt
 
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::get_cbegin(const S& shape, bool end_index) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::get_cbegin(const S& shape, bool end_index) const noexcept
+        -> const_broadcast_iterator<S, L>
     {
         return const_broadcast_iterator<S, L>(get_stepper_begin(shape), shape, end_index);
     }
 
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::get_cend(const S& shape, bool end_index) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::get_cend(const S& shape, bool end_index) const noexcept
+        -> const_broadcast_iterator<S, L>
     {
         return const_broadcast_iterator<S, L>(get_stepper_end(shape, L), shape, end_index);
     }
@@ -655,7 +706,8 @@ namespace xt
 
     template <class D>
     template <class S>
-    inline auto xconst_iterable<D>::get_stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
+    inline auto xconst_iterable<D>::get_stepper_end(const S& shape, layout_type l) const noexcept
+        -> const_stepper
     {
         return derived_cast().stepper_end(shape, l);
     }
@@ -682,7 +734,7 @@ namespace xt
     //@{
     /**
      * Returns an iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -694,7 +746,7 @@ namespace xt
     /**
      * Returns an iterator to the element following the last element
      * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -702,6 +754,7 @@ namespace xt
     {
         return get_end<L>(true);
     }
+
     //@}
 
     /**
@@ -710,7 +763,7 @@ namespace xt
     //@{
     /**
      * Returns an iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -722,7 +775,7 @@ namespace xt
     /**
      * Returns an iterator to the element following the last element
      * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -730,6 +783,7 @@ namespace xt
     {
         return reverse_layout_iterator<L>(get_begin<L>(false));
     }
+
     //@}
 
     /**
@@ -741,7 +795,7 @@ namespace xt
      * iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -755,7 +809,7 @@ namespace xt
      * expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -763,6 +817,7 @@ namespace xt
     {
         return get_end<L, S>(shape, true);
     }
+
     //@}
 
     /**
@@ -774,7 +829,7 @@ namespace xt
      * iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -788,7 +843,7 @@ namespace xt
      * reversed expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -796,6 +851,7 @@ namespace xt
     {
         return reverse_broadcast_iterator<S, L>(get_begin<L, S>(shape, false));
     }
+
     //@}
 
     template <class D>
@@ -864,48 +920,50 @@ namespace xt
      * xcontiguous_iterable implementation *
      ***************************************/
 
-     /**
-      * @name Iterators
-      */
-     //@{
-     /**
-      * Returns an iterator to the first element of the expression.
-      * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-      */
+    /**
+     * @name Iterators
+     */
+    //@{
+    /**
+     * Returns an iterator to the first element of the expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::begin() noexcept -> select_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_begin();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_begin();
+        }
+        else
         {
-            return self(*this).iterable_base::template begin<L>();
-        });
+            return iterable_base::template begin<L>();
+        }
     }
 
     /**
      * Returns an iterator to the element following the last element
      * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::end() noexcept -> select_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_end();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_end();
+        }
+        else
         {
-            return self(*this).iterable_base::template end<L>();
-        });
+            return iterable_base::template end<L>();
+        }
     }
 
     /**
      * Returns a constant iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -917,7 +975,7 @@ namespace xt
     /**
      * Returns a constant iterator to the element following the last element
      * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -928,38 +986,41 @@ namespace xt
 
     /**
      * Returns a constant iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::cbegin() const noexcept -> select_const_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_cbegin();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_cbegin();
+        }
+        else
         {
-            return self(*this).iterable_base::template cbegin<L>();
-        });
+            return iterable_base::template cbegin<L>();
+        }
     }
 
     /**
      * Returns a constant iterator to the element following the last element
      * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::cend() const noexcept -> select_const_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_cend();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_cend();
+        }
+        else
         {
-            return self(*this).iterable_base::template cend<L>();
-        });
+            return iterable_base::template cend<L>();
+        }
     }
+
     //@}
 
     /**
@@ -968,42 +1029,44 @@ namespace xt
     //@{
     /**
      * Returns an iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::rbegin() noexcept -> select_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_rbegin();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_rbegin();
+        }
+        else
         {
-            return self(*this).iterable_base::template rbegin<L>();
-        });
+            return iterable_base::template rbegin<L>();
+        }
     }
 
     /**
      * Returns an iterator to the element following the last element
      * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::rend() noexcept -> select_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_rend();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_rend();
+        }
+        else
         {
-            return self(*this).iterable_base::template rend<L>();
-        });
+            return iterable_base::template rend<L>();
+        }
     }
 
     /**
      * Returns a constant iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -1012,11 +1075,10 @@ namespace xt
         return this->template crbegin<L>();
     }
 
-
     /**
      * Returns a constant iterator to the element following the last element
      * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
@@ -1027,50 +1089,54 @@ namespace xt
 
     /**
      * Returns a constant iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::crbegin() const noexcept -> select_const_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_crbegin();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_crbegin();
+        }
+        else
         {
-            return self(*this).iterable_base::template crbegin<L>();
-        });
+            return iterable_base::template crbegin<L>();
+        }
     }
 
     /**
      * Returns a constant iterator to the element following the last element
      * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L>
     inline auto xcontiguous_iterable<D>::crend() const noexcept -> select_const_reverse_iterator<L>
     {
-        return xtl::mpl::static_if<L == static_layout>([&](auto self)
+        if constexpr (L == static_layout)
         {
-            return self(*this).derived_cast().storage_crend();
-        }, /*else*/ [&](auto self)
+            return derived_cast().linear_crend();
+        }
+        else
         {
-            return self(*this).iterable_base::template crend<L>();
-        });
+            return iterable_base::template crend<L>();
+        }
     }
+
     //@}
 
     /**
      * @name Broadcast iterators
      */
-     /**
-      * Returns an iterator to the first element of the expression. The
-      * iteration is broadcasted to the specified shape.
-      * @param shape the shape used for broadcasting
-      * @tparam S type of the \c shape parameter.
-      * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-      */
+
+    /**
+     * Returns an iterator to the first element of the expression. The
+     * iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
     //@{
     template <class D>
     template <layout_type L, class S>
@@ -1084,7 +1150,7 @@ namespace xt
      * expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -1098,7 +1164,7 @@ namespace xt
      * iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -1112,7 +1178,7 @@ namespace xt
      * expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -1126,11 +1192,12 @@ namespace xt
      * iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::cbegin(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::cbegin(const S& shape) const noexcept
+        -> const_broadcast_iterator<S, L>
     {
         return iterable_base::template cbegin<L, S>(shape);
     }
@@ -1140,7 +1207,7 @@ namespace xt
      * expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -1148,6 +1215,7 @@ namespace xt
     {
         return iterable_base::template cend<L, S>(shape);
     }
+
     //@}
 
     /**
@@ -1159,7 +1227,7 @@ namespace xt
      * iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -1173,7 +1241,7 @@ namespace xt
      * reversed expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
@@ -1187,11 +1255,12 @@ namespace xt
      * The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::rbegin(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::rbegin(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template rbegin<L, S>(shape);
     }
@@ -1201,11 +1270,12 @@ namespace xt
      * reversed expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::rend(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::rend(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template rend<L, S>(shape);
     }
@@ -1215,11 +1285,12 @@ namespace xt
      * The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::crbegin(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::crbegin(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template crbegin<L, S>(shape);
     }
@@ -1229,14 +1300,16 @@ namespace xt
      * reversed expression. The iteration is broadcasted to the specified shape.
      * @param shape the shape used for broadcasting
      * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::crend(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::crend(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template crend<L, S>(shape);
     }
+
     //@}
 
     template <class D>
diff --git a/include/xtensor/xiterator.hpp b/include/xtensor/core/xiterator.hpp
similarity index 65%
rename from include/xtensor/xiterator.hpp
rename to include/xtensor/core/xiterator.hpp
index d7496b492..448f6093d 100644
--- a/include/xtensor/xiterator.hpp
+++ b/include/xtensor/core/xiterator.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ITERATOR_HPP
 #define XTENSOR_ITERATOR_HPP
@@ -14,16 +15,16 @@
 #include <cstddef>
 #include <iterator>
 #include <numeric>
-#include <vector>
 
+#include <xtl/xcompare.hpp>
 #include <xtl/xiterator_base.hpp>
 #include <xtl/xmeta_utils.hpp>
 #include <xtl/xsequence.hpp>
 
-#include "xexception.hpp"
-#include "xlayout.hpp"
-#include "xshape.hpp"
-#include "xutils.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xshape.hpp"
+#include "../utils/xexception.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
@@ -35,6 +36,9 @@ namespace xt
     template <class CT>
     class xscalar;
 
+    template <bool is_const, class CT>
+    class xscalar_stepper;
+
     namespace detail
     {
         template <class C>
@@ -111,7 +115,10 @@ namespace xt
         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_type = xsimd::simd_type<value_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>;
 
         xstepper() = default;
         xstepper(storage_type* c, subiterator_type it, size_type offset) noexcept;
@@ -126,10 +133,10 @@ namespace xt
         void to_begin();
         void to_end(layout_type l);
 
-        template <class R>
-        R step_simd();
+        template <class T>
+        simd_return_type<T> step_simd();
 
-        value_type step_leading();
+        void step_leading();
 
         template <class R>
         void store_simd(const R& vec);
@@ -149,26 +156,16 @@ namespace xt
         // operator-- on xiterators.
 
         template <class S, class IT, class ST>
-        static void increment_stepper(S& stepper,
-                                      IT& index,
-                                      const ST& shape);
+        static void increment_stepper(S& stepper, IT& index, const ST& shape);
 
         template <class S, class IT, class ST>
-        static void decrement_stepper(S& stepper,
-                                      IT& index,
-                                      const ST& shape);
+        static void decrement_stepper(S& stepper, IT& index, const ST& shape);
 
         template <class S, class IT, class ST>
-        static void increment_stepper(S& stepper,
-                                      IT& index,
-                                      const ST& shape,
-                                      typename S::size_type n);
+        static void increment_stepper(S& stepper, IT& index, const ST& shape, typename S::size_type n);
 
         template <class S, class IT, class ST>
-        static void decrement_stepper(S& stepper,
-                                      IT& index,
-                                      const ST& shape,
-                                      typename S::size_type n);
+        static void decrement_stepper(S& stepper, IT& index, const ST& shape, typename S::size_type n);
     };
 
     /********************
@@ -184,12 +181,10 @@ namespace xt
         using xexpression_type = std::conditional_t<is_const, const E, E>;
 
         using value_type = typename xexpression_type::value_type;
-        using reference = std::conditional_t<is_const,
-                                             typename xexpression_type::const_reference,
-                                             typename xexpression_type::reference>;
-        using pointer = std::conditional_t<is_const,
-                                           typename xexpression_type::const_pointer,
-                                           typename xexpression_type::pointer>;
+        using reference = std::
+            conditional_t<is_const, typename xexpression_type::const_reference, typename xexpression_type::reference>;
+        using pointer = std::
+            conditional_t<is_const, typename xexpression_type::const_pointer, typename xexpression_type::pointer>;
         using size_type = typename xexpression_type::size_type;
         using difference_type = typename xexpression_type::difference_type;
 
@@ -228,6 +223,22 @@ namespace xt
         static const bool value = true;
     };
 
+    template <class T, class R = T>
+    struct enable_indexed_stepper : std::enable_if<is_indexed_stepper<T>::value, R>
+    {
+    };
+
+    template <class T, class R = T>
+    using enable_indexed_stepper_t = typename enable_indexed_stepper<T, R>::type;
+
+    template <class T, class R = T>
+    struct disable_indexed_stepper : std::enable_if<!is_indexed_stepper<T>::value, R>
+    {
+    };
+
+    template <class T, class R = T>
+    using disable_indexed_stepper_t = typename disable_indexed_stepper<T, R>::type;
+
     /*************
      * xiterator *
      *************/
@@ -271,24 +282,25 @@ namespace xt
         struct LAYOUT_FORBIDEN_FOR_XITERATOR;
     }
 
-    template <class It, class S, layout_type L>
-    class xiterator : public xtl::xrandom_access_iterator_base<xiterator<It, S, L>,
-                                                               typename It::value_type,
-                                                               typename It::difference_type,
-                                                               typename It::pointer,
-                                                               typename It::reference>,
+    template <class St, class S, layout_type L>
+    class xiterator : public xtl::xrandom_access_iterator_base<
+                          xiterator<St, S, L>,
+                          typename St::value_type,
+                          typename St::difference_type,
+                          typename St::pointer,
+                          typename St::reference>,
                       private detail::shape_storage<S>
     {
     public:
 
-        using self_type = xiterator<It, S, L>;
+        using self_type = xiterator<St, S, L>;
 
-        using subiterator_type = It;
-        using value_type = typename subiterator_type::value_type;
-        using reference = typename subiterator_type::reference;
-        using pointer = typename subiterator_type::pointer;
-        using difference_type = typename subiterator_type::difference_type;
-        using size_type = typename subiterator_type::size_type;
+        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>;
@@ -297,8 +309,9 @@ namespace xt
         using index_type = xindex_type_t<shape_type>;
 
         xiterator() = default;
+
         // end_index means either reverse_iterator && !end or !reverse_iterator && end
-        xiterator(It it, shape_param_type shape, bool end_index);
+        xiterator(St st, shape_param_type shape, bool end_index);
 
         self_type& operator++();
         self_type& operator--();
@@ -316,31 +329,35 @@ namespace xt
 
     private:
 
-        subiterator_type m_it;
+        stepper_type m_st;
         index_type m_index;
         difference_type m_linear_index;
 
         using checking_type = typename detail::LAYOUT_FORBIDEN_FOR_XITERATOR<L>::type;
     };
 
-    template <class It, class S, layout_type L>
-    bool operator==(const xiterator<It, S, L>& lhs,
-                    const xiterator<It, S, L>& rhs);
+    template <class St, class S, layout_type L>
+    bool operator==(const xiterator<St, S, L>& lhs, const xiterator<St, S, L>& rhs);
+
+    template <class St, class S, layout_type L>
+    bool operator<(const xiterator<St, S, L>& lhs, const xiterator<St, S, L>& rhs);
 
-    template <class It, class S, layout_type L>
-    bool operator<(const xiterator<It, S, L>& lhs,
-                   const xiterator<It, S, L>& rhs);
+    template <class St, class S, layout_type L>
+    struct is_contiguous_container<xiterator<St, S, L>> : std::false_type
+    {
+    };
 
     /*********************
      * xbounded_iterator *
      *********************/
 
     template <class It, class BIt>
-    class xbounded_iterator : public xtl::xrandom_access_iterator_base<xbounded_iterator<It, BIt>,
-                                                                       typename std::iterator_traits<It>::value_type,
-                                                                       typename std::iterator_traits<It>::difference_type,
-                                                                       typename std::iterator_traits<It>::pointer,
-                                                                       typename std::iterator_traits<It>::reference>
+    class xbounded_iterator : public xtl::xrandom_access_iterator_base<
+                                  xbounded_iterator<It, BIt>,
+                                  typename std::iterator_traits<It>::value_type,
+                                  typename std::iterator_traits<It>::difference_type,
+                                  typename std::iterator_traits<It>::pointer,
+                                  typename std::iterator_traits<It>::reference>
     {
     public:
 
@@ -377,12 +394,10 @@ namespace xt
     };
 
     template <class It, class BIt>
-    bool operator==(const xbounded_iterator<It, BIt>& lhs,
-                    const xbounded_iterator<It, BIt>& rhs);
+    bool operator==(const xbounded_iterator<It, BIt>& lhs, const xbounded_iterator<It, BIt>& rhs);
 
     template <class It, class BIt>
-    bool operator<(const xbounded_iterator<It, BIt>& lhs,
-                   const xbounded_iterator<It, BIt>& rhs);
+    bool operator<(const xbounded_iterator<It, BIt>& lhs, const xbounded_iterator<It, BIt>& rhs);
 
     /*****************************
      * linear_begin / linear_end *
@@ -391,62 +406,65 @@ namespace xt
     namespace detail
     {
         template <class C, class = void_t<>>
-        struct has_storage_iterator : std::false_type
+        struct has_linear_iterator : std::false_type
         {
         };
 
         template <class C>
-        struct has_storage_iterator<C, void_t<decltype(std::declval<C>().storage_cbegin())>>
-            : std::true_type
+        struct has_linear_iterator<C, void_t<decltype(std::declval<C>().linear_cbegin())>> : std::true_type
         {
         };
+    }
 
-        template <class C>
-        XTENSOR_CONSTEXPR_RETURN auto linear_begin(C& c) noexcept
+    template <class C>
+    constexpr auto linear_begin(C& c) noexcept
+    {
+        if constexpr (detail::has_linear_iterator<C>::value)
         {
-            return xtl::mpl::static_if<has_storage_iterator<C>::value>([&](auto self)
-            {
-                return self(c).storage_begin();
-            }, /*else*/ [&](auto self)
-            {
-                return self(c).begin();
-            });
+            return c.linear_begin();
         }
+        else
+        {
+            return c.begin();
+        }
+    }
 
-        template <class C>
-        XTENSOR_CONSTEXPR_RETURN auto linear_end(C& c) noexcept
+    template <class C>
+    constexpr auto linear_end(C& c) noexcept
+    {
+        if constexpr (detail::has_linear_iterator<C>::value)
         {
-            return xtl::mpl::static_if<has_storage_iterator<C>::value>([&](auto self)
-            {
-                return self(c).storage_end();
-            }, /*else*/ [&](auto self)
-            {
-                return self(c).end();
-            });
+            return c.linear_end();
+        }
+        else
+        {
+            return c.end();
         }
+    }
 
-        template <class C>
-        XTENSOR_CONSTEXPR_RETURN auto linear_begin(const C& c) noexcept
+    template <class C>
+    constexpr auto linear_begin(const C& c) noexcept
+    {
+        if constexpr (detail::has_linear_iterator<C>::value)
         {
-            return xtl::mpl::static_if<has_storage_iterator<C>::value>([&](auto self)
-            {
-                return self(c).storage_cbegin();
-            }, /*else*/ [&](auto self)
-            {
-                return self(c).cbegin();
-            });
+            return c.linear_cbegin();
         }
+        else
+        {
+            return c.cbegin();
+        }
+    }
 
-        template <class C>
-        XTENSOR_CONSTEXPR_RETURN auto linear_end(const C& c) noexcept
+    template <class C>
+    constexpr auto linear_end(const C& c) noexcept
+    {
+        if constexpr (detail::has_linear_iterator<C>::value)
         {
-            return xtl::mpl::static_if<has_storage_iterator<C>::value>([&](auto self)
-            {
-                return self(c).storage_cend();
-            }, /*else*/ [&](auto self)
-            {
-                return self(c).cend();
-            });
+            return c.linear_cend();
+        }
+        else
+        {
+            return c.cend();
         }
     }
 
@@ -456,7 +474,9 @@ namespace xt
 
     template <class C>
     inline xstepper<C>::xstepper(storage_type* c, subiterator_type it, size_type offset) noexcept
-        : p_c(c), m_it(it), m_offset(offset)
+        : p_c(c)
+        , m_it(it)
+        , m_offset(offset)
     {
     }
 
@@ -471,7 +491,7 @@ namespace xt
     {
         if (dim >= m_offset)
         {
-            using strides_value_type = decltype(p_c->strides()[0]);
+            using strides_value_type = typename std::decay_t<decltype(p_c->strides())>::value_type;
             m_it += difference_type(static_cast<strides_value_type>(n) * p_c->strides()[dim - m_offset]);
         }
     }
@@ -481,7 +501,7 @@ namespace xt
     {
         if (dim >= m_offset)
         {
-            using strides_value_type = decltype(p_c->strides()[0]);
+            using strides_value_type = typename std::decay_t<decltype(p_c->strides())>::value_type;
             m_it -= difference_type(static_cast<strides_value_type>(n) * p_c->strides()[dim - m_offset]);
         }
     }
@@ -513,16 +533,41 @@ namespace xt
     template <class C>
     inline void xstepper<C>::to_end(layout_type l)
     {
-        m_it = p_c->data_xend(l);
+        m_it = p_c->data_xend(l, m_offset);
+    }
+
+    namespace detail
+    {
+        template <class It>
+        struct step_simd_invoker
+        {
+            template <class R>
+            static R apply(const It& it)
+            {
+                R reg;
+                return reg.load_unaligned(&(*it));
+                // return reg;
+            }
+        };
+
+        template <bool is_const, class T, class S, layout_type L>
+        struct step_simd_invoker<xiterator<xscalar_stepper<is_const, T>, S, L>>
+        {
+            template <class R>
+            static R apply(const xiterator<xscalar_stepper<is_const, T>, S, L>& it)
+            {
+                return R(*it);
+            }
+        };
     }
 
     template <class C>
-    template <class R>
-    inline R xstepper<C>::step_simd()
+    template <class T>
+    inline auto xstepper<C>::step_simd() -> simd_return_type<T>
     {
-        R reg;
-        reg.load_unaligned(&(*m_it));
-        m_it += xsimd::revert_simd_traits<R>::size;
+        using simd_type = simd_return_type<T>;
+        simd_type reg = detail::step_simd_invoker<subiterator_type>::template apply<simd_type>(m_it);
+        m_it += xt_simd::revert_simd_traits<simd_type>::size;
         return reg;
     }
 
@@ -531,24 +576,23 @@ namespace xt
     inline void xstepper<C>::store_simd(const R& vec)
     {
         vec.store_unaligned(&(*m_it));
-        m_it += xsimd::revert_simd_traits<R>::size;;
+        m_it += xt_simd::revert_simd_traits<R>::size;
+        ;
     }
 
     template <class C>
-    auto xstepper<C>::step_leading() -> value_type
+    void xstepper<C>::step_leading()
     {
         ++m_it;
-        return *m_it;
     }
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::row_major>::increment_stepper(S& stepper,
-                                                                  IT& index,
-                                                                  const ST& shape)
+    void stepper_tools<layout_type::row_major>::increment_stepper(S& stepper, IT& index, const ST& shape)
     {
         using size_type = typename S::size_type;
-        size_type i = index.size();
+        const size_type size = index.size();
+        size_type i = size;
         while (i != 0)
         {
             --i;
@@ -569,26 +613,41 @@ namespace xt
         }
         if (i == 0)
         {
-            std::copy(shape.cbegin(), shape.cend(), index.begin());
+            if (size != size_type(0))
+            {
+                std::transform(
+                    shape.cbegin(),
+                    shape.cend() - 1,
+                    index.begin(),
+                    [](const auto& v)
+                    {
+                        return v - 1;
+                    }
+                );
+                index[size - 1] = shape[size - 1];
+            }
             stepper.to_end(layout_type::row_major);
         }
     }
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::row_major>::increment_stepper(S& stepper,
-                                                                  IT& index,
-                                                                  const ST& shape,
-                                                                  typename S::size_type n)
+    void stepper_tools<layout_type::row_major>::increment_stepper(
+        S& stepper,
+        IT& index,
+        const ST& shape,
+        typename S::size_type n
+    )
     {
         using size_type = typename S::size_type;
-        size_type i = index.size();
-        size_type leading_i = index.size() - 1;
+        const size_type size = index.size();
+        const size_type leading_i = size - 1;
+        size_type i = size;
         while (i != 0 && n != 0)
         {
             --i;
             size_type inc = (i == leading_i) ? n : 1;
-            if (index[i] + inc < shape[i])
+            if (xtl::cmp_less(index[i] + inc, shape[i]))
             {
                 index[i] += inc;
                 stepper.step(i, inc);
@@ -613,18 +672,28 @@ namespace xt
                 }
             }
         }
-        if (i == 0)
+        if (i == 0 && n != 0)
         {
-            std::copy(shape.cbegin(), shape.cend(), index.begin());
+            if (size != size_type(0))
+            {
+                std::transform(
+                    shape.cbegin(),
+                    shape.cend() - 1,
+                    index.begin(),
+                    [](const auto& v)
+                    {
+                        return v - 1;
+                    }
+                );
+                index[leading_i] = shape[leading_i];
+            }
             stepper.to_end(layout_type::row_major);
         }
     }
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::row_major>::decrement_stepper(S& stepper,
-                                                                  IT& index,
-                                                                  const ST& shape)
+    void stepper_tools<layout_type::row_major>::decrement_stepper(S& stepper, IT& index, const ST& shape)
     {
         using size_type = typename S::size_type;
         size_type i = index.size();
@@ -654,10 +723,12 @@ namespace xt
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::row_major>::decrement_stepper(S& stepper,
-                                                                  IT& index,
-                                                                  const ST& shape,
-                                                                  typename S::size_type n)
+    void stepper_tools<layout_type::row_major>::decrement_stepper(
+        S& stepper,
+        IT& index,
+        const ST& shape,
+        typename S::size_type n
+    )
     {
         using size_type = typename S::size_type;
         size_type i = index.size();
@@ -666,7 +737,7 @@ namespace xt
         {
             --i;
             size_type inc = (i == leading_i) ? n : 1;
-            if (index[i] >= inc)
+            if (xtl::cmp_greater_equal(index[i], inc))
             {
                 index[i] -= inc;
                 stepper.step_back(i, inc);
@@ -691,7 +762,7 @@ namespace xt
                 }
             }
         }
-        if (i == 0)
+        if (i == 0 && n != 0)
         {
             stepper.to_begin();
         }
@@ -699,12 +770,10 @@ namespace xt
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::column_major>::increment_stepper(S& stepper,
-                                                                     IT& index,
-                                                                     const ST& shape)
+    void stepper_tools<layout_type::column_major>::increment_stepper(S& stepper, IT& index, const ST& shape)
     {
         using size_type = typename S::size_type;
-        size_type size = index.size();
+        const size_type size = index.size();
         size_type i = 0;
         while (i != size)
         {
@@ -726,22 +795,36 @@ namespace xt
         }
         if (i == size)
         {
-            std::copy(shape.cbegin(), shape.cend(), index.begin());
+            if (size != size_type(0))
+            {
+                std::transform(
+                    shape.cbegin() + 1,
+                    shape.cend(),
+                    index.begin() + 1,
+                    [](const auto& v)
+                    {
+                        return v - 1;
+                    }
+                );
+                index[0] = shape[0];
+            }
             stepper.to_end(layout_type::column_major);
         }
     }
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::column_major>::increment_stepper(S& stepper,
-                                                                     IT& index,
-                                                                     const ST& shape,
-                                                                     typename S::size_type n)
+    void stepper_tools<layout_type::column_major>::increment_stepper(
+        S& stepper,
+        IT& index,
+        const ST& shape,
+        typename S::size_type n
+    )
     {
         using size_type = typename S::size_type;
-        size_type size = index.size();
+        const size_type size = index.size();
+        const size_type leading_i = 0;
         size_type i = 0;
-        size_type leading_i = 0;
         while (i != size && n != 0)
         {
             size_type inc = (i == leading_i) ? n : 1;
@@ -750,7 +833,7 @@ namespace xt
                 index[i] += inc;
                 stepper.step(i, inc);
                 n -= inc;
-                if (i != leading_i || index.size() == 1)
+                if (i != leading_i || size == 1)
                 {
                     i = 0;
                     continue;
@@ -772,18 +855,28 @@ namespace xt
             }
             ++i;
         }
-        if (i == size)
+        if (i == size && n != 0)
         {
-            std::copy(shape.cbegin(), shape.cend(), index.begin());
+            if (size != size_type(0))
+            {
+                std::transform(
+                    shape.cbegin() + 1,
+                    shape.cend(),
+                    index.begin() + 1,
+                    [](const auto& v)
+                    {
+                        return v - 1;
+                    }
+                );
+                index[leading_i] = shape[leading_i];
+            }
             stepper.to_end(layout_type::column_major);
         }
     }
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::column_major>::decrement_stepper(S& stepper,
-                                                                     IT& index,
-                                                                     const ST& shape)
+    void stepper_tools<layout_type::column_major>::decrement_stepper(S& stepper, IT& index, const ST& shape)
     {
         using size_type = typename S::size_type;
         size_type size = index.size();
@@ -814,10 +907,12 @@ namespace xt
 
     template <>
     template <class S, class IT, class ST>
-    void stepper_tools<layout_type::column_major>::decrement_stepper(S& stepper,
-                                                                     IT& index,
-                                                                     const ST& shape,
-                                                                     typename S::size_type n)
+    void stepper_tools<layout_type::column_major>::decrement_stepper(
+        S& stepper,
+        IT& index,
+        const ST& shape,
+        typename S::size_type n
+    )
     {
         using size_type = typename S::size_type;
         size_type size = index.size();
@@ -853,7 +948,7 @@ namespace xt
             }
             ++i;
         }
-        if (i == size)
+        if (i == size && n != 0)
         {
             stepper.to_begin();
         }
@@ -865,12 +960,14 @@ namespace xt
 
     template <class C, bool is_const>
     inline xindexed_stepper<C, is_const>::xindexed_stepper(xexpression_type* e, size_type offset, bool end) noexcept
-        : p_e(e), m_index(xtl::make_sequence<index_type>(e->shape().size(), size_type(0))), m_offset(offset)
+        : p_e(e)
+        , m_index(xtl::make_sequence<index_type>(e->shape().size(), size_type(0)))
+        , m_offset(offset)
     {
         if (end)
         {
-            // Note: the layout here doesn't matter (unused) but using default layout looks more "correct"
-            to_end(XTENSOR_DEFAULT_LAYOUT);
+            // Note: the layout here doesn't matter (unused) but using default traversal looks more "correct".
+            to_end(XTENSOR_DEFAULT_TRAVERSAL);
         }
     }
 
@@ -923,9 +1020,21 @@ namespace xt
     }
 
     template <class C, bool is_const>
-    inline void xindexed_stepper<C, is_const>::to_end(layout_type)
+    inline void xindexed_stepper<C, is_const>::to_end(layout_type l)
     {
-        std::copy(p_e->shape().begin(), p_e->shape().end(), m_index.begin());
+        const auto& shape = p_e->shape();
+        std::transform(
+            shape.cbegin(),
+            shape.cend(),
+            m_index.begin(),
+            [](const auto& v)
+            {
+                return v - 1;
+            }
+        );
+
+        size_type l_dim = (l == layout_type::row_major) ? shape.size() - 1 : 0;
+        m_index[l_dim] = shape[l_dim];
     }
 
     /****************************
@@ -971,12 +1080,15 @@ namespace xt
         };
     }
 
-    template <class It, class S, layout_type L>
-    inline xiterator<It, S, L>::xiterator(It it, shape_param_type shape, bool end_index)
-        : private_base(shape), m_it(it),
-          m_index(end_index ? xtl::forward_sequence<index_type, const shape_type&>(this->shape())
-                            : xtl::make_sequence<index_type>(this->shape().size(), size_type(0))),
-          m_linear_index(0)
+    template <class St, class S, layout_type L>
+    inline xiterator<St, S, L>::xiterator(St st, shape_param_type shape, bool end_index)
+        : private_base(shape)
+        , m_st(st)
+        , m_index(
+              end_index ? xtl::forward_sequence<index_type, const shape_type&>(this->shape())
+                        : xtl::make_sequence<index_type>(this->shape().size(), size_type(0))
+          )
+        , m_linear_index(0)
     {
         // end_index means either reverse_iterator && !end or !reverse_iterator && end
         if (end_index)
@@ -985,101 +1097,111 @@ namespace xt
             {
                 auto iter_begin = (L == layout_type::row_major) ? m_index.begin() : m_index.begin() + 1;
                 auto iter_end = (L == layout_type::row_major) ? m_index.end() - 1 : m_index.end();
-                std::transform(iter_begin, iter_end, iter_begin, [](const auto& v) { return v - 1; });
+                std::transform(
+                    iter_begin,
+                    iter_end,
+                    iter_begin,
+                    [](const auto& v)
+                    {
+                        return v - 1;
+                    }
+                );
             }
-            m_linear_index = difference_type(std::accumulate(this->shape().cbegin(), this->shape().cend(),
-                                                             size_type(1), std::multiplies<size_type>()));
+            m_linear_index = difference_type(std::accumulate(
+                this->shape().cbegin(),
+                this->shape().cend(),
+                size_type(1),
+                std::multiplies<size_type>()
+            ));
         }
     }
 
-    template <class It, class S, layout_type L>
-    inline auto xiterator<It, S, L>::operator++() -> self_type&
+    template <class St, class S, layout_type L>
+    inline auto xiterator<St, S, L>::operator++() -> self_type&
     {
-        stepper_tools<L>::increment_stepper(m_it, m_index, this->shape());
+        stepper_tools<L>::increment_stepper(m_st, m_index, this->shape());
         ++m_linear_index;
         return *this;
     }
 
-    template <class It, class S, layout_type L>
-    inline auto xiterator<It, S, L>::operator--() -> self_type&
+    template <class St, class S, layout_type L>
+    inline auto xiterator<St, S, L>::operator--() -> self_type&
     {
-        stepper_tools<L>::decrement_stepper(m_it, m_index, this->shape());
+        stepper_tools<L>::decrement_stepper(m_st, m_index, this->shape());
         --m_linear_index;
         return *this;
     }
 
-    template <class It, class S, layout_type L>
-    inline auto xiterator<It, S, L>::operator+=(difference_type n) -> self_type&
+    template <class St, class S, layout_type L>
+    inline auto xiterator<St, S, L>::operator+=(difference_type n) -> self_type&
     {
         if (n >= 0)
         {
-            stepper_tools<L>::increment_stepper(m_it, m_index, this->shape(), static_cast<size_type>(n));
+            stepper_tools<L>::increment_stepper(m_st, m_index, this->shape(), static_cast<size_type>(n));
         }
         else
         {
-            stepper_tools<L>::decrement_stepper(m_it, m_index, this->shape(), static_cast<size_type>(-n));
+            stepper_tools<L>::decrement_stepper(m_st, m_index, this->shape(), static_cast<size_type>(-n));
         }
         m_linear_index += n;
         return *this;
     }
 
-    template <class It, class S, layout_type L>
-    inline auto xiterator<It, S, L>::operator-=(difference_type n) -> self_type&
+    template <class St, class S, layout_type L>
+    inline auto xiterator<St, S, L>::operator-=(difference_type n) -> self_type&
     {
         if (n >= 0)
         {
-            stepper_tools<L>::decrement_stepper(m_it, m_index, this->shape(), static_cast<size_type>(n));
+            stepper_tools<L>::decrement_stepper(m_st, m_index, this->shape(), static_cast<size_type>(n));
         }
         else
         {
-            stepper_tools<L>::increment_stepper(m_it, m_index, this->shape(), static_cast<size_type>(-n));
+            stepper_tools<L>::increment_stepper(m_st, m_index, this->shape(), static_cast<size_type>(-n));
         }
         m_linear_index -= n;
         return *this;
     }
 
-    template <class It, class S, layout_type L>
-    inline auto xiterator<It, S, L>::operator-(const self_type& rhs) const -> difference_type
+    template <class St, class S, layout_type L>
+    inline auto xiterator<St, S, L>::operator-(const self_type& rhs) const -> difference_type
     {
         return m_linear_index - rhs.m_linear_index;
     }
 
-    template <class It, class S, layout_type L>
-    inline auto xiterator<It, S, L>::operator*() const -> reference
+    template <class St, class S, layout_type L>
+    inline auto xiterator<St, S, L>::operator*() const -> reference
     {
-        return *m_it;
+        return *m_st;
     }
 
-    template <class It, class S, layout_type L>
-    inline auto xiterator<It, S, L>::operator->() const -> pointer
+    template <class St, class S, layout_type L>
+    inline auto xiterator<St, S, L>::operator->() const -> pointer
     {
-        return &(*m_it);
+        return &(*m_st);
     }
 
-    template <class It, class S, layout_type L>
-    inline bool xiterator<It, S, L>::equal(const xiterator& rhs) const
+    template <class St, class S, layout_type L>
+    inline bool xiterator<St, S, L>::equal(const xiterator& rhs) const
     {
         XTENSOR_ASSERT(this->shape() == rhs.shape());
         return m_linear_index == rhs.m_linear_index;
     }
 
-    template <class It, class S, layout_type L>
-    inline bool xiterator<It, S, L>::less_than(const xiterator& rhs) const
+    template <class St, class S, layout_type L>
+    inline bool xiterator<St, S, L>::less_than(const xiterator& rhs) const
     {
         XTENSOR_ASSERT(this->shape() == rhs.shape());
         return m_linear_index < rhs.m_linear_index;
     }
 
-    template <class It, class S, layout_type L>
-    inline bool operator==(const xiterator<It, S, L>& lhs,
-                           const xiterator<It, S, L>& rhs)
+    template <class St, class S, layout_type L>
+    inline bool operator==(const xiterator<St, S, L>& lhs, const xiterator<St, S, L>& rhs)
     {
         return lhs.equal(rhs);
     }
 
-    template <class It, class S, layout_type L>
-    bool operator<(const xiterator<It, S, L>& lhs,
-                   const xiterator<It, S, L>& rhs)
+    template <class St, class S, layout_type L>
+    bool operator<(const xiterator<St, S, L>& lhs, const xiterator<St, S, L>& rhs)
     {
         return lhs.less_than(rhs);
     }
@@ -1090,7 +1212,8 @@ namespace xt
 
     template <class It, class BIt>
     xbounded_iterator<It, BIt>::xbounded_iterator(It it, BIt bound_it)
-        : m_it(it), m_bound_it(bound_it)
+        : m_it(it)
+        , m_bound_it(bound_it)
     {
     }
 
@@ -1152,15 +1275,13 @@ namespace xt
     }
 
     template <class It, class BIt>
-    inline bool operator==(const xbounded_iterator<It, BIt>& lhs,
-                           const xbounded_iterator<It, BIt>& rhs)
+    inline bool operator==(const xbounded_iterator<It, BIt>& lhs, const xbounded_iterator<It, BIt>& rhs)
     {
         return lhs.equal(rhs);
     }
 
     template <class It, class BIt>
-    inline bool operator<(const xbounded_iterator<It, BIt>& lhs,
-                          const xbounded_iterator<It, BIt>& rhs)
+    inline bool operator<(const xbounded_iterator<It, BIt>& lhs, const xbounded_iterator<It, BIt>& rhs)
     {
         return lhs.less_than(rhs);
     }
diff --git a/include/xtensor/xlayout.hpp b/include/xtensor/core/xlayout.hpp
similarity index 59%
rename from include/xtensor/xlayout.hpp
rename to include/xtensor/core/xlayout.hpp
index 302348ed4..f3330f427 100644
--- a/include/xtensor/xlayout.hpp
+++ b/include/xtensor/core/xlayout.hpp
@@ -1,16 +1,21 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_LAYOUT_HPP
 #define XTENSOR_LAYOUT_HPP
 
-#include "xtensor_config.hpp"
-#include "xshape.hpp"
+#include <type_traits>
+
+// Do not include anything else here.
+// xlayout.hpp is included in xtensor_forward.hpp
+// and we don't want to bring other headers to it.
+#include "../core/xtensor_config.hpp"
 
 namespace xt
 {
@@ -30,15 +35,14 @@ namespace xt
     /**
      * Implementation of the following logical table:
      *
-     * @verbatim
-         | d | a | r | c |
-       --+---+---+---+---+
-       d | d | d | d | d |
-       a | d | a | r | c |
-       r | d | r | r | d |
-       c | d | c | d | c |
-       d = dynamic, a = any, r = row_major, c = column_major.
-       @endverbatim
+     *        | d | a | r | c |
+     *      --+---+---+---+---+
+     *      d | d | d | d | d |
+     *      a | d | a | r | c |
+     *      r | d | r | r | d |
+     *      c | d | c | d | c |
+     *      d = dynamic, a = any, r = row_major, c = column_major.
+     *
      * Using bitmasks to avoid nested if-else statements.
      *
      * @param args the input layouts.
@@ -49,20 +53,7 @@ namespace xt
 
     constexpr layout_type default_assignable_layout(layout_type l) noexcept;
 
-    /**
-     * Compute a layout based on a layout and a shape type.
-     *
-     * The main functionality of this function is that it reduces vectors to
-     * ``layout_type::any`` so that assigning a row major 1D container to another
-     * row_major container becomes free.
-     */
-    template <layout_type L, class S>
-    struct select_layout
-    {
-        constexpr static std::ptrdiff_t static_dimension = xt::static_dimension<S>::value;
-        constexpr static bool is_any = static_dimension != -1 && static_dimension <= 1 && L != layout_type::dynamic;
-        constexpr static layout_type value = is_any ? layout_type::any : L;
-    };
+    constexpr layout_type layout_remove_any(const layout_type layout) noexcept;
 
     /******************
      * Implementation *
@@ -101,8 +92,12 @@ namespace xt
 
     constexpr layout_type default_assignable_layout(layout_type l) noexcept
     {
-        return (l == layout_type::row_major || l == layout_type::column_major) ?
-            l : XTENSOR_DEFAULT_LAYOUT;
+        return (l == layout_type::row_major || l == layout_type::column_major) ? l : XTENSOR_DEFAULT_LAYOUT;
+    }
+
+    constexpr layout_type layout_remove_any(const layout_type layout) noexcept
+    {
+        return layout == layout_type::any ? XTENSOR_DEFAULT_LAYOUT : layout;
     }
 }
 
diff --git a/include/xtensor/core/xmath.hpp b/include/xtensor/core/xmath.hpp
new file mode 100644
index 000000000..6b86c4b74
--- /dev/null
+++ b/include/xtensor/core/xmath.hpp
@@ -0,0 +1,3292 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+/**
+ * @brief standard mathematical functions for xexpressions
+ */
+
+#ifndef XTENSOR_MATH_HPP
+#define XTENSOR_MATH_HPP
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <complex>
+#include <type_traits>
+
+#include <xtl/xcomplex.hpp>
+#include <xtl/xsequence.hpp>
+#include <xtl/xtype_traits.hpp>
+
+#include "../core/xeval.hpp"
+#include "../core/xoperation.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../misc/xmanipulation.hpp"
+#include "../reducers/xaccumulator.hpp"
+#include "../reducers/xreducer.hpp"
+#include "../views/xslice.hpp"
+#include "../views/xstrided_view.hpp"
+
+namespace xt
+{
+    template <class T = double>
+    struct numeric_constants
+    {
+        static constexpr T PI = 3.141592653589793238463;
+        static constexpr T PI_2 = 1.57079632679489661923;
+        static constexpr T PI_4 = 0.785398163397448309616;
+        static constexpr T D_1_PI = 0.318309886183790671538;
+        static constexpr T D_2_PI = 0.636619772367581343076;
+        static constexpr T D_2_SQRTPI = 1.12837916709551257390;
+        static constexpr T SQRT2 = 1.41421356237309504880;
+        static constexpr T SQRT1_2 = 0.707106781186547524401;
+        static constexpr T E = 2.71828182845904523536;
+        static constexpr T LOG2E = 1.44269504088896340736;
+        static constexpr T LOG10E = 0.434294481903251827651;
+        static constexpr T LN2 = 0.693147180559945309417;
+    };
+
+    /***********
+     * Helpers *
+     ***********/
+
+#define XTENSOR_UNSIGNED_ABS_FUNC(T)   \
+    constexpr inline T abs(const T& x) \
+    {                                  \
+        return x;                      \
+    }
+
+#define XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, T) \
+    constexpr inline bool FUNC_NAME(const T& /*x*/) noexcept      \
+    {                                                             \
+        return RETURN_VAL;                                        \
+    }
+
+#define XTENSOR_INT_SPECIALIZATION(FUNC_NAME, RETURN_VAL)                   \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, char);           \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, short);          \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, int);            \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, long);           \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, long long);      \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned char);  \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned short); \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned int);   \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned long);  \
+    XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned long long);
+
+
+#define XTENSOR_UNARY_MATH_FUNCTOR(NAME)              \
+    struct NAME##_fun                                 \
+    {                                                 \
+        template <class T>                            \
+        constexpr auto operator()(const T& arg) const \
+        {                                             \
+            using math::NAME;                         \
+            return NAME(arg);                         \
+        }                                             \
+        template <class B>                            \
+        constexpr auto simd_apply(const B& arg) const \
+        {                                             \
+            using math::NAME;                         \
+            return NAME(arg);                         \
+        }                                             \
+    }
+
+#define XTENSOR_UNARY_MATH_FUNCTOR_COMPLEX_REDUCING(NAME) \
+    struct NAME##_fun                                     \
+    {                                                     \
+        template <class T>                                \
+        constexpr auto operator()(const T& arg) const     \
+        {                                                 \
+            using math::NAME;                             \
+            return NAME(arg);                             \
+        }                                                 \
+        template <class B>                                \
+        constexpr auto simd_apply(const B& arg) const     \
+        {                                                 \
+            using math::NAME;                             \
+            return NAME(arg);                             \
+        }                                                 \
+    }
+
+#define XTENSOR_BINARY_MATH_FUNCTOR(NAME)                               \
+    struct NAME##_fun                                                   \
+    {                                                                   \
+        template <class T1, class T2>                                   \
+        constexpr auto operator()(const T1& arg1, const T2& arg2) const \
+        {                                                               \
+            using math::NAME;                                           \
+            return NAME(arg1, arg2);                                    \
+        }                                                               \
+        template <class B>                                              \
+        constexpr auto simd_apply(const B& arg1, const B& arg2) const   \
+        {                                                               \
+            using math::NAME;                                           \
+            return NAME(arg1, arg2);                                    \
+        }                                                               \
+    }
+
+#define XTENSOR_TERNARY_MATH_FUNCTOR(NAME)                                              \
+    struct NAME##_fun                                                                   \
+    {                                                                                   \
+        template <class T1, class T2, class T3>                                         \
+        constexpr auto operator()(const T1& arg1, const T2& arg2, const T3& arg3) const \
+        {                                                                               \
+            using math::NAME;                                                           \
+            return NAME(arg1, arg2, arg3);                                              \
+        }                                                                               \
+        template <class B>                                                              \
+        auto simd_apply(const B& arg1, const B& arg2, const B& arg3) const              \
+        {                                                                               \
+            using math::NAME;                                                           \
+            return NAME(arg1, arg2, arg3);                                              \
+        }                                                                               \
+    }
+
+    namespace math
+    {
+        using std::abs;
+        using std::fabs;
+
+        using std::acos;
+        using std::asin;
+        using std::atan;
+        using std::cos;
+        using std::sin;
+        using std::tan;
+
+        using std::acosh;
+        using std::asinh;
+        using std::atanh;
+        using std::cosh;
+        using std::sinh;
+        using std::tanh;
+
+        using std::cbrt;
+        using std::sqrt;
+
+        using std::exp;
+        using std::exp2;
+        using std::expm1;
+        using std::ilogb;
+        using std::log;
+        using std::log10;
+        using std::log1p;
+        using std::log2;
+        using std::logb;
+
+        using std::ceil;
+        using std::floor;
+        using std::llround;
+        using std::lround;
+        using std::nearbyint;
+        using std::remainder;
+        using std::rint;
+        using std::round;
+        using std::trunc;
+
+        using std::erf;
+        using std::erfc;
+        using std::lgamma;
+        using std::tgamma;
+
+        using std::arg;
+        using std::conj;
+        using std::imag;
+        using std::real;
+
+        using std::atan2;
+
+// copysign is not in the std namespace for MSVC
+#if !defined(_MSC_VER)
+        using std::copysign;
+#endif
+        using std::fdim;
+        using std::fmax;
+        using std::fmin;
+        using std::fmod;
+        using std::hypot;
+        using std::pow;
+
+        using std::fma;
+        using std::fpclassify;
+
+        // Overload isinf, isnan and isfinite because glibc implementation
+        // might return int instead of bool and the SIMD detection requires
+        // bool return type.
+        template <class T>
+        inline std::enable_if_t<xtl::is_arithmetic<T>::value, bool> isinf(const T& t)
+        {
+            return bool(std::isinf(t));
+        }
+
+        template <class T>
+        inline std::enable_if_t<xtl::is_arithmetic<T>::value, bool> isnan(const T& t)
+        {
+            return bool(std::isnan(t));
+        }
+
+        template <class T>
+        inline std::enable_if_t<xtl::is_arithmetic<T>::value, bool> isfinite(const T& t)
+        {
+            return bool(std::isfinite(t));
+        }
+
+        // Overload isinf, isnan and isfinite for complex datatypes,
+        // following the Python specification:
+        template <class T>
+        inline bool isinf(const std::complex<T>& c)
+        {
+            return std::isinf(std::real(c)) || std::isinf(std::imag(c));
+        }
+
+        template <class T>
+        inline bool isnan(const std::complex<T>& c)
+        {
+            return std::isnan(std::real(c)) || std::isnan(std::imag(c));
+        }
+
+        template <class T>
+        inline bool isfinite(const std::complex<T>& c)
+        {
+            return !isinf(c) && !isnan(c);
+        }
+
+        // VS2015 STL defines isnan, isinf and isfinite as template
+        // functions, breaking ADL.
+#if defined(_WIN32) && defined(XTENSOR_USE_XSIMD)
+        /*template <class T, class A>
+        inline xsimd::batch_bool<T, A> isinf(const xsimd::batch<T, A>& b)
+        {
+            return xsimd::isinf(b);
+        }
+        template <class T, class A>
+        inline xsimd::batch_bool<T, A> isnan(const xsimd::batch<T, A>& b)
+        {
+            return xsimd::isnan(b);
+        }
+        template <class T, class A>
+        inline xsimd::batch_bool<T, A> isfinite(const xsimd::batch<T, A>& b)
+        {
+            return xsimd::isfinite(b);
+        }*/
+#endif
+        // The following specializations are needed to avoid 'ambiguous overload' errors,
+        // whereas 'unsigned char' and 'unsigned short' are automatically converted to 'int'.
+        // we're still adding those functions to silence warnings
+        XTENSOR_UNSIGNED_ABS_FUNC(unsigned char)
+        XTENSOR_UNSIGNED_ABS_FUNC(unsigned short)
+        XTENSOR_UNSIGNED_ABS_FUNC(unsigned int)
+        XTENSOR_UNSIGNED_ABS_FUNC(unsigned long)
+        XTENSOR_UNSIGNED_ABS_FUNC(unsigned long long)
+
+#ifdef _WIN32
+        XTENSOR_INT_SPECIALIZATION(isinf, false);
+        XTENSOR_INT_SPECIALIZATION(isnan, false);
+        XTENSOR_INT_SPECIALIZATION(isfinite, true);
+#endif
+
+        XTENSOR_UNARY_MATH_FUNCTOR_COMPLEX_REDUCING(abs);
+
+        XTENSOR_UNARY_MATH_FUNCTOR(fabs);
+        XTENSOR_BINARY_MATH_FUNCTOR(fmod);
+        XTENSOR_BINARY_MATH_FUNCTOR(remainder);
+        XTENSOR_TERNARY_MATH_FUNCTOR(fma);
+        XTENSOR_BINARY_MATH_FUNCTOR(fmax);
+        XTENSOR_BINARY_MATH_FUNCTOR(fmin);
+        XTENSOR_BINARY_MATH_FUNCTOR(fdim);
+        XTENSOR_UNARY_MATH_FUNCTOR(exp);
+        XTENSOR_UNARY_MATH_FUNCTOR(exp2);
+        XTENSOR_UNARY_MATH_FUNCTOR(expm1);
+        XTENSOR_UNARY_MATH_FUNCTOR(log);
+        XTENSOR_UNARY_MATH_FUNCTOR(log10);
+        XTENSOR_UNARY_MATH_FUNCTOR(log2);
+        XTENSOR_UNARY_MATH_FUNCTOR(log1p);
+        XTENSOR_BINARY_MATH_FUNCTOR(pow);
+        XTENSOR_UNARY_MATH_FUNCTOR(sqrt);
+        XTENSOR_UNARY_MATH_FUNCTOR(cbrt);
+        XTENSOR_BINARY_MATH_FUNCTOR(hypot);
+        XTENSOR_UNARY_MATH_FUNCTOR(sin);
+        XTENSOR_UNARY_MATH_FUNCTOR(cos);
+        XTENSOR_UNARY_MATH_FUNCTOR(tan);
+        XTENSOR_UNARY_MATH_FUNCTOR(asin);
+        XTENSOR_UNARY_MATH_FUNCTOR(acos);
+        XTENSOR_UNARY_MATH_FUNCTOR(atan);
+        XTENSOR_BINARY_MATH_FUNCTOR(atan2);
+        XTENSOR_UNARY_MATH_FUNCTOR(sinh);
+        XTENSOR_UNARY_MATH_FUNCTOR(cosh);
+        XTENSOR_UNARY_MATH_FUNCTOR(tanh);
+        XTENSOR_UNARY_MATH_FUNCTOR(asinh);
+        XTENSOR_UNARY_MATH_FUNCTOR(acosh);
+        XTENSOR_UNARY_MATH_FUNCTOR(atanh);
+        XTENSOR_UNARY_MATH_FUNCTOR(erf);
+        XTENSOR_UNARY_MATH_FUNCTOR(erfc);
+        XTENSOR_UNARY_MATH_FUNCTOR(tgamma);
+        XTENSOR_UNARY_MATH_FUNCTOR(lgamma);
+        XTENSOR_UNARY_MATH_FUNCTOR(ceil);
+        XTENSOR_UNARY_MATH_FUNCTOR(floor);
+        XTENSOR_UNARY_MATH_FUNCTOR(trunc);
+        XTENSOR_UNARY_MATH_FUNCTOR(round);
+        XTENSOR_UNARY_MATH_FUNCTOR(nearbyint);
+        XTENSOR_UNARY_MATH_FUNCTOR(rint);
+        XTENSOR_UNARY_MATH_FUNCTOR(isfinite);
+        XTENSOR_UNARY_MATH_FUNCTOR(isinf);
+        XTENSOR_UNARY_MATH_FUNCTOR(isnan);
+        XTENSOR_UNARY_MATH_FUNCTOR(conj);
+    }
+
+#undef XTENSOR_UNARY_MATH_FUNCTOR
+#undef XTENSOR_BINARY_MATH_FUNCTOR
+#undef XTENSOR_TERNARY_MATH_FUNCTOR
+#undef XTENSOR_UNARY_MATH_FUNCTOR_COMPLEX_REDUCING
+#undef XTENSOR_UNSIGNED_ABS_FUNC
+
+    namespace detail
+    {
+        template <class R, class T>
+        std::enable_if_t<!iterable_expression<R>, R> fill_init(T init)
+        {
+            return R(init);
+        }
+
+        template <class R, class T>
+        std::enable_if_t<iterable_expression<R>, R> fill_init(T init)
+        {
+            R result;
+            std::fill(std::begin(result), std::end(result), init);
+            return result;
+        }
+    }
+
+#define XTENSOR_REDUCER_FUNCTION(NAME, FUNCTOR, INIT_VALUE_TYPE, INIT)                                               \
+    template <                                                                                                       \
+        class T = void,                                                                                              \
+        class E,                                                                                                     \
+        class X,                                                                                                     \
+        class EVS = DEFAULT_STRATEGY_REDUCERS,                                                                       \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)>        \
+    inline auto NAME(E&& e, X&& axes, EVS es = EVS())                                                                \
+    {                                                                                                                \
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, INIT_VALUE_TYPE, T>;                \
+        using functor_type = FUNCTOR;                                                                                \
+        using init_value_fct = xt::const_value<init_value_type>;                                                     \
+        return xt::reduce(                                                                                           \
+            make_xreducer_functor(functor_type(), init_value_fct(detail::fill_init<init_value_type>(INIT))),         \
+            std::forward<E>(e),                                                                                      \
+            std::forward<X>(axes),                                                                                   \
+            es                                                                                                       \
+        );                                                                                                           \
+    }                                                                                                                \
+                                                                                                                     \
+    template <                                                                                                       \
+        class T = void,                                                                                              \
+        class E,                                                                                                     \
+        class X,                                                                                                     \
+        class EVS = DEFAULT_STRATEGY_REDUCERS,                                                                       \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<std::decay_t<X>>)>                       \
+    inline auto NAME(E&& e, X axis, EVS es = EVS())                                                                  \
+    {                                                                                                                \
+        return NAME(std::forward<E>(e), {axis}, es);                                                                 \
+    }                                                                                                                \
+                                                                                                                     \
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)> \
+    inline auto NAME(E&& e, EVS es = EVS())                                                                          \
+    {                                                                                                                \
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, INIT_VALUE_TYPE, T>;                \
+        using functor_type = FUNCTOR;                                                                                \
+        using init_value_fct = xt::const_value<init_value_type>;                                                     \
+        return xt::reduce(                                                                                           \
+            make_xreducer_functor(functor_type(), init_value_fct(detail::fill_init<init_value_type>(INIT))),         \
+            std::forward<E>(e),                                                                                      \
+            es                                                                                                       \
+        );                                                                                                           \
+    }                                                                                                                \
+                                                                                                                     \
+    template <class T = void, class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>                \
+    inline auto NAME(E&& e, const I(&axes)[N], EVS es = EVS())                                                       \
+    {                                                                                                                \
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, INIT_VALUE_TYPE, T>;                \
+        using functor_type = FUNCTOR;                                                                                \
+        using init_value_fct = xt::const_value<init_value_type>;                                                     \
+        return xt::reduce(                                                                                           \
+            make_xreducer_functor(functor_type(), init_value_fct(detail::fill_init<init_value_type>(INIT))),         \
+            std::forward<E>(e),                                                                                      \
+            axes,                                                                                                    \
+            es                                                                                                       \
+        );                                                                                                           \
+    }
+
+    /*******************
+     * basic functions *
+     *******************/
+
+    /**
+     * @defgroup basic_functions Basic functions
+     */
+
+    /**
+     * @ingroup basic_functions
+     * @brief Absolute value function.
+     *
+     * Returns an \ref xfunction for the element-wise absolute value
+     * of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto abs(E&& e) noexcept -> detail::xfunction_type_t<math::abs_fun, E>
+    {
+        return detail::make_xfunction<math::abs_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Absolute value function.
+     *
+     * Returns an \ref xfunction for the element-wise absolute value
+     * of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto fabs(E&& e) noexcept -> detail::xfunction_type_t<math::fabs_fun, E>
+    {
+        return detail::make_xfunction<math::fabs_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Remainder of the floating point division operation.
+     *
+     * Returns an \ref xfunction for the element-wise remainder of
+     * the floating point division operation <em>e1 / e2</em>.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto fmod(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::fmod_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::fmod_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Signed remainder of the division operation.
+     *
+     * Returns an \ref xfunction for the element-wise signed remainder
+     * of the floating point division operation <em>e1 / e2</em>.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto remainder(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::remainder_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::remainder_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Fused multiply-add operation.
+     *
+     * Returns an \ref xfunction for <em>e1 * e2 + e3</em> as if
+     * to infinite precision and rounded only once to fit the result type.
+     * @param e1 an \ref xfunction or a scalar
+     * @param e2 an \ref xfunction or a scalar
+     * @param e3 an \ref xfunction or a scalar
+     * @return an \ref xfunction
+     * @note e1, e2 and e3 can't be scalars every three.
+     */
+    template <class E1, class E2, class E3>
+    inline auto fma(E1&& e1, E2&& e2, E3&& e3) noexcept -> detail::xfunction_type_t<math::fma_fun, E1, E2, E3>
+    {
+        return detail::make_xfunction<math::fma_fun>(
+            std::forward<E1>(e1),
+            std::forward<E2>(e2),
+            std::forward<E3>(e3)
+        );
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Maximum function.
+     *
+     * Returns an \ref xfunction for the element-wise maximum
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto fmax(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::fmax_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::fmax_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Minimum function.
+     *
+     * Returns an \ref xfunction for the element-wise minimum
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto fmin(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::fmin_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::fmin_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Positive difference function.
+     *
+     * Returns an \ref xfunction for the element-wise positive
+     * difference of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto fdim(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::fdim_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::fdim_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    namespace math
+    {
+        template <class T = void>
+        struct minimum
+        {
+            template <class A1, class A2>
+            constexpr auto operator()(const A1& t1, const A2& t2) const noexcept
+            {
+                return xtl::select(t1 < t2, t1, t2);
+            }
+
+            template <class A1, class A2>
+            constexpr auto simd_apply(const A1& t1, const A2& t2) const noexcept
+            {
+                return xt_simd::select(t1 < t2, t1, t2);
+            }
+        };
+
+        template <class T = void>
+        struct maximum
+        {
+            template <class A1, class A2>
+            constexpr auto operator()(const A1& t1, const A2& t2) const noexcept
+            {
+                return xtl::select(t1 > t2, t1, t2);
+            }
+
+            template <class A1, class A2>
+            constexpr auto simd_apply(const A1& t1, const A2& t2) const noexcept
+            {
+                return xt_simd::select(t1 > t2, t1, t2);
+            }
+        };
+
+        struct clamp_fun
+        {
+            template <class A1, class A2, class A3>
+            constexpr auto operator()(const A1& v, const A2& lo, const A3& hi) const
+            {
+                return xtl::select(lo < hi, xtl::select(v < lo, lo, xtl::select(hi < v, hi, v)), hi);
+            }
+
+            template <class A1, class A2, class A3>
+            constexpr auto simd_apply(const A1& v, const A2& lo, const A3& hi) const
+            {
+                return xt_simd::select(lo < hi, xt_simd::select(v < lo, lo, xt_simd::select(hi < v, hi, v)), hi);
+            }
+        };
+
+        struct deg2rad
+        {
+            template <class A, std::enable_if_t<xtl::is_integral<A>::value, int> = 0>
+            constexpr double operator()(const A& a) const noexcept
+            {
+                return a * xt::numeric_constants<double>::PI / 180.0;
+            }
+
+            template <class A, std::enable_if_t<std::is_floating_point<A>::value, int> = 0>
+            constexpr auto operator()(const A& a) const noexcept
+            {
+                return a * xt::numeric_constants<A>::PI / A(180.0);
+            }
+
+            template <class A, std::enable_if_t<xtl::is_integral<A>::value, int> = 0>
+            constexpr double simd_apply(const A& a) const noexcept
+            {
+                return a * xt::numeric_constants<double>::PI / 180.0;
+            }
+
+            template <class A, std::enable_if_t<std::is_floating_point<A>::value, int> = 0>
+            constexpr auto simd_apply(const A& a) const noexcept
+            {
+                return a * xt::numeric_constants<A>::PI / A(180.0);
+            }
+        };
+
+        struct rad2deg
+        {
+            template <class A, std::enable_if_t<xtl::is_integral<A>::value, int> = 0>
+            constexpr double operator()(const A& a) const noexcept
+            {
+                return a * 180.0 / xt::numeric_constants<double>::PI;
+            }
+
+            template <class A, std::enable_if_t<std::is_floating_point<A>::value, int> = 0>
+            constexpr auto operator()(const A& a) const noexcept
+            {
+                return a * A(180.0) / xt::numeric_constants<A>::PI;
+            }
+
+            template <class A, std::enable_if_t<xtl::is_integral<A>::value, int> = 0>
+            constexpr double simd_apply(const A& a) const noexcept
+            {
+                return a * 180.0 / xt::numeric_constants<double>::PI;
+            }
+
+            template <class A, std::enable_if_t<std::is_floating_point<A>::value, int> = 0>
+            constexpr auto simd_apply(const A& a) const noexcept
+            {
+                return a * A(180.0) / xt::numeric_constants<A>::PI;
+            }
+        };
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Convert angles from degrees to radians.
+     *
+     * Returns an \ref xfunction for the element-wise corresponding
+     * angle in radians of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto deg2rad(E&& e) noexcept -> detail::xfunction_type_t<math::deg2rad, E>
+    {
+        return detail::make_xfunction<math::deg2rad>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Convert angles from degrees to radians.
+     *
+     * Returns an \ref xfunction for the element-wise corresponding
+     * angle in radians of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto radians(E&& e) noexcept -> detail::xfunction_type_t<math::deg2rad, E>
+    {
+        return detail::make_xfunction<math::deg2rad>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Convert angles from radians to degrees.
+     *
+     * Returns an \ref xfunction for the element-wise corresponding
+     * angle in degrees of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto rad2deg(E&& e) noexcept -> detail::xfunction_type_t<math::rad2deg, E>
+    {
+        return detail::make_xfunction<math::rad2deg>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Convert angles from radians to degrees.
+     *
+     * Returns an \ref xfunction for the element-wise corresponding
+     * angle in degrees of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto degrees(E&& e) noexcept -> detail::xfunction_type_t<math::rad2deg, E>
+    {
+        return detail::make_xfunction<math::rad2deg>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Elementwise maximum
+     *
+     * Returns an \ref xfunction for the element-wise
+     * maximum between e1 and e2.
+     * @param e1 an \ref xexpression
+     * @param e2 an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto maximum(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::maximum<void>, E1, E2>
+    {
+        return detail::make_xfunction<math::maximum<void>>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Elementwise minimum
+     *
+     * Returns an \ref xfunction for the element-wise
+     * minimum between e1 and e2.
+     * @param e1 an \ref xexpression
+     * @param e2 an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto minimum(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::minimum<void>, E1, E2>
+    {
+        return detail::make_xfunction<math::minimum<void>>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Maximum element along given axis.
+     *
+     * Returns an \ref xreducer for the maximum of elements over given
+     * \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the maximum is found (optional)
+     * @param es evaluation strategy of the reducer
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(
+        amax,
+        math::maximum<void>,
+        typename std::decay_t<E>::value_type,
+        std::numeric_limits<xvalue_type_t<std::decay_t<E>>>::lowest()
+    )
+
+    /**
+     * @ingroup basic_functions
+     * @brief Minimum element along given axis.
+     *
+     * Returns an \ref xreducer for the minimum of elements over given
+     * \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the minimum is found (optional)
+     * @param es evaluation strategy of the reducer
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(
+        amin,
+        math::minimum<void>,
+        typename std::decay_t<E>::value_type,
+        std::numeric_limits<xvalue_type_t<std::decay_t<E>>>::max()
+    )
+
+    /**
+     * @ingroup basic_functions
+     * @brief Clip values between hi and lo
+     *
+     * Returns an \ref xfunction for the element-wise clipped
+     * values between lo and hi
+     * @param e1 an \ref xexpression or a scalar
+     * @param lo a scalar
+     * @param hi a scalar
+     *
+     * @return a \ref xfunction
+     */
+    template <class E1, class E2, class E3>
+    inline auto clip(E1&& e1, E2&& lo, E3&& hi) noexcept
+        -> detail::xfunction_type_t<math::clamp_fun, E1, E2, E3>
+    {
+        return detail::make_xfunction<math::clamp_fun>(
+            std::forward<E1>(e1),
+            std::forward<E2>(lo),
+            std::forward<E3>(hi)
+        );
+    }
+
+    namespace math
+    {
+        template <class T>
+        struct sign_impl
+        {
+            template <class XT = T>
+            static constexpr std::enable_if_t<xtl::is_signed<XT>::value, T> run(T x)
+            {
+                return std::isnan(x) ? std::numeric_limits<T>::quiet_NaN()
+                       : x == 0      ? T(copysign(T(0), x))
+                                     : T(copysign(T(1), x));
+            }
+
+            template <class XT = T>
+            static constexpr std::enable_if_t<xtl::is_complex<XT>::value, T> run(T x)
+            {
+                return T(
+                    sign_impl<typename T::value_type>::run(
+                        (x.real() != typename T::value_type(0)) ? x.real() : x.imag()
+                    ),
+                    0
+                );
+            }
+
+            template <class XT = T>
+            static constexpr std::enable_if_t<std::is_unsigned<XT>::value, T> run(T x)
+            {
+                return T(x > T(0));
+            }
+        };
+
+        struct sign_fun
+        {
+            template <class T>
+            constexpr auto operator()(const T& x) const
+            {
+                return sign_impl<T>::run(x);
+            }
+        };
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Returns an element-wise indication of the sign of a number
+     *
+     * If the number is positive, returns +1. If negative, -1. If the number
+     * is zero, returns 0.
+     *
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto sign(E&& e) noexcept -> detail::xfunction_type_t<math::sign_fun, E>
+    {
+        return detail::make_xfunction<math::sign_fun>(std::forward<E>(e));
+    }
+
+    /*************************
+     * exponential functions *
+     *************************/
+
+    /**
+     * @defgroup exp_functions Exponential functions
+     */
+
+    /**
+     * @ingroup exp_functions
+     * @brief Natural exponential function.
+     *
+     * Returns an \ref xfunction for the element-wise natural
+     * exponential of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto exp(E&& e) noexcept -> detail::xfunction_type_t<math::exp_fun, E>
+    {
+        return detail::make_xfunction<math::exp_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup exp_functions
+     * @brief Base 2 exponential function.
+     *
+     * Returns an \ref xfunction for the element-wise base 2
+     * exponential of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto exp2(E&& e) noexcept -> detail::xfunction_type_t<math::exp2_fun, E>
+    {
+        return detail::make_xfunction<math::exp2_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup exp_functions
+     * @brief Natural exponential minus one function.
+     *
+     * Returns an \ref xfunction for the element-wise natural
+     * exponential of \em e, minus 1.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto expm1(E&& e) noexcept -> detail::xfunction_type_t<math::expm1_fun, E>
+    {
+        return detail::make_xfunction<math::expm1_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup exp_functions
+     * @brief Natural logarithm function.
+     *
+     * Returns an \ref xfunction for the element-wise natural
+     * logarithm of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto log(E&& e) noexcept -> detail::xfunction_type_t<math::log_fun, E>
+    {
+        return detail::make_xfunction<math::log_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup exp_functions
+     * @brief Base 10 logarithm function.
+     *
+     * Returns an \ref xfunction for the element-wise base 10
+     * logarithm of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto log10(E&& e) noexcept -> detail::xfunction_type_t<math::log10_fun, E>
+    {
+        return detail::make_xfunction<math::log10_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup exp_functions
+     * @brief Base 2 logarithm function.
+     *
+     * Returns an \ref xfunction for the element-wise base 2
+     * logarithm of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto log2(E&& e) noexcept -> detail::xfunction_type_t<math::log2_fun, E>
+    {
+        return detail::make_xfunction<math::log2_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup exp_functions
+     * @brief Natural logarithm of one plus function.
+     *
+     * Returns an \ref xfunction for the element-wise natural
+     * logarithm of \em e, plus 1.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto log1p(E&& e) noexcept -> detail::xfunction_type_t<math::log1p_fun, E>
+    {
+        return detail::make_xfunction<math::log1p_fun>(std::forward<E>(e));
+    }
+
+    /*******************
+     * power functions *
+     *******************/
+
+    /**
+     * @defgroup pow_functions Power functions
+     */
+
+    /**
+     * @ingroup pow_functions
+     * @brief Power function.
+     *
+     * Returns an \ref xfunction for the element-wise value of
+     * of \em e1 raised to the power \em e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto pow(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::pow_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::pow_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    namespace detail
+    {
+        template <class F, class... T, typename = decltype(std::declval<F>()(std::declval<T>()...))>
+        std::true_type supports_test(const F&, const T&...);
+        std::false_type supports_test(...);
+
+        template <class... T>
+        struct supports;
+
+        template <class F, class... T>
+        struct supports<F(T...)> : decltype(supports_test(std::declval<F>(), std::declval<T>()...))
+        {
+        };
+
+        template <class F>
+        struct lambda_adapt
+        {
+            explicit lambda_adapt(F&& lmbd)
+                : m_lambda(std::move(lmbd))
+            {
+            }
+
+            template <class... T>
+            auto operator()(T... args) const
+            {
+                return m_lambda(args...);
+            }
+
+            template <class... T, XTL_REQUIRES(detail::supports<F(T...)>)>
+            auto simd_apply(T... args) const
+            {
+                return m_lambda(args...);
+            }
+
+            F m_lambda;
+        };
+    }
+
+    /**
+     * Create a xfunction from a lambda
+     *
+     * This function can be used to easily create performant xfunctions from lambdas:
+     *
+     * @code{cpp}
+     * template <class E1>
+     * inline auto square(E1&& e1) noexcept
+     * {
+     *     auto fnct = [](auto x) -> decltype(x * x) {
+     *         return x * x;
+     *     };
+     *     return make_lambda_xfunction(std::move(fnct), std::forward<E1>(e1));
+     * }
+     * @endcode
+     *
+     * Lambda function allow the reusal of a single arguments in multiple places (otherwise
+     * only correctly possible when using xshared_expressions). ``auto`` lambda functions are
+     * automatically vectorized with ``xsimd`` if possible (note that the trailing
+     * ``-> decltype(...)`` is mandatory for the feature detection to work).
+     *
+     * @param lambda the lambda to be vectorized
+     * @param args forwarded arguments
+     *
+     * @return lazy xfunction
+     */
+    template <class F, class... E>
+    inline auto make_lambda_xfunction(F&& lambda, E&&... args)
+    {
+        using xfunction_type = typename detail::xfunction_type<detail::lambda_adapt<F>, E...>::type;
+        return xfunction_type(detail::lambda_adapt<F>(std::forward<F>(lambda)), std::forward<E>(args)...);
+    }
+
+    /**
+     * @ingroup pow_functions
+     * @brief Square power function, equivalent to e1 * e1.
+     *
+     * Returns an \ref xfunction for the element-wise value of
+     * of \em e1 * \em e1.
+     * @param e1 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1>
+    inline auto square(E1&& e1) noexcept
+    {
+        auto fnct = [](auto x) -> decltype(x * x)
+        {
+            return x * x;
+        };
+        return make_lambda_xfunction(std::move(fnct), std::forward<E1>(e1));
+    }
+
+    /**
+     * @ingroup pow_functions
+     * @brief Cube power function, equivalent to e1 * e1 * e1.
+     *
+     * Returns an \ref xfunction for the element-wise value of
+     * of \em e1 * \em e1.
+     * @param e1 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1>
+    inline auto cube(E1&& e1) noexcept
+    {
+        auto fnct = [](auto x) -> decltype(x * x * x)
+        {
+            return x * x * x;
+        };
+        return make_lambda_xfunction(std::move(fnct), std::forward<E1>(e1));
+    }
+
+    namespace detail
+    {
+        // Thanks to Matt Pharr in http://pbrt.org/hair.pdf
+        template <std::size_t N>
+        struct pow_impl;
+
+        template <std::size_t N>
+        struct pow_impl
+        {
+            template <class T>
+            auto operator()(T v) const -> decltype(v * v)
+            {
+                T temp = pow_impl<N / 2>{}(v);
+                return temp * temp * pow_impl<N & 1>{}(v);
+            }
+        };
+
+        template <>
+        struct pow_impl<1>
+        {
+            template <class T>
+            auto operator()(T v) const -> T
+            {
+                return v;
+            }
+        };
+
+        template <>
+        struct pow_impl<0>
+        {
+            template <class T>
+            auto operator()(T /*v*/) const -> T
+            {
+                return T(1);
+            }
+        };
+    }
+
+    /**
+     * @ingroup pow_functions
+     * @brief Integer power function.
+     *
+     * Returns an \ref xfunction for the element-wise power of e1 to
+     * an integral constant.
+     *
+     * Instead of computing the power by using the (expensive) logarithm, this function
+     * computes the power in a number of straight-forward multiplication steps. This function
+     * is therefore much faster (even for high N) than the generic pow-function.
+     *
+     * For example, `e1^20` can be expressed as `(((e1^2)^2)^2)^2*(e1^2)^2`, which is just 5 multiplications.
+     *
+     * @param e an \ref xexpression
+     * @tparam N the exponent (has to be positive integer)
+     * @return an \ref xfunction
+     */
+    template <std::size_t N, class E>
+    inline auto pow(E&& e) noexcept
+    {
+        static_assert(N > 0, "integer power cannot be negative");
+        return make_lambda_xfunction(detail::pow_impl<N>{}, std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup pow_functions
+     * @brief Square root function.
+     *
+     * Returns an \ref xfunction for the element-wise square
+     * root of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto sqrt(E&& e) noexcept -> detail::xfunction_type_t<math::sqrt_fun, E>
+    {
+        return detail::make_xfunction<math::sqrt_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup pow_functions
+     * @brief Cubic root function.
+     *
+     * Returns an \ref xfunction for the element-wise cubic
+     * root of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto cbrt(E&& e) noexcept -> detail::xfunction_type_t<math::cbrt_fun, E>
+    {
+        return detail::make_xfunction<math::cbrt_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup pow_functions
+     * @brief Hypotenuse function.
+     *
+     * Returns an \ref xfunction for the element-wise square
+     * root of the sum of the square of \em e1 and \em e2, avoiding
+     * overflow and underflow at intermediate stages of computation.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto hypot(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::hypot_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::hypot_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /***************************
+     * trigonometric functions *
+     ***************************/
+
+    /**
+     * @defgroup trigo_functions Trigonometric function
+     */
+
+    /**
+     * @ingroup trigo_functions
+     * @brief Sine function.
+     *
+     * Returns an \ref xfunction for the element-wise sine
+     * of \em e (measured in radians).
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto sin(E&& e) noexcept -> detail::xfunction_type_t<math::sin_fun, E>
+    {
+        return detail::make_xfunction<math::sin_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup trigo_functions
+     * @brief Cosine function.
+     *
+     * Returns an \ref xfunction for the element-wise cosine
+     * of \em e (measured in radians).
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto cos(E&& e) noexcept -> detail::xfunction_type_t<math::cos_fun, E>
+    {
+        return detail::make_xfunction<math::cos_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup trigo_functions
+     * @brief Tangent function.
+     *
+     * Returns an \ref xfunction for the element-wise tangent
+     * of \em e (measured in radians).
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto tan(E&& e) noexcept -> detail::xfunction_type_t<math::tan_fun, E>
+    {
+        return detail::make_xfunction<math::tan_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup trigo_functions
+     * @brief Arcsine function.
+     *
+     * Returns an \ref xfunction for the element-wise arcsine
+     * of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto asin(E&& e) noexcept -> detail::xfunction_type_t<math::asin_fun, E>
+    {
+        return detail::make_xfunction<math::asin_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup trigo_functions
+     * @brief Arccosine function.
+     *
+     * Returns an \ref xfunction for the element-wise arccosine
+     * of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto acos(E&& e) noexcept -> detail::xfunction_type_t<math::acos_fun, E>
+    {
+        return detail::make_xfunction<math::acos_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup trigo_functions
+     * @brief Arctangent function.
+     *
+     * Returns an \ref xfunction for the element-wise arctangent
+     * of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto atan(E&& e) noexcept -> detail::xfunction_type_t<math::atan_fun, E>
+    {
+        return detail::make_xfunction<math::atan_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup trigo_functions
+     * @brief Artangent function, using signs to determine quadrants.
+     *
+     * Returns an \ref xfunction for the element-wise arctangent
+     * of <em>e1 / e2</em>, using the signs of arguments to determine the
+     * correct quadrant.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     * @note e1 and e2 can't be both scalars.
+     */
+    template <class E1, class E2>
+    inline auto atan2(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<math::atan2_fun, E1, E2>
+    {
+        return detail::make_xfunction<math::atan2_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /************************
+     * hyperbolic functions *
+     ************************/
+
+    /**
+     * @defgroup hyper_functions Hyperbolic functions
+     */
+
+    /**
+     * @ingroup hyper_functions
+     * @brief Hyperbolic sine function.
+     *
+     * Returns an \ref xfunction for the element-wise hyperbolic
+     * sine of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto sinh(E&& e) noexcept -> detail::xfunction_type_t<math::sinh_fun, E>
+    {
+        return detail::make_xfunction<math::sinh_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup hyper_functions
+     * @brief Hyperbolic cosine function.
+     *
+     * Returns an \ref xfunction for the element-wise hyperbolic
+     * cosine of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto cosh(E&& e) noexcept -> detail::xfunction_type_t<math::cosh_fun, E>
+    {
+        return detail::make_xfunction<math::cosh_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup hyper_functions
+     * @brief Hyperbolic tangent function.
+     *
+     * Returns an \ref xfunction for the element-wise hyperbolic
+     * tangent of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto tanh(E&& e) noexcept -> detail::xfunction_type_t<math::tanh_fun, E>
+    {
+        return detail::make_xfunction<math::tanh_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup hyper_functions
+     * @brief Inverse hyperbolic sine function.
+     *
+     * Returns an \ref xfunction for the element-wise inverse hyperbolic
+     * sine of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto asinh(E&& e) noexcept -> detail::xfunction_type_t<math::asinh_fun, E>
+    {
+        return detail::make_xfunction<math::asinh_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup hyper_functions
+     * @brief Inverse hyperbolic cosine function.
+     *
+     * Returns an \ref xfunction for the element-wise inverse hyperbolic
+     * cosine of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto acosh(E&& e) noexcept -> detail::xfunction_type_t<math::acosh_fun, E>
+    {
+        return detail::make_xfunction<math::acosh_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup hyper_functions
+     * @brief Inverse hyperbolic tangent function.
+     *
+     * Returns an \ref xfunction for the element-wise inverse hyperbolic
+     * tangent of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto atanh(E&& e) noexcept -> detail::xfunction_type_t<math::atanh_fun, E>
+    {
+        return detail::make_xfunction<math::atanh_fun>(std::forward<E>(e));
+    }
+
+    /*****************************
+     * error and gamma functions *
+     *****************************/
+
+    /**
+     * @defgroup err_functions Error and gamma functions
+     */
+
+    /**
+     * @ingroup err_functions
+     * @brief Error function.
+     *
+     * Returns an \ref xfunction for the element-wise error function
+     * of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto erf(E&& e) noexcept -> detail::xfunction_type_t<math::erf_fun, E>
+    {
+        return detail::make_xfunction<math::erf_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup err_functions
+     * @brief Complementary error function.
+     *
+     * Returns an \ref xfunction for the element-wise complementary
+     * error function of \em e, whithout loss of precision for large argument.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto erfc(E&& e) noexcept -> detail::xfunction_type_t<math::erfc_fun, E>
+    {
+        return detail::make_xfunction<math::erfc_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup err_functions
+     * @brief Gamma function.
+     *
+     * Returns an \ref xfunction for the element-wise gamma function
+     * of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto tgamma(E&& e) noexcept -> detail::xfunction_type_t<math::tgamma_fun, E>
+    {
+        return detail::make_xfunction<math::tgamma_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup err_functions
+     * @brief Natural logarithm of the gamma function.
+     *
+     * Returns an \ref xfunction for the element-wise logarithm of
+     * the asbolute value fo the gamma function of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto lgamma(E&& e) noexcept -> detail::xfunction_type_t<math::lgamma_fun, E>
+    {
+        return detail::make_xfunction<math::lgamma_fun>(std::forward<E>(e));
+    }
+
+    /*********************************************
+     * nearest integer floating point operations *
+     *********************************************/
+
+    /**
+     * @defgroup nearint_functions Nearest integer floating point operations
+     */
+
+    /**
+     * @ingroup nearint_functions
+     * @brief ceil function.
+     *
+     * Returns an \ref xfunction for the element-wise smallest integer value
+     * not less than \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto ceil(E&& e) noexcept -> detail::xfunction_type_t<math::ceil_fun, E>
+    {
+        return detail::make_xfunction<math::ceil_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup nearint_functions
+     * @brief floor function.
+     *
+     * Returns an \ref xfunction for the element-wise smallest integer value
+     * not greater than \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto floor(E&& e) noexcept -> detail::xfunction_type_t<math::floor_fun, E>
+    {
+        return detail::make_xfunction<math::floor_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup nearint_functions
+     * @brief trunc function.
+     *
+     * Returns an \ref xfunction for the element-wise nearest integer not greater
+     * in magnitude than \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto trunc(E&& e) noexcept -> detail::xfunction_type_t<math::trunc_fun, E>
+    {
+        return detail::make_xfunction<math::trunc_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup nearint_functions
+     * @brief round function.
+     *
+     * Returns an \ref xfunction for the element-wise nearest integer value
+     * to \em e, rounding halfway cases away from zero, regardless of the
+     * current rounding mode.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto round(E&& e) noexcept -> detail::xfunction_type_t<math::round_fun, E>
+    {
+        return detail::make_xfunction<math::round_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup nearint_functions
+     * @brief nearbyint function.
+     *
+     * Returns an \ref xfunction for the element-wise rounding of \em e to integer
+     * values in floating point format, using the current rounding mode. nearbyint
+     * never raises FE_INEXACT error.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto nearbyint(E&& e) noexcept -> detail::xfunction_type_t<math::nearbyint_fun, E>
+    {
+        return detail::make_xfunction<math::nearbyint_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup nearint_functions
+     * @brief rint function.
+     *
+     * Returns an \ref xfunction for the element-wise rounding of \em e to integer
+     * values in floating point format, using the current rounding mode. Contrary
+     * to nearbyint, rint may raise FE_INEXACT error.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto rint(E&& e) noexcept -> detail::xfunction_type_t<math::rint_fun, E>
+    {
+        return detail::make_xfunction<math::rint_fun>(std::forward<E>(e));
+    }
+
+    /****************************
+     * classification functions *
+     ****************************/
+
+    /**
+     * @defgroup classif_functions Classification functions
+     */
+
+    /**
+     * @ingroup classif_functions
+     * @brief finite value check
+     *
+     * Returns an \ref xfunction for the element-wise finite value check
+     * tangent of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto isfinite(E&& e) noexcept -> detail::xfunction_type_t<math::isfinite_fun, E>
+    {
+        return detail::make_xfunction<math::isfinite_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup classif_functions
+     * @brief infinity check
+     *
+     * Returns an \ref xfunction for the element-wise infinity check
+     * tangent of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto isinf(E&& e) noexcept -> detail::xfunction_type_t<math::isinf_fun, E>
+    {
+        return detail::make_xfunction<math::isinf_fun>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup classif_functions
+     * @brief NaN check
+     *
+     * Returns an \ref xfunction for the element-wise NaN check
+     * tangent of \em e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto isnan(E&& e) noexcept -> detail::xfunction_type_t<math::isnan_fun, E>
+    {
+        return detail::make_xfunction<math::isnan_fun>(std::forward<E>(e));
+    }
+
+    namespace detail
+    {
+        template <class FUNCTOR, class T, std::size_t... Is>
+        inline auto get_functor(T&& args, std::index_sequence<Is...>)
+        {
+            return FUNCTOR(std::get<Is>(args)...);
+        }
+
+        template <class F, class... A, class... E>
+        inline auto make_xfunction(std::tuple<A...>&& f_args, E&&... e) noexcept
+        {
+            using functor_type = F;
+            using expression_tag = xexpression_tag_t<E...>;
+            using type = select_xfunction_expression_t<expression_tag, functor_type, const_xclosure_t<E>...>;
+            auto functor = get_functor<functor_type>(
+                std::forward<std::tuple<A...>>(f_args),
+                std::make_index_sequence<sizeof...(A)>{}
+            );
+            return type(std::move(functor), std::forward<E>(e)...);
+        }
+
+        struct isclose
+        {
+            using result_type = bool;
+
+            isclose(double rtol, double atol, bool equal_nan)
+                : m_rtol(rtol)
+                , m_atol(atol)
+                , m_equal_nan(equal_nan)
+            {
+            }
+
+            template <class A1, class A2>
+            bool operator()(const A1& a, const A2& b) const
+            {
+                using internal_type = xtl::promote_type_t<A1, A2, double>;
+                if (math::isnan(a) && math::isnan(b))
+                {
+                    return m_equal_nan;
+                }
+                if (math::isinf(a) && math::isinf(b))
+                {
+                    // check for both infinity signs equal
+                    return a == b;
+                }
+                auto d = math::abs(internal_type(a) - internal_type(b));
+                return d <= m_atol
+                       || d <= m_rtol
+                                   * double((std::max)(math::abs(internal_type(a)), math::abs(internal_type(b)))
+                                   );
+            }
+
+        private:
+
+            double m_rtol;
+            double m_atol;
+            bool m_equal_nan;
+        };
+    }
+
+    /**
+     * @ingroup classif_functions
+     * @brief Element-wise closeness detection
+     *
+     * Returns an \ref xfunction that evaluates to
+     * true if the elements in ``e1`` and ``e2`` are close to each other
+     * according to parameters ``atol`` and ``rtol``.
+     * The equation is: ``std::abs(a - b) <= (m_atol + m_rtol * std::abs(b))``.
+     * @param e1 input array to compare
+     * @param e2 input array to compare
+     * @param rtol the relative tolerance parameter (default 1e-05)
+     * @param atol the absolute tolerance parameter (default 1e-08)
+     * @param equal_nan if true, isclose returns true if both elements of e1 and e2 are NaN
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto
+    isclose(E1&& e1, E2&& e2, double rtol = 1e-05, double atol = 1e-08, bool equal_nan = false) noexcept
+    {
+        return detail::make_xfunction<detail::isclose>(
+            std::make_tuple(rtol, atol, equal_nan),
+            std::forward<E1>(e1),
+            std::forward<E2>(e2)
+        );
+    }
+
+    /**
+     * @ingroup classif_functions
+     * @brief Check if all elements in \em e1 are close to the
+     * corresponding elements in \em e2.
+     *
+     * Returns true if all elements in ``e1`` and ``e2`` are close to each other
+     * according to parameters ``atol`` and ``rtol``.
+     * @param e1 input array to compare
+     * @param e2 input arrays to compare
+     * @param rtol the relative tolerance parameter (default 1e-05)
+     * @param atol the absolute tolerance parameter (default 1e-08)
+     * @return a boolean
+     */
+    template <class E1, class E2>
+    inline auto allclose(E1&& e1, E2&& e2, double rtol = 1e-05, double atol = 1e-08) noexcept
+    {
+        return xt::all(isclose(std::forward<E1>(e1), std::forward<E2>(e2), rtol, atol));
+    }
+
+    /**********************
+     * Reducing functions *
+     **********************/
+
+    /**
+     * @defgroup  red_functions reducing functions
+     */
+
+    /**
+     * @ingroup red_functions
+     * @brief Sum of elements over given axes.
+     *
+     * Returns an \ref xreducer for the sum of elements over given
+     * \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the sum is performed (optional)
+     * @param es evaluation strategy of the reducer
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T` is also used for determining the value type
+     *           of the result, which is the type of `T() + E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(sum, detail::plus, typename std::decay_t<E>::value_type, 0)
+
+    /**
+     * @ingroup red_functions
+     * @brief Product of elements over given axes.
+     *
+     * Returns an \ref xreducer for the product of elements over given
+     * \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the product is computed (optional)
+     * @param ddof delta degrees of freedom (optional).
+     *             The divisor used in calculations is N - ddof, where N represents the number of
+     *             elements. By default ddof is zero.
+     * @param es evaluation strategy of the reducer
+     * @tparam T the value type used for internal computation. The default is `E::value_type`.
+     *           `T` is also used for determining the value type of the result, which is the type
+     *           of `T() * E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(prod, detail::multiplies, typename std::decay_t<E>::value_type, 1)
+
+    namespace detail
+    {
+        template <class T, class S, class ST>
+        inline auto mean_division(S&& s, ST e_size)
+        {
+            using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
+            // Avoids floating point exception when s.size is 0
+            value_type div = s.size() != ST(0) ? static_cast<value_type>(e_size / s.size()) : value_type(0);
+            return std::move(s) / std::move(div);
+        }
+
+        template <
+            class T,
+            class E,
+            class X,
+            class D,
+            class EVS,
+            XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<D>)>
+        inline auto mean(E&& e, X&& axes, const D& ddof, EVS es)
+        {
+            // sum cannot always be a double. It could be a complex number which cannot operate on
+            // std::plus<double>.
+            using size_type = typename std::decay_t<E>::size_type;
+            const size_type size = e.size();
+            XTENSOR_ASSERT(static_cast<size_type>(ddof) <= size);
+            auto s = sum<T>(std::forward<E>(e), std::forward<X>(axes), es);
+            return mean_division<T>(std::move(s), size - static_cast<size_type>(ddof));
+        }
+
+        template <class T, class E, class I, std::size_t N, class D, class EVS>
+        inline auto mean(E&& e, const I (&axes)[N], const D& ddof, EVS es)
+        {
+            using size_type = typename std::decay_t<E>::size_type;
+            const size_type size = e.size();
+            XTENSOR_ASSERT(static_cast<size_type>(ddof) <= size);
+            auto s = sum<T>(std::forward<E>(e), axes, es);
+            return mean_division<T>(std::move(s), size - static_cast<size_type>(ddof));
+        }
+
+        template <class T, class E, class D, class EVS, XTL_REQUIRES(is_reducer_options<EVS>, xtl::is_integral<D>)>
+        inline auto mean_noaxis(E&& e, const D& ddof, EVS es)
+        {
+            using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
+            using size_type = typename std::decay_t<E>::size_type;
+            const size_type size = e.size();
+            XTENSOR_ASSERT(static_cast<size_type>(ddof) <= size);
+            auto s = sum<T>(std::forward<E>(e), es);
+            return std::move(s) / static_cast<value_type>((size - static_cast<size_type>(ddof)));
+        }
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Mean of elements over given axes.
+     *
+     * Returns an \ref xreducer for the mean of elements over given
+     * \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the mean is computed (optional)
+     * @param es the evaluation strategy (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T` is also used for determining the value type
+     *           of the result, which is the type of `T() + E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xexpression
+     */
+    template <
+        class T = void,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
+    inline auto mean(E&& e, X&& axes, EVS es = EVS())
+    {
+        return detail::mean<T>(std::forward<E>(e), std::forward<X>(axes), 0u, es);
+    }
+
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto mean(E&& e, EVS es = EVS())
+    {
+        return detail::mean_noaxis<T>(std::forward<E>(e), 0u, es);
+    }
+
+    template <class T = void, class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto mean(E&& e, const I (&axes)[N], EVS es = EVS())
+    {
+        return detail::mean<T>(std::forward<E>(e), axes, 0u, es);
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Average of elements over given axes using weights.
+     *
+     * Returns an \ref xreducer for the mean of elements over given
+     * \em axes.
+     * @param e an \ref xexpression
+     * @param weights \ref xexpression containing weights associated with the values in \ref e
+     * @param axes the axes along which the mean is computed (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T`is also used for determining the value type of the result,
+     *           which is the type of `T() + E::value_type().
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xexpression
+     *
+     * @sa mean
+     */
+    template <
+        class T = void,
+        class E,
+        class W,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(is_reducer_options<EVS>, std::negation<xtl::is_integral<X>>)>
+    inline auto average(E&& e, W&& weights, X&& axes, EVS ev = EVS())
+    {
+        xindex_type_t<typename std::decay_t<E>::shape_type> broadcast_shape;
+        xt::resize_container(broadcast_shape, e.dimension());
+        auto ax = normalize_axis(e, axes);
+        if (weights.dimension() == 1)
+        {
+            if (weights.size() != e.shape()[ax[0]])
+            {
+                XTENSOR_THROW(std::runtime_error, "Weights need to have the same shape as expression at axes.");
+            }
+
+            std::fill(broadcast_shape.begin(), broadcast_shape.end(), std::size_t(1));
+            broadcast_shape[ax[0]] = weights.size();
+        }
+        else
+        {
+            if (!same_shape(e.shape(), weights.shape()))
+            {
+                XTENSOR_THROW(
+                    std::runtime_error,
+                    "Weights with dim > 1 need to have the same shape as expression."
+                );
+            }
+
+            std::copy(e.shape().begin(), e.shape().end(), broadcast_shape.begin());
+        }
+
+        constexpr layout_type L = default_assignable_layout(std::decay_t<W>::static_layout);
+        auto weights_view = reshape_view<L>(std::forward<W>(weights), std::move(broadcast_shape));
+        auto scl = sum<T>(weights_view, ax, xt::evaluation_strategy::immediate);
+        return sum<T>(std::forward<E>(e) * std::move(weights_view), std::move(ax), ev) / std::move(scl);
+    }
+
+    template <
+        class T = void,
+        class E,
+        class W,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(is_reducer_options<EVS>, xtl::is_integral<X>)>
+    inline auto average(E&& e, W&& weights, X axis, EVS ev = EVS())
+    {
+        return average(std::forward<E>(e), std::forward<W>(weights), {axis}, std::forward<EVS>(ev));
+    }
+
+    template <class T = void, class E, class W, class X, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto average(E&& e, W&& weights, const X (&axes)[N], EVS ev = EVS())
+    {
+        // need to select the X&& overload and forward to different type
+        using ax_t = std::array<std::size_t, N>;
+        return average<T>(std::forward<E>(e), std::forward<W>(weights), xt::forward_normalize<ax_t>(e, axes), ev);
+    }
+
+    template <class T = void, class E, class W, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto average(E&& e, W&& weights, EVS ev = EVS())
+    {
+        if (weights.dimension() != e.dimension()
+            || !std::equal(weights.shape().begin(), weights.shape().end(), e.shape().begin()))
+        {
+            XTENSOR_THROW(std::runtime_error, "Weights need to have the same shape as expression.");
+        }
+
+        auto div = sum<T>(weights, evaluation_strategy::immediate)();
+        auto s = sum<T>(std::forward<E>(e) * std::forward<W>(weights), ev) / std::move(div);
+        return s;
+    }
+
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto average(E&& e, EVS ev = EVS())
+    {
+        return mean<T>(e, ev);
+    }
+
+    namespace detail
+    {
+        template <typename E>
+        std::enable_if_t<std::is_lvalue_reference<E>::value, E> shared_forward(E e) noexcept
+        {
+            return e;
+        }
+
+        template <typename E>
+        std::enable_if_t<!std::is_lvalue_reference<E>::value, xshared_expression<E>> shared_forward(E e) noexcept
+        {
+            return make_xshared(std::move(e));
+        }
+    }
+
+    template <
+        class T = void,
+        class E,
+        class D,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(is_reducer_options<EVS>, xtl::is_integral<D>)>
+    inline auto variance(E&& e, const D& ddof, EVS es = EVS())
+    {
+        auto cached_mean = mean<T>(e, es)();
+        return detail::mean_noaxis<T>(square(std::forward<E>(e) - std::move(cached_mean)), ddof, es);
+    }
+
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto variance(E&& e, EVS es = EVS())
+    {
+        return variance<T>(std::forward<E>(e), 0u, es);
+    }
+
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto stddev(E&& e, EVS es = EVS())
+    {
+        return sqrt(variance<T>(std::forward<E>(e), es));
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Compute the variance along the specified axes
+     *
+     * Returns the variance of the array elements, a measure of the spread of a
+     * distribution. The variance is computed for the flattened array by default,
+     * otherwise over the specified axes.
+     *
+     * Note: this function is not yet specialized for complex numbers.
+     *
+     * @param e an \ref xexpression
+     * @param axes the axes along which the variance is computed (optional)
+     * @param ddof delta degrees of freedom (optional).
+     *             The divisor used in calculations is N - ddof, where N represents the number of
+     *             elements. By default ddof is zero.
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T`is also used for determining the value type of the result,
+     *           which is the type of `T() + E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xexpression
+     *
+     * @sa stddev, mean
+     */
+    template <
+        class T = void,
+        class E,
+        class X,
+        class D,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<D>)>
+    inline auto variance(E&& e, X&& axes, const D& ddof, EVS es = EVS())
+    {
+        decltype(auto) sc = detail::shared_forward<E>(e);
+        // note: forcing copy of first axes argument -- is there a better solution?
+        auto axes_copy = axes;
+        // always eval to prevent repeated evaluations in the next calls
+        auto inner_mean = eval(mean<T>(sc, std::move(axes_copy), evaluation_strategy::immediate));
+
+        // fake keep_dims = 1
+        // Since the inner_shape might have a reference semantic (e.g. xbuffer_adaptor in bindings)
+        // We need to map it to another type before modifying it.
+        // We pragmatically abuse `get_strides_t`
+        using tmp_shape_t = get_strides_t<typename std::decay_t<E>::shape_type>;
+        tmp_shape_t keep_dim_shape = xtl::forward_sequence<tmp_shape_t, decltype(e.shape())>(e.shape());
+        for (const auto& el : axes)
+        {
+            keep_dim_shape[el] = 1u;
+        }
+
+        auto mrv = reshape_view<XTENSOR_DEFAULT_LAYOUT>(std::move(inner_mean), std::move(keep_dim_shape));
+        return detail::mean<T>(square(sc - std::move(mrv)), std::forward<X>(axes), ddof, es);
+    }
+
+    template <
+        class T = void,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>, is_reducer_options<EVS>)>
+    inline auto variance(E&& e, X&& axes, EVS es = EVS())
+    {
+        return variance<T>(std::forward<E>(e), std::forward<X>(axes), 0u, es);
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Compute the standard deviation along the specified axis.
+     *
+     * Returns the standard deviation, a measure of the spread of a distribution,
+     * of the array elements. The standard deviation is computed for the flattened
+     * array by default, otherwise over the specified axis.
+     *
+     * Note: this function is not yet specialized for complex numbers.
+     *
+     * @param e an \ref xexpression
+     * @param axes the axes along which the standard deviation is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T`is also used for determining the value type of the result,
+     *           which is the type of `T() + E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xexpression
+     *
+     * @sa variance, mean
+     */
+    template <
+        class T = void,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
+    inline auto stddev(E&& e, X&& axes, EVS es = EVS())
+    {
+        return sqrt(variance<T>(std::forward<E>(e), std::forward<X>(axes), es));
+    }
+
+    template <class T = void, class E, class A, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto stddev(E&& e, const A (&axes)[N], EVS es = EVS())
+    {
+        return stddev<T>(
+            std::forward<E>(e),
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(axes)>(axes),
+            es
+        );
+    }
+
+    template <
+        class T = void,
+        class E,
+        class A,
+        std::size_t N,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto variance(E&& e, const A (&axes)[N], EVS es = EVS())
+    {
+        return variance<T>(
+            std::forward<E>(e),
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(axes)>(axes),
+            es
+        );
+    }
+
+    template <class T = void, class E, class A, std::size_t N, class D, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto variance(E&& e, const A (&axes)[N], const D& ddof, EVS es = EVS())
+    {
+        return variance<T>(
+            std::forward<E>(e),
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(axes)>(axes),
+            ddof,
+            es
+        );
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Minimum and maximum among the elements of an array or expression.
+     *
+     * Returns an \ref xreducer for the minimum and maximum of an expression's elements.
+     * @param e an \ref xexpression
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xexpression of type ``std::array<value_type, 2>``, whose first
+     *         and second element represent the minimum and maximum respectively
+     */
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto minmax(E&& e, EVS es = EVS())
+    {
+        using std::max;
+        using std::min;
+        using value_type = typename std::decay_t<E>::value_type;
+        using result_type = std::array<value_type, 2>;
+        using init_value_fct = xt::const_value<result_type>;
+
+        auto reduce_func = [](auto r, const auto& v)
+        {
+            r[0] = (min) (r[0], v);
+            r[1] = (max) (r[1], v);
+            return r;
+        };
+
+        auto init_func = init_value_fct(
+            result_type{std::numeric_limits<value_type>::max(), std::numeric_limits<value_type>::lowest()}
+        );
+
+        auto merge_func = [](auto r, const auto& s)
+        {
+            r[0] = (min) (r[0], s[0]);
+            r[1] = (max) (r[1], s[1]);
+            return r;
+        };
+        return xt::reduce(
+            make_xreducer_functor(std::move(reduce_func), std::move(init_func), std::move(merge_func)),
+            std::forward<E>(e),
+            arange(e.dimension()),
+            es
+        );
+    }
+
+    /**
+     * @defgroup acc_functions accumulating functions
+     */
+
+    /**
+     * @ingroup acc_functions
+     * @brief Cumulative sum.
+     *
+     * Returns the accumulated sum for the elements over given
+     * \em axis (or flattened).
+     * @param e an \ref xexpression
+     * @param axis the axes along which the cumulative sum is computed (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T`is also used for determining the value type of the result,
+     *           which is the type of `T() + E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xarray<T>
+     */
+    template <class T = void, class E>
+    inline auto cumsum(E&& e, std::ptrdiff_t axis)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::plus(), detail::accumulator_identity<init_value_type>()),
+            std::forward<E>(e),
+            axis
+        );
+    }
+
+    template <class T = void, class E>
+    inline auto cumsum(E&& e)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::plus(), detail::accumulator_identity<init_value_type>()),
+            std::forward<E>(e)
+        );
+    }
+
+    /**
+     * @ingroup acc_functions
+     * @brief Cumulative product.
+     *
+     * Returns the accumulated product for the elements over given
+     * \em axis (or flattened).
+     * @param e an \ref xexpression
+     * @param axis the axes along which the cumulative product is computed (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T`is also used for determining the value type of the result,
+     *           which is the type of `T() * E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xarray<T>
+     */
+    template <class T = void, class E>
+    inline auto cumprod(E&& e, std::ptrdiff_t axis)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::multiplies(), detail::accumulator_identity<init_value_type>()),
+            std::forward<E>(e),
+            axis
+        );
+    }
+
+    template <class T = void, class E>
+    inline auto cumprod(E&& e)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::multiplies(), detail::accumulator_identity<init_value_type>()),
+            std::forward<E>(e)
+        );
+    }
+
+    /*****************
+     * nan functions *
+     *****************/
+
+    namespace detail
+    {
+        struct nan_to_num_functor
+        {
+            template <class A>
+            inline auto operator()(const A& a) const
+            {
+                if (math::isnan(a))
+                {
+                    return A(0);
+                }
+                if (math::isinf(a))
+                {
+                    if (a < 0)
+                    {
+                        return std::numeric_limits<A>::lowest();
+                    }
+                    else
+                    {
+                        return (std::numeric_limits<A>::max)();
+                    }
+                }
+                return a;
+            }
+        };
+
+        struct nan_min
+        {
+            template <class T, class U>
+            constexpr auto operator()(const T lhs, const U rhs) const
+            {
+                // Clunky expression for working with GCC 4.9
+                return math::isnan(lhs)
+                           ? rhs
+                           : (math::isnan(rhs) ? lhs
+                                               : std::common_type_t<T, U>(
+                                                   detail::make_xfunction<math::minimum<void>>(lhs, rhs)
+                                               ));
+            }
+        };
+
+        struct nan_max
+        {
+            template <class T, class U>
+            constexpr auto operator()(const T lhs, const U rhs) const
+            {
+                // Clunky expression for working with GCC 4.9
+                return math::isnan(lhs)
+                           ? rhs
+                           : (math::isnan(rhs) ? lhs
+                                               : std::common_type_t<T, U>(
+                                                   detail::make_xfunction<math::maximum<void>>(lhs, rhs)
+                                               ));
+            }
+        };
+
+        struct nan_plus
+        {
+            template <class T, class U>
+            constexpr auto operator()(const T lhs, const U rhs) const
+            {
+                return !math::isnan(rhs) ? lhs + rhs : lhs;
+            }
+        };
+
+        struct nan_multiplies
+        {
+            template <class T, class U>
+            constexpr auto operator()(const T lhs, const U rhs) const
+            {
+                return !math::isnan(rhs) ? lhs * rhs : lhs;
+            }
+        };
+
+        template <class T, int V>
+        struct nan_init
+        {
+            using value_type = T;
+            using result_type = T;
+
+            constexpr result_type operator()(const value_type lhs) const
+            {
+                return math::isnan(lhs) ? result_type(V) : lhs;
+            }
+        };
+    }
+
+    /**
+     * @defgroup  nan_functions nan functions
+     */
+
+    /**
+     * @ingroup nan_functions
+     * @brief Convert nan or +/- inf to numbers
+     *
+     * This functions converts NaN to 0, and +inf to the highest, -inf to the lowest
+     * floating point value of the same type.
+     *
+     * @param e input \ref xexpression
+     * @return an \ref xexpression
+     */
+    template <class E>
+    inline auto nan_to_num(E&& e)
+    {
+        return detail::make_xfunction<detail::nan_to_num_functor>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup nan_functions
+     * @brief Minimum element over given axes, ignoring NaNs.
+     *
+     * Returns an \ref xreducer for the minimum of elements over given
+     * @p axes, ignoring NaNs.
+     * @warning Casting the result to an integer type can cause undefined behavior.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the minimum is found (optional)
+     * @param es evaluation strategy of the reducer (optional)
+     * @tparam T the result type. The default is `E::value_type`.
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(nanmin, detail::nan_min, typename std::decay_t<E>::value_type, std::nan("0"))
+
+    /**
+     * @ingroup nan_functions
+     * @brief Maximum element along given axes, ignoring NaNs.
+     *
+     * Returns an \ref xreducer for the sum of elements over given
+     * @p axes, ignoring NaN.
+     * @warning Casting the result to an integer type can cause undefined behavior.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the sum is performed (optional)
+     * @param es evaluation strategy of the reducer (optional)
+     * @tparam T the result type. The default is `E::value_type`.
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(nanmax, detail::nan_max, typename std::decay_t<E>::value_type, std::nan("0"))
+
+    /**
+     * @ingroup nan_functions
+     * @brief Sum of elements over given axes, replacing NaN with 0.
+     *
+     * Returns an \ref xreducer for the sum of elements over given
+     * @p axes, ignoring NaN.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the sum is performed (optional)
+     * @param es evaluation strategy of the reducer (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T` is also used for determining the value type
+     *           of the result, which is the type of `T() + E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(nansum, detail::nan_plus, typename std::decay_t<E>::value_type, 0)
+
+    /**
+     * @ingroup nan_functions
+     * @brief Product of elements over given axes, replacing NaN with 1.
+     *
+     * Returns an \ref xreducer for the sum of elements over given
+     * @p axes, replacing nan with 1.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the sum is performed (optional)
+     * @param es evaluation strategy of the reducer (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T` is also used for determining the value type
+     *           of the result, which is the type of `T() * E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xreducer
+     */
+    XTENSOR_REDUCER_FUNCTION(nanprod, detail::nan_multiplies, typename std::decay_t<E>::value_type, 1)
+
+#define COUNT_NON_ZEROS_CONTENT                                                             \
+    using value_type = typename std::decay_t<E>::value_type;                                \
+    using result_type = xt::detail::xreducer_size_type_t<value_type>;                       \
+    using init_value_fct = xt::const_value<result_type>;                                    \
+                                                                                            \
+    auto init_fct = init_value_fct(0);                                                      \
+                                                                                            \
+    auto reduce_fct = [](const auto& lhs, const auto& rhs)                                  \
+    {                                                                                       \
+        using value_t = xt::detail::xreducer_temporary_type_t<std::decay_t<decltype(rhs)>>; \
+        using result_t = std::decay_t<decltype(lhs)>;                                       \
+                                                                                            \
+        return (rhs != value_t(0)) ? lhs + result_t(1) : lhs;                               \
+    };                                                                                      \
+    auto merge_func = detail::plus();
+
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto count_nonzero(E&& e, EVS es = EVS())
+    {
+        COUNT_NON_ZEROS_CONTENT;
+        return xt::reduce(
+            make_xreducer_functor(std::move(reduce_fct), std::move(init_fct), std::move(merge_func)),
+            std::forward<E>(e),
+            es
+        );
+    }
+
+    template <
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<X>>)>
+    inline auto count_nonzero(E&& e, X&& axes, EVS es = EVS())
+    {
+        COUNT_NON_ZEROS_CONTENT;
+        return xt::reduce(
+            make_xreducer_functor(std::move(reduce_fct), std::move(init_fct), std::move(merge_func)),
+            std::forward<E>(e),
+            std::forward<X>(axes),
+            es
+        );
+    }
+
+    template <
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<X>)>
+    inline auto count_nonzero(E&& e, X axis, EVS es = EVS())
+    {
+        return count_nonzero(std::forward<E>(e), {axis}, es);
+    }
+
+    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto count_nonzero(E&& e, const I (&axes)[N], EVS es = EVS())
+    {
+        COUNT_NON_ZEROS_CONTENT;
+        return xt::reduce(
+            make_xreducer_functor(std::move(reduce_fct), std::move(init_fct), std::move(merge_func)),
+            std::forward<E>(e),
+            axes,
+            es
+        );
+    }
+
+#undef COUNT_NON_ZEROS_CONTENT
+
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto count_nonnan(E&& e, EVS es = EVS())
+    {
+        return xt::count_nonzero(!xt::isnan(std::forward<E>(e)), es);
+    }
+
+    template <
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<X>>)>
+    inline auto count_nonnan(E&& e, X&& axes, EVS es = EVS())
+    {
+        return xt::count_nonzero(!xt::isnan(std::forward<E>(e)), std::forward<X>(axes), es);
+    }
+
+    template <
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, xtl::is_integral<X>)>
+    inline auto count_nonnan(E&& e, X&& axes, EVS es = EVS())
+    {
+        return xt::count_nonzero(!xt::isnan(std::forward<E>(e)), {axes}, es);
+    }
+
+    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto count_nonnan(E&& e, const I (&axes)[N], EVS es = EVS())
+    {
+        return xt::count_nonzero(!xt::isnan(std::forward<E>(e)), axes, es);
+    }
+
+    /**
+     * @ingroup nan_functions
+     * @brief Cumulative sum, replacing nan with 0.
+     *
+     * Returns an xaccumulator for the sum of elements over given
+     * \em axis, replacing nan with 0.
+     * @param e an \ref xexpression
+     * @param axis the axis along which the elements are accumulated (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T` is also used for determining the value type
+     *           of the result, which is the type of `T() + E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an xaccumulator
+     */
+    template <class T = void, class E>
+    inline auto nancumsum(E&& e, std::ptrdiff_t axis)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::nan_plus(), detail::nan_init<init_value_type, 0>()),
+            std::forward<E>(e),
+            axis
+        );
+    }
+
+    template <class T = void, class E>
+    inline auto nancumsum(E&& e)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::nan_plus(), detail::nan_init<init_value_type, 0>()),
+            std::forward<E>(e)
+        );
+    }
+
+    /**
+     * @ingroup nan_functions
+     * @brief Cumulative product, replacing nan with 1.
+     *
+     * Returns an xaccumulator for the product of elements over given
+     * \em axis, replacing nan with 1.
+     * @param e an \ref xexpression
+     * @param axis the axis along which the elements are accumulated (optional)
+     * @tparam T the value type used for internal computation. The default is
+     *           `E::value_type`. `T` is also used for determining the value type
+     *           of the result, which is the type of `T() * E::value_type()`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an xaccumulator
+     */
+    template <class T = void, class E>
+    inline auto nancumprod(E&& e, std::ptrdiff_t axis)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::nan_multiplies(), detail::nan_init<init_value_type, 1>()),
+            std::forward<E>(e),
+            axis
+        );
+    }
+
+    template <class T = void, class E>
+    inline auto nancumprod(E&& e)
+    {
+        using init_value_type = std::conditional_t<std::is_same<T, void>::value, typename std::decay_t<E>::value_type, T>;
+        return accumulate(
+            make_xaccumulator_functor(detail::nan_multiplies(), detail::nan_init<init_value_type, 1>()),
+            std::forward<E>(e)
+        );
+    }
+
+    namespace detail
+    {
+        template <class T>
+        struct diff_impl
+        {
+            template <class Arg>
+            inline void operator()(
+                Arg& ad,
+                const std::size_t& n,
+                xstrided_slice_vector& slice1,
+                xstrided_slice_vector& slice2,
+                std::size_t saxis
+            )
+            {
+                for (std::size_t i = 0; i < n; ++i)
+                {
+                    slice2[saxis] = range(xnone(), ad.shape()[saxis] - 1);
+                    ad = strided_view(ad, slice1) - strided_view(ad, slice2);
+                }
+            }
+        };
+
+        template <>
+        struct diff_impl<bool>
+        {
+            template <class Arg>
+            inline void operator()(
+                Arg& ad,
+                const std::size_t& n,
+                xstrided_slice_vector& slice1,
+                xstrided_slice_vector& slice2,
+                std::size_t saxis
+            )
+            {
+                for (std::size_t i = 0; i < n; ++i)
+                {
+                    slice2[saxis] = range(xnone(), ad.shape()[saxis] - 1);
+                    ad = not_equal(strided_view(ad, slice1), strided_view(ad, slice2));
+                }
+            }
+        };
+    }
+
+    /**
+     * @ingroup nan_functions
+     * @brief Mean of elements over given axes, excluding NaNs.
+     *
+     * Returns an \ref xreducer for the mean of elements over given
+     * \em axes, excluding NaNs.
+     * This is not the same as counting NaNs as zero, since excluding NaNs changes the number
+     * of elements considered in the statistic.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the mean is computed (optional)
+     * @param es the evaluation strategy (optional)
+     * @tparam T the result type. The default is `E::value_type`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xexpression
+     */
+    template <
+        class T = void,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
+    inline auto nanmean(E&& e, X&& axes, EVS es = EVS())
+    {
+        decltype(auto) sc = detail::shared_forward<E>(e);
+        // note: forcing copy of first axes argument -- is there a better solution?
+        auto axes_copy = axes;
+        using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
+        using sum_type = typename std::conditional_t<
+            std::is_same<T, void>::value,
+            typename std::common_type_t<typename std::decay_t<E>::value_type, value_type>,
+            T>;
+        // sum cannot always be a double. It could be a complex number which cannot operate on
+        // std::plus<double>.
+        return nansum<sum_type>(sc, std::forward<X>(axes), es)
+               / xt::cast<value_type>(count_nonnan(sc, std::move(axes_copy), es));
+    }
+
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto nanmean(E&& e, EVS es = EVS())
+    {
+        decltype(auto) sc = detail::shared_forward<E>(e);
+        using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
+        using sum_type = typename std::conditional_t<
+            std::is_same<T, void>::value,
+            typename std::common_type_t<typename std::decay_t<E>::value_type, value_type>,
+            T>;
+        return nansum<sum_type>(sc, es) / xt::cast<value_type>(count_nonnan(sc, es));
+    }
+
+    template <class T = void, class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto nanmean(E&& e, const I (&axes)[N], EVS es = EVS())
+    {
+        return nanmean<T>(
+            std::forward<E>(e),
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(axes)>(axes),
+            es
+        );
+    }
+
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto nanvar(E&& e, EVS es = EVS())
+    {
+        decltype(auto) sc = detail::shared_forward<E>(e);
+        return nanmean<T>(square(sc - nanmean<T>(sc)), es);
+    }
+
+    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_reducer_options<EVS>)>
+    inline auto nanstd(E&& e, EVS es = EVS())
+    {
+        return sqrt(nanvar<T>(std::forward<E>(e), es));
+    }
+
+    /**
+     * @ingroup nan_functions
+     * @brief Compute the variance along the specified axes, excluding NaNs
+     *
+     * Returns the variance of the array elements, a measure of the spread of a
+     * distribution. The variance is computed for the flattened array by default,
+     * otherwise over the specified axes.
+     * Excluding NaNs changes the number of elements considered in the statistic.
+     *
+     * Note: this function is not yet specialized for complex numbers.
+     *
+     * @param e an \ref xexpression
+     * @param axes the axes along which the variance is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @tparam T the result type. The default is `E::value_type`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xexpression
+     *
+     * @sa nanstd, nanmean
+     */
+    template <
+        class T = void,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
+    inline auto nanvar(E&& e, X&& axes, EVS es = EVS())
+    {
+        decltype(auto) sc = detail::shared_forward<E>(e);
+        // note: forcing copy of first axes argument -- is there a better solution?
+        auto axes_copy = axes;
+        using result_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
+        auto inner_mean = nanmean<result_type>(sc, std::move(axes_copy));
+
+        // fake keep_dims = 1
+        // Since the inner_shape might have a reference semantic (e.g. xbuffer_adaptor in bindings)
+        // We need to map it to another type before modifying it.
+        // We pragmatically abuse `get_strides_t`
+        using tmp_shape_t = get_strides_t<typename std::decay_t<E>::shape_type>;
+        tmp_shape_t keep_dim_shape = xtl::forward_sequence<tmp_shape_t, decltype(e.shape())>(e.shape());
+        for (const auto& el : axes)
+        {
+            keep_dim_shape[el] = 1;
+        }
+        auto mrv = reshape_view<XTENSOR_DEFAULT_LAYOUT>(std::move(inner_mean), std::move(keep_dim_shape));
+        return nanmean<result_type>(square(cast<result_type>(sc) - std::move(mrv)), std::forward<X>(axes), es);
+    }
+
+    /**
+     * @ingroup nan_functions
+     * @brief Compute the standard deviation along the specified axis, excluding nans.
+     *
+     * Returns the standard deviation, a measure of the spread of a distribution,
+     * of the array elements. The standard deviation is computed for the flattened
+     * array by default, otherwise over the specified axis.
+     * Excluding NaNs changes the number of elements considered in the statistic.
+     *
+     * Note: this function is not yet specialized for complex numbers.
+     *
+     * @param e an \ref xexpression
+     * @param axes the axes along which the standard deviation is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @tparam T the result type. The default is `E::value_type`.
+     *           You can pass `big_promote_value_type_t<E>` to avoid overflow in computation.
+     * @return an \ref xexpression
+     *
+     * @sa nanvar, nanmean
+     */
+    template <
+        class T = void,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
+    inline auto nanstd(E&& e, X&& axes, EVS es = EVS())
+    {
+        return sqrt(nanvar<T>(std::forward<E>(e), std::forward<X>(axes), es));
+    }
+
+    template <class T = void, class E, class A, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto nanstd(E&& e, const A (&axes)[N], EVS es = EVS())
+    {
+        return nanstd<T>(
+            std::forward<E>(e),
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(axes)>(axes),
+            es
+        );
+    }
+
+    template <class T = void, class E, class A, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto nanvar(E&& e, const A (&axes)[N], EVS es = EVS())
+    {
+        return nanvar<T>(
+            std::forward<E>(e),
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(axes)>(axes),
+            es
+        );
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Calculate the n-th discrete difference along the given axis.
+     *
+     * Calculate the n-th discrete difference along the given axis. This function is not lazy (might change in
+     * the future).
+     * @param a an \ref xexpression
+     * @param n The number of times values are differenced. If zero, the input is returned as-is. (optional)
+     * @param axis The axis along which the difference is taken, default is the last axis.
+     * @return an xarray
+     */
+    template <class T>
+    auto diff(const xexpression<T>& a, std::size_t n = 1, std::ptrdiff_t axis = -1)
+    {
+        typename std::decay_t<T>::temporary_type ad = a.derived_cast();
+        std::size_t saxis = normalize_axis(ad.dimension(), axis);
+        if (n <= ad.size())
+        {
+            if (n != std::size_t(0))
+            {
+                xstrided_slice_vector slice1(ad.dimension(), all());
+                xstrided_slice_vector slice2(ad.dimension(), all());
+                slice1[saxis] = range(1, xnone());
+
+                detail::diff_impl<typename T::value_type> impl;
+                impl(ad, n, slice1, slice2, saxis);
+            }
+        }
+        else
+        {
+            auto shape = ad.shape();
+            shape[saxis] = std::size_t(0);
+            ad.resize(shape);
+        }
+        return ad;
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Integrate along the given axis using the composite trapezoidal rule.
+     *
+     * Returns definite integral as approximated by trapezoidal rule. This function is not lazy (might change
+     * in the future).
+     * @param y an \ref xexpression
+     * @param dx the spacing between sample points (optional)
+     * @param axis the axis along which to integrate.
+     * @return an xarray
+     */
+    template <class T>
+    auto trapz(const xexpression<T>& y, double dx = 1.0, std::ptrdiff_t axis = -1)
+    {
+        auto& yd = y.derived_cast();
+        std::size_t saxis = normalize_axis(yd.dimension(), axis);
+
+        xstrided_slice_vector slice1(yd.dimension(), all());
+        xstrided_slice_vector slice2(yd.dimension(), all());
+        slice1[saxis] = range(1, xnone());
+        slice2[saxis] = range(xnone(), yd.shape()[saxis] - 1);
+
+        auto trap = dx * (strided_view(yd, slice1) + strided_view(yd, slice2)) * 0.5;
+
+        return eval(sum(trap, {saxis}));
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Integrate along the given axis using the composite trapezoidal rule.
+     *
+     * Returns definite integral as approximated by trapezoidal rule. This function is not lazy (might change
+     * in the future).
+     * @param y an \ref xexpression
+     * @param x an \ref xexpression representing the sample points corresponding to the y values.
+     * @param axis the axis along which to integrate.
+     * @return an xarray
+     */
+    template <class T, class E>
+    auto trapz(const xexpression<T>& y, const xexpression<E>& x, std::ptrdiff_t axis = -1)
+    {
+        auto& yd = y.derived_cast();
+        auto& xd = x.derived_cast();
+        decltype(diff(x)) dx;
+
+        std::size_t saxis = normalize_axis(yd.dimension(), axis);
+
+        if (xd.dimension() == 1)
+        {
+            dx = diff(x);
+            typename std::decay_t<decltype(yd)>::shape_type shape;
+            resize_container(shape, yd.dimension());
+            std::fill(shape.begin(), shape.end(), 1);
+            shape[saxis] = dx.shape()[0];
+            dx.reshape(shape);
+        }
+        else
+        {
+            dx = diff(x, 1, axis);
+        }
+
+        xstrided_slice_vector slice1(yd.dimension(), all());
+        xstrided_slice_vector slice2(yd.dimension(), all());
+        slice1[saxis] = range(1, xnone());
+        slice2[saxis] = range(xnone(), yd.shape()[saxis] - 1);
+
+        auto trap = dx * (strided_view(yd, slice1) + strided_view(yd, slice2)) * 0.5;
+
+        return eval(sum(trap, {saxis}));
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Returns the one-dimensional piecewise linear interpolant to a function with given discrete data
+     * points (xp, fp), evaluated at x.
+     *
+     * @param x The x-coordinates at which to evaluate the interpolated values (sorted).
+     * @param xp The x-coordinates of the data points (sorted).
+     * @param fp The y-coordinates of the data points, same length as xp.
+     * @param left Value to return for x < xp[0].
+     * @param right Value to return for x > xp[-1]
+     * @return an one-dimensional xarray, same length as x.
+     */
+    template <class E1, class E2, class E3, typename T>
+    inline auto interp(const E1& x, const E2& xp, const E3& fp, T left, T right)
+    {
+        using size_type = common_size_type_t<E1, E2, E3>;
+        using value_type = typename E3::value_type;
+
+        // basic checks
+        XTENSOR_ASSERT(xp.dimension() == 1);
+        XTENSOR_ASSERT(std::is_sorted(x.cbegin(), x.cend()));
+        XTENSOR_ASSERT(std::is_sorted(xp.cbegin(), xp.cend()));
+
+        // allocate output
+        auto f = xtensor<value_type, 1>::from_shape(x.shape());
+
+        // counter in "x": from left
+        size_type i = 0;
+
+        // fill f[i] for x[i] <= xp[0]
+        for (; i < x.size(); ++i)
+        {
+            if (x[i] > xp[0])
+            {
+                break;
+            }
+            f[i] = static_cast<value_type>(left);
+        }
+
+        // counter in "x": from right
+        // (index counts one right, to terminate the reverse loop, without risking being negative)
+        size_type imax = x.size();
+
+        // fill f[i] for x[-1] >= xp[-1]
+        for (; imax > 0; --imax)
+        {
+            if (x[imax - 1] < xp[xp.size() - 1])
+            {
+                break;
+            }
+            f[imax - 1] = static_cast<value_type>(right);
+        }
+
+        // catch edge case: all entries are "right"
+        if (imax == 0)
+        {
+            return f;
+        }
+
+        // set "imax" as actual index
+        // (counted one right, see above)
+        --imax;
+
+        // counter in "xp"
+        size_type ip = 1;
+
+        // fill f[i] for the interior
+        for (; i <= imax; ++i)
+        {
+            // - search next value in "xp"
+            while (x[i] > xp[ip])
+            {
+                ++ip;
+            }
+            // - distances as doubles
+            double dfp = static_cast<double>(fp[ip] - fp[ip - 1]);
+            double dxp = static_cast<double>(xp[ip] - xp[ip - 1]);
+            double dx = static_cast<double>(x[i] - xp[ip - 1]);
+            // - interpolate
+            f[i] = fp[ip - 1] + static_cast<value_type>(dfp / dxp * dx);
+        }
+
+        return f;
+    }
+
+    namespace detail
+    {
+        template <class E1, class E2>
+        auto calculate_discontinuity(E1&& discontinuity, E2&&)
+        {
+            return discontinuity;
+        }
+
+        template <class E2>
+        auto calculate_discontinuity(xt::placeholders::xtuph, E2&& period)
+        {
+            return 0.5 * period;
+        }
+
+        template <class E1, class E2>
+        auto
+        calculate_interval(E2&& period, typename std::enable_if<std::is_integral<E1>::value, E1>::type* = 0)
+        {
+            auto interval_high = 0.5 * period;
+            uint64_t remainder = static_cast<uint64_t>(period) % 2;
+            auto boundary_ambiguous = (remainder == 0);
+            return std::make_tuple(interval_high, boundary_ambiguous);
+        }
+
+        template <class E1, class E2>
+        auto
+        calculate_interval(E2&& period, typename std::enable_if<std::is_floating_point<E1>::value, E1>::type* = 0)
+        {
+            auto interval_high = 0.5 * period;
+            auto boundary_ambiguous = true;
+            return std::make_tuple(interval_high, boundary_ambiguous);
+        }
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Unwrap by taking the complement of large deltas with respect to the period
+     * @details https://numpy.org/doc/stable/reference/generated/numpy.unwrap.html
+     * @param p Input array.
+     * @param discontinuity
+     *     Maximum discontinuity between values, default is `period / 2`.
+     *     Values below `period / 2` are treated as if they were `period / 2`.
+     *     To have an effect different from the default, use `discontinuity > period / 2`.
+     * @param axis Axis along which unwrap will operate, default: the last axis.
+     * @param period Size of the range over which the input wraps. Default: \f$ 2 \pi \f$.
+     */
+
+    template <class E1, class E2 = xt::placeholders::xtuph, class E3 = double>
+    inline auto unwrap(
+        E1&& p,
+        E2 discontinuity = xnone(),
+        std::ptrdiff_t axis = -1,
+        E3 period = 2.0 * xt::numeric_constants<double>::PI
+    )
+    {
+        auto discont = detail::calculate_discontinuity(discontinuity, period);
+        using value_type = typename std::decay_t<E1>::value_type;
+        std::size_t saxis = normalize_axis(p.dimension(), axis);
+        auto dd = diff(p, 1, axis);
+        xstrided_slice_vector slice(p.dimension(), all());
+        slice[saxis] = range(1, xnone());
+        auto interval_tuple = detail::calculate_interval<value_type>(period);
+        auto interval_high = std::get<0>(interval_tuple);
+        auto boundary_ambiguous = std::get<1>(interval_tuple);
+        auto interval_low = -interval_high;
+        auto ddmod = xt::eval(xt::fmod(xt::fmod(dd - interval_low, period) + period, period) + interval_low);
+        if (boundary_ambiguous)
+        {
+            // for `mask = (abs(dd) == period/2)`, the above line made
+            //`ddmod[mask] == -period/2`. correct these such that
+            //`ddmod[mask] == sign(dd[mask])*period/2`.
+            auto boolmap = xt::equal(ddmod, interval_low) && (xt::greater(dd, 0.0));
+            ddmod = xt::where(boolmap, interval_high, ddmod);
+        }
+        auto ph_correct = xt::eval(ddmod - dd);
+        ph_correct = xt::where(xt::abs(dd) < discont, 0.0, ph_correct);
+        E1 up(p);
+        strided_view(up, slice) = strided_view(p, slice)
+                                  + xt::cumsum(ph_correct, static_cast<std::ptrdiff_t>(saxis));
+        return up;
+    }
+
+    /**
+     * @ingroup basic_functions
+     * @brief Returns the one-dimensional piecewise linear interpolant to a function with given discrete data
+     * points (xp, fp), evaluated at x.
+     *
+     * @param x The x-coordinates at which to evaluate the interpolated values (sorted).
+     * @param xp The x-coordinates of the data points (sorted).
+     * @param fp The y-coordinates of the data points, same length as xp.
+     * @return an one-dimensional xarray, same length as x.
+     */
+    template <class E1, class E2, class E3>
+    inline auto interp(const E1& x, const E2& xp, const E3& fp)
+    {
+        return interp(x, xp, fp, fp[0], fp[fp.size() - 1]);
+    }
+
+    /**
+     * @brief Returns the covariance matrix
+     *
+     * @param x one or two dimensional array
+     * @param y optional one-dimensional array to build covariance to x
+     */
+    template <class E1>
+    inline auto cov(const E1& x, const E1& y = E1())
+    {
+        using value_type = typename E1::value_type;
+
+        if (y.dimension() == 0)
+        {
+            auto s = x.shape();
+            using size_type = std::decay_t<decltype(s[0])>;
+            if (x.dimension() == 1)
+            {
+                auto covar = eval(zeros<value_type>({1, 1}));
+                auto x_norm = x - eval(mean(x));
+                covar(0, 0) = std::inner_product(x_norm.begin(), x_norm.end(), x_norm.begin(), 0.0)
+                              / value_type(s[0] - 1);
+                return covar;
+            }
+
+            XTENSOR_ASSERT(x.dimension() == 2);
+
+            auto covar = eval(zeros<value_type>({s[0], s[0]}));
+            auto m = eval(mean(x, {1}));
+            m.reshape({m.shape()[0], 1});
+            auto x_norm = x - m;
+            for (size_type i = 0; i < s[0]; i++)
+            {
+                auto xi = strided_view(x_norm, {range(i, i + 1), all()});
+                for (size_type j = i; j < s[0]; j++)
+                {
+                    auto xj = strided_view(x_norm, {range(j, j + 1), all()});
+                    covar(j, i) = std::inner_product(xi.begin(), xi.end(), xj.begin(), 0.0)
+                                  / value_type(s[1] - 1);
+                }
+            }
+            return eval(covar + transpose(covar) - diag(diagonal(covar)));
+        }
+        else
+        {
+            return cov(eval(stack(xtuple(x, y))));
+        }
+    }
+
+    /*
+     * convolution mode placeholders for selecting the algorithm
+     * used in computing a 1D convolution.
+     * Same as NumPy's mode parameter.
+     */
+    namespace convolve_mode
+    {
+        struct valid
+        {
+        };
+
+        struct full
+        {
+        };
+    }
+
+    namespace detail
+    {
+        template <class E1, class E2>
+        inline auto convolve_impl(E1&& e1, E2&& e2, convolve_mode::valid)
+        {
+            using value_type = typename std::decay<E1>::type::value_type;
+
+            const std::size_t na = e1.size();
+            const std::size_t nv = e2.size();
+            const std::size_t n = na - nv + 1;
+            xt::xtensor<value_type, 1> out = xt::zeros<value_type>({n});
+            for (std::size_t i = 0; i < n; i++)
+            {
+                for (std::size_t j = 0; j < nv; j++)
+                {
+                    out(i) += e1(j) * e2(j + i);
+                }
+            }
+            return out;
+        }
+
+        template <class E1, class E2>
+        inline auto convolve_impl(E1&& e1, E2&& e2, convolve_mode::full)
+        {
+            using value_type = typename std::decay<E1>::type::value_type;
+
+            const std::size_t na = e1.size();
+            const std::size_t nv = e2.size();
+            const std::size_t n = na + nv - 1;
+            xt::xtensor<value_type, 1> out = xt::zeros<value_type>({n});
+            for (std::size_t i = 0; i < n; i++)
+            {
+                const std::size_t jmn = (i >= nv - 1) ? i - (nv - 1) : 0;
+                const std::size_t jmx = (i < na - 1) ? i : na - 1;
+                for (std::size_t j = jmn; j <= jmx; ++j)
+                {
+                    out(i) += e1(j) * e2(i - j);
+                }
+            }
+            return out;
+        }
+    }
+
+    /*
+     * @brief computes the 1D convolution between two 1D expressions
+     *
+     * @param a 1D expression
+     * @param v 1D expression
+     * @param mode placeholder Select algorithm #convolve_mode
+     *
+     * @detail the algorithm convolves a with v and will incur a copy overhead
+     *   should v be longer than a.
+     */
+    template <class E1, class E2, class E3>
+    inline auto convolve(E1&& a, E2&& v, E3 mode)
+    {
+        if (a.dimension() != 1 || v.dimension() != 1)
+        {
+            XTENSOR_THROW(std::runtime_error, "Invalid dimentions convolution arguments must be 1D expressions");
+        }
+
+        XTENSOR_ASSERT(a.size() > 0 && v.size() > 0);
+
+        // swap them so a is always the longest one
+        if (a.size() < v.size())
+        {
+            return detail::convolve_impl(std::forward<E2>(v), std::forward<E1>(a), mode);
+        }
+        else
+        {
+            return detail::convolve_impl(std::forward<E1>(a), std::forward<E2>(v), mode);
+        }
+    }
+}
+
+
+#endif
diff --git a/include/xtensor/core/xmultiindex_iterator.hpp b/include/xtensor/core/xmultiindex_iterator.hpp
new file mode 100644
index 000000000..f0fdd041b
--- /dev/null
+++ b/include/xtensor/core/xmultiindex_iterator.hpp
@@ -0,0 +1,131 @@
+/***************************************************************************
+ * 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_XMULTIINDEX_ITERATOR
+#define XTENSOR_XMULTIINDEX_ITERATOR
+
+#include "../views/xstrided_view.hpp"
+#include "xtl/xsequence.hpp"
+
+namespace xt
+{
+
+    template <class S>
+    class xmultiindex_iterator
+    {
+    public:
+
+        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;
+
+        xmultiindex_iterator() = default;
+
+        template <class B, class E, class C>
+        xmultiindex_iterator(B&& begin, E&& end, C&& current, const std::size_t linear_index)
+            : m_begin(std::forward<B>(begin))
+            , m_end(std::forward<E>(end))
+            , m_current(std::forward<C>(current))
+            , m_linear_index(linear_index)
+        {
+        }
+
+        self_type& operator++()
+        {
+            std::size_t i = m_begin.size();
+            while (i != 0)
+            {
+                --i;
+                if (m_current[i] + 1u == m_end[i])
+                {
+                    m_current[i] = m_begin[i];
+                }
+                else
+                {
+                    m_current[i] += 1;
+                    break;
+                }
+            }
+            m_linear_index++;
+            return *this;
+        }
+
+        self_type operator++(int)
+        {
+            self_type it = *this;
+            ++(*this);
+            return it;
+        }
+
+        shape_type& operator*()
+        {
+            return m_current;
+        }
+
+        const shape_type& operator*() const
+        {
+            return m_current;
+        }
+
+        bool operator==(const self_type& rhs) const
+        {
+            return m_linear_index == rhs.m_linear_index;
+        }
+
+        bool operator!=(const self_type& rhs) const
+        {
+            return !this->operator==(rhs);
+        }
+
+    private:
+
+        shape_type m_begin;
+        shape_type m_end;
+        shape_type m_current;
+        std::size_t m_linear_index{0};
+    };
+
+    template <class S, class B, class E>
+    auto multiindex_iterator_begin(B&& roi_begin, E&& roi_end)
+    {
+        S current;
+        resize_container(current, roi_begin.size());
+        std::copy(roi_begin.begin(), roi_begin.end(), current.begin());
+        return xmultiindex_iterator<S>(std::forward<B>(roi_begin), std::forward<E>(roi_end), std::move(current), 0);
+    }
+
+    template <class S, class B, class E>
+    auto multiindex_iterator_end(B&& roi_begin, E&& roi_end)
+    {
+        S current;
+        resize_container(current, roi_begin.size());
+        std::copy(roi_end.begin(), roi_end.end(), current.begin());
+
+        std::size_t linear_index = 1;
+        for (std::size_t i = 0; i < roi_begin.size(); ++i)
+        {
+            linear_index *= roi_end[i] - roi_begin[i];
+        }
+
+        return xmultiindex_iterator<S>(
+            std::forward<B>(roi_begin),
+            std::forward<E>(roi_end),
+            std::move(current),
+            linear_index
+        );
+    }
+
+}
+
+#endif
diff --git a/include/xtensor/xnoalias.hpp b/include/xtensor/core/xnoalias.hpp
similarity index 89%
rename from include/xtensor/xnoalias.hpp
rename to include/xtensor/core/xnoalias.hpp
index a0aec84cd..7d95a3b1a 100644
--- a/include/xtensor/xnoalias.hpp
+++ b/include/xtensor/core/xnoalias.hpp
@@ -1,15 +1,16 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_NOALIAS_HPP
 #define XTENSOR_NOALIAS_HPP
 
-#include "xsemantic.hpp"
+#include "../core/xsemantic.hpp"
 
 namespace xt
 {
@@ -17,7 +18,6 @@ namespace xt
     template <class A>
     class noalias_proxy
     {
-
     public:
 
         noalias_proxy(A a) noexcept;
@@ -221,8 +221,7 @@ namespace xt
     }
 
     template <class A>
-    inline noalias_proxy<xtl::closure_type_t<A>>
-    noalias(A&& a) noexcept
+    inline noalias_proxy<xtl::closure_type_t<A>> noalias(A&& a) noexcept
     {
         return noalias_proxy<xtl::closure_type_t<A>>(a);
     }
diff --git a/include/xtensor/core/xoperation.hpp b/include/xtensor/core/xoperation.hpp
new file mode 100644
index 000000000..76bfc7c50
--- /dev/null
+++ b/include/xtensor/core/xoperation.hpp
@@ -0,0 +1,996 @@
+/***************************************************************************
+ * 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_OPERATION_HPP
+#define XTENSOR_OPERATION_HPP
+
+#include <algorithm>
+#include <type_traits>
+
+#include <xtl/xsequence.hpp>
+
+#include "../containers/xscalar.hpp"
+#include "../core/xfunction.hpp"
+#include "../core/xstrides.hpp"
+#include "../views/xstrided_view.hpp"
+
+namespace xt
+{
+
+    /***********
+     * helpers *
+     ***********/
+
+#define UNARY_OPERATOR_FUNCTOR(NAME, OP)               \
+    struct NAME                                        \
+    {                                                  \
+        template <class A1>                            \
+        constexpr auto operator()(const A1& arg) const \
+        {                                              \
+            return OP arg;                             \
+        }                                              \
+        template <class B>                             \
+        constexpr auto simd_apply(const B& arg) const  \
+        {                                              \
+            return OP arg;                             \
+        }                                              \
+    }
+
+#define DEFINE_COMPLEX_OVERLOAD(OP)                                                           \
+    template <class T1, class T2, XTL_REQUIRES(std::negation<std::is_same<T1, T2>>)>          \
+    constexpr auto operator OP(const std::complex<T1>& arg1, const std::complex<T2>& arg2)    \
+    {                                                                                         \
+        using result_type = typename xtl::promote_type_t<std::complex<T1>, std::complex<T2>>; \
+        return (result_type(arg1) OP result_type(arg2));                                      \
+    }                                                                                         \
+                                                                                              \
+    template <class T1, class T2, XTL_REQUIRES(std::negation<std::is_same<T1, T2>>)>          \
+    constexpr auto operator OP(const T1& arg1, const std::complex<T2>& arg2)                  \
+    {                                                                                         \
+        using result_type = typename xtl::promote_type_t<T1, std::complex<T2>>;               \
+        return (result_type(arg1) OP result_type(arg2));                                      \
+    }                                                                                         \
+                                                                                              \
+    template <class T1, class T2, XTL_REQUIRES(std::negation<std::is_same<T1, T2>>)>          \
+    constexpr auto operator OP(const std::complex<T1>& arg1, const T2& arg2)                  \
+    {                                                                                         \
+        using result_type = typename xtl::promote_type_t<std::complex<T1>, T2>;               \
+        return (result_type(arg1) OP result_type(arg2));                                      \
+    }
+
+#define BINARY_OPERATOR_FUNCTOR(NAME, OP)                              \
+    struct NAME                                                        \
+    {                                                                  \
+        template <class T1, class T2>                                  \
+        constexpr auto operator()(T1&& arg1, T2&& arg2) const          \
+        {                                                              \
+            using xt::detail::operator OP;                             \
+            return (std::forward<T1>(arg1) OP std::forward<T2>(arg2)); \
+        }                                                              \
+        template <class B>                                             \
+        constexpr auto simd_apply(const B& arg1, const B& arg2) const  \
+        {                                                              \
+            return (arg1 OP arg2);                                     \
+        }                                                              \
+    }
+
+    namespace detail
+    {
+        DEFINE_COMPLEX_OVERLOAD(+);
+        DEFINE_COMPLEX_OVERLOAD(-);
+        DEFINE_COMPLEX_OVERLOAD(*);
+        DEFINE_COMPLEX_OVERLOAD(/);
+        DEFINE_COMPLEX_OVERLOAD(%);
+        DEFINE_COMPLEX_OVERLOAD(||);
+        DEFINE_COMPLEX_OVERLOAD(&&);
+        DEFINE_COMPLEX_OVERLOAD(|);
+        DEFINE_COMPLEX_OVERLOAD(&);
+        DEFINE_COMPLEX_OVERLOAD(^);
+        DEFINE_COMPLEX_OVERLOAD(<<);
+        DEFINE_COMPLEX_OVERLOAD(>>);
+        DEFINE_COMPLEX_OVERLOAD(<);
+        DEFINE_COMPLEX_OVERLOAD(<=);
+        DEFINE_COMPLEX_OVERLOAD(>);
+        DEFINE_COMPLEX_OVERLOAD(>=);
+        DEFINE_COMPLEX_OVERLOAD(==);
+        DEFINE_COMPLEX_OVERLOAD(!=);
+
+        UNARY_OPERATOR_FUNCTOR(identity, +);
+        UNARY_OPERATOR_FUNCTOR(negate, -);
+        BINARY_OPERATOR_FUNCTOR(plus, +);
+        BINARY_OPERATOR_FUNCTOR(minus, -);
+        BINARY_OPERATOR_FUNCTOR(multiplies, *);
+        BINARY_OPERATOR_FUNCTOR(divides, /);
+        BINARY_OPERATOR_FUNCTOR(modulus, %);
+        BINARY_OPERATOR_FUNCTOR(logical_or, ||);
+        BINARY_OPERATOR_FUNCTOR(logical_and, &&);
+        UNARY_OPERATOR_FUNCTOR(logical_not, !);
+        BINARY_OPERATOR_FUNCTOR(bitwise_or, |);
+        BINARY_OPERATOR_FUNCTOR(bitwise_and, &);
+        BINARY_OPERATOR_FUNCTOR(bitwise_xor, ^);
+        UNARY_OPERATOR_FUNCTOR(bitwise_not, ~);
+        BINARY_OPERATOR_FUNCTOR(left_shift, <<);
+        BINARY_OPERATOR_FUNCTOR(right_shift, >>);
+        BINARY_OPERATOR_FUNCTOR(less, <);
+        BINARY_OPERATOR_FUNCTOR(less_equal, <=);
+        BINARY_OPERATOR_FUNCTOR(greater, >);
+        BINARY_OPERATOR_FUNCTOR(greater_equal, >=);
+        BINARY_OPERATOR_FUNCTOR(equal_to, ==);
+        BINARY_OPERATOR_FUNCTOR(not_equal_to, !=);
+
+        struct conditional_ternary
+        {
+            template <class B>
+            using get_batch_bool = typename xt_simd::simd_traits<typename xt_simd::revert_simd_traits<B>::type>::bool_type;
+
+            template <class B, class A1, class A2>
+            constexpr auto operator()(const B& cond, const A1& v1, const A2& v2) const noexcept
+            {
+                return xtl::select(cond, v1, v2);
+            }
+
+            template <class B>
+            constexpr B simd_apply(const get_batch_bool<B>& t1, const B& t2, const B& t3) const noexcept
+            {
+                return xt_simd::select(t1, t2, t3);
+            }
+        };
+
+        template <class R>
+        struct cast
+        {
+            struct functor
+            {
+                using result_type = R;
+
+                template <class A1>
+                constexpr result_type operator()(const A1& arg) const
+                {
+                    return static_cast<R>(arg);
+                }
+
+                // SIMD conversion disabled for now since it does not make sense
+                // in most of the cases
+                /*constexpr simd_result_type simd_apply(const simd_value_type& arg) const
+                {
+                    return static_cast<R>(arg);
+                }*/
+            };
+        };
+
+        template <class Tag, class F, class... E>
+        struct select_xfunction_expression;
+
+        template <class F, class... E>
+        struct select_xfunction_expression<xtensor_expression_tag, F, E...>
+        {
+            using type = xfunction<F, E...>;
+        };
+
+        template <class F, class... E>
+        struct select_xfunction_expression<xoptional_expression_tag, F, E...>
+        {
+            using type = xfunction<F, E...>;
+        };
+
+        template <class Tag, class F, class... E>
+        using select_xfunction_expression_t = typename select_xfunction_expression<Tag, F, E...>::type;
+
+        template <class F, class... E>
+        struct xfunction_type
+        {
+            using expression_tag = xexpression_tag_t<E...>;
+            using functor_type = F;
+            using type = select_xfunction_expression_t<expression_tag, functor_type, const_xclosure_t<E>...>;
+        };
+
+        template <class F, class... E>
+        inline auto make_xfunction(E&&... e) noexcept
+        {
+            using function_type = xfunction_type<F, E...>;
+            using functor_type = typename function_type::functor_type;
+            using type = typename function_type::type;
+            return type(functor_type(), std::forward<E>(e)...);
+        }
+
+        // On MSVC, the second argument of enable_if_t is always evaluated, even if the condition is false.
+        // Wrapping the xfunction type in the xfunction_type metafunction avoids this evaluation when
+        // the condition is false, since it leads to a tricky bug preventing from using operator+ and
+        // operator- on vector and arrays iterators.
+        template <class F, class... E>
+        using xfunction_type_t = typename std::
+            enable_if_t<has_xexpression<std::decay_t<E>...>::value, xfunction_type<F, E...>>::type;
+    }
+
+#undef UNARY_OPERATOR_FUNCTOR
+#undef BINARY_OPERATOR_FUNCTOR
+
+    /*************
+     * operators *
+     *************/
+
+    /**
+     * @defgroup arithmetic_operators Arithmetic operators
+     */
+
+    /**
+     * @ingroup arithmetic_operators
+     * @brief Identity
+     *
+     * Returns an \ref xfunction for the element-wise identity
+     * of \a e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto operator+(E&& e) noexcept -> detail::xfunction_type_t<detail::identity, E>
+    {
+        return detail::make_xfunction<detail::identity>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup arithmetic_operators
+     * @brief Opposite
+     *
+     * Returns an \ref xfunction for the element-wise opposite
+     * of \a e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto operator-(E&& e) noexcept -> detail::xfunction_type_t<detail::negate, E>
+    {
+        return detail::make_xfunction<detail::negate>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup arithmetic_operators
+     * @brief Addition
+     *
+     * Returns an \ref xfunction for the element-wise addition
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator+(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::plus, E1, E2>
+    {
+        return detail::make_xfunction<detail::plus>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup arithmetic_operators
+     * @brief Substraction
+     *
+     * Returns an \ref xfunction for the element-wise substraction
+     * of \a e2 to \a e1.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator-(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::minus, E1, E2>
+    {
+        return detail::make_xfunction<detail::minus>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup arithmetic_operators
+     * @brief Multiplication
+     *
+     * Returns an \ref xfunction for the element-wise multiplication
+     * of \a e1 by \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator*(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::multiplies, E1, E2>
+    {
+        return detail::make_xfunction<detail::multiplies>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup arithmetic_operators
+     * @brief Division
+     *
+     * Returns an \ref xfunction for the element-wise division
+     * of \a e1 by \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator/(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::divides, E1, E2>
+    {
+        return detail::make_xfunction<detail::divides>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup arithmetic_operators
+     * @brief Modulus
+     *
+     * Returns an \ref xfunction for the element-wise modulus
+     * of \a e1 by \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator%(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::modulus, E1, E2>
+    {
+        return detail::make_xfunction<detail::modulus>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @defgroup logical_operators Logical operators
+     */
+
+    /**
+     * @ingroup logical_operators
+     * @brief Or
+     *
+     * Returns an \ref xfunction for the element-wise or
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator||(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::logical_or, E1, E2>
+    {
+        return detail::make_xfunction<detail::logical_or>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief And
+     *
+     * Returns an \ref xfunction for the element-wise and
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator&&(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::logical_and, E1, E2>
+    {
+        return detail::make_xfunction<detail::logical_and>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief Not
+     *
+     * Returns an \ref xfunction for the element-wise not
+     * of \a e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto operator!(E&& e) noexcept -> detail::xfunction_type_t<detail::logical_not, E>
+    {
+        return detail::make_xfunction<detail::logical_not>(std::forward<E>(e));
+    }
+
+    /**
+     * @defgroup bitwise_operators Bitwise operators
+     */
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise and
+     *
+     * Returns an \ref xfunction for the element-wise bitwise and
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator&(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::bitwise_and, E1, E2>
+    {
+        return detail::make_xfunction<detail::bitwise_and>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise or
+     *
+     * Returns an \ref xfunction for the element-wise bitwise or
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator|(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::bitwise_or, E1, E2>
+    {
+        return detail::make_xfunction<detail::bitwise_or>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise xor
+     *
+     * Returns an \ref xfunction for the element-wise bitwise xor
+     * of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator^(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::bitwise_xor, E1, E2>
+    {
+        return detail::make_xfunction<detail::bitwise_xor>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise not
+     *
+     * Returns an \ref xfunction for the element-wise bitwise not
+     * of \a e.
+     * @param e an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E>
+    inline auto operator~(E&& e) noexcept -> detail::xfunction_type_t<detail::bitwise_not, E>
+    {
+        return detail::make_xfunction<detail::bitwise_not>(std::forward<E>(e));
+    }
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise left shift
+     *
+     * Returns an \ref xfunction for the element-wise bitwise left shift of e1
+     * by e2.
+     * @param e1 an \ref xexpression
+     * @param e2 an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto left_shift(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::left_shift, E1, E2>
+    {
+        return detail::make_xfunction<detail::left_shift>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise left shift
+     *
+     * Returns an \ref xfunction for the element-wise bitwise left shift of e1
+     * by e2.
+     * @param e1 an \ref xexpression
+     * @param e2 an \ref xexpression
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto right_shift(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::right_shift, E1, E2>
+    {
+        return detail::make_xfunction<detail::right_shift>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    namespace detail
+    {
+        // Shift operator is not available for all the types, so the xfunction type instantiation
+        // has to be delayed, enable_if_t is not sufficient
+        template <class F, class E1, class E2>
+        struct shift_function_getter
+        {
+            using type = xfunction_type_t<F, E1, E2>;
+        };
+
+        template <bool B, class T>
+        struct eval_enable_if
+        {
+            using type = typename T::type;
+        };
+
+        template <class T>
+        struct eval_enable_if<false, T>
+        {
+        };
+
+        template <bool B, class T>
+        using eval_enable_if_t = typename eval_enable_if<B, T>::type;
+
+        template <class F, class E1, class E2>
+        using shift_return_type_t = eval_enable_if_t<
+            is_xexpression<std::decay_t<E1>>::value,
+            shift_function_getter<F, E1, E2>>;
+    }
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise left shift
+     *
+     * Returns an \ref xfunction for the element-wise bitwise left shift of e1
+     * by e2.
+     * @param e1 an \ref xexpression
+     * @param e2 an \ref xexpression
+     * @return an \ref xfunction
+     * @sa left_shift
+     */
+    template <class E1, class E2>
+    inline auto operator<<(E1&& e1, E2&& e2) noexcept
+        -> detail::shift_return_type_t<detail::left_shift, E1, E2>
+    {
+        return left_shift(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup bitwise_operators
+     * @brief Bitwise right shift
+     *
+     * Returns an \ref xfunction for the element-wise bitwise right shift of e1
+     * by e2.
+     * @param e1 an \ref xexpression
+     * @param e2 an \ref xexpression
+     * @return an \ref xfunction
+     * @sa right_shift
+     */
+    template <class E1, class E2>
+    inline auto operator>>(E1&& e1, E2&& e2) -> detail::shift_return_type_t<detail::right_shift, E1, E2>
+    {
+        return right_shift(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @defgroup comparison_operators Comparison operators
+     */
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Lesser than
+     *
+     * Returns an \ref xfunction for the element-wise
+     * lesser than comparison of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator<(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::less, E1, E2>
+    {
+        return detail::make_xfunction<detail::less>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Lesser or equal
+     *
+     * Returns an \ref xfunction for the element-wise
+     * lesser or equal comparison of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator<=(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::less_equal, E1, E2>
+    {
+        return detail::make_xfunction<detail::less_equal>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Greater than
+     *
+     * Returns an \ref xfunction for the element-wise
+     * greater than comparison of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator>(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::greater, E1, E2>
+    {
+        return detail::make_xfunction<detail::greater>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Greater or equal
+     *
+     * Returns an \ref xfunction for the element-wise
+     * greater or equal comparison of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto operator>=(E1&& e1, E2&& e2) noexcept
+        -> detail::xfunction_type_t<detail::greater_equal, E1, E2>
+    {
+        return detail::make_xfunction<detail::greater_equal>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Equality
+     *
+     * Returns true if \a e1 and \a e2 have the same shape
+     * and hold the same values. Unlike other comparison
+     * operators, this does not return an \ref xfunction.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return a boolean
+     */
+    template <class E1, class E2>
+    inline std::enable_if_t<xoptional_comparable<E1, E2>::value, bool>
+    operator==(const xexpression<E1>& e1, const xexpression<E2>& e2)
+    {
+        const E1& de1 = e1.derived_cast();
+        const E2& de2 = e2.derived_cast();
+        bool res = de1.dimension() == de2.dimension()
+                   && std::equal(de1.shape().begin(), de1.shape().end(), de2.shape().begin());
+        auto iter1 = de1.begin();
+        auto iter2 = de2.begin();
+        auto iter_end = de1.end();
+        while (res && iter1 != iter_end)
+        {
+            res = (*iter1++ == *iter2++);
+        }
+        return res;
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Inequality
+     *
+     * Returns true if \a e1 and \a e2 have different shapes
+     * or hold the different values. Unlike other comparison
+     * operators, this does not return an \ref xfunction.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return a boolean
+     */
+    template <class E1, class E2>
+    inline bool operator!=(const xexpression<E1>& e1, const xexpression<E2>& e2)
+    {
+        return !(e1 == e2);
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Element-wise equality
+     *
+     * Returns an \ref xfunction for the element-wise
+     * equality of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto equal(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::equal_to, E1, E2>
+    {
+        return detail::make_xfunction<detail::equal_to>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Element-wise inequality
+     *
+     * Returns an \ref xfunction for the element-wise
+     * inequality of \a e1 and \a e2.
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto not_equal(E1&& e1, E2&& e2) noexcept -> detail::xfunction_type_t<detail::not_equal_to, E1, E2>
+    {
+        return detail::make_xfunction<detail::not_equal_to>(std::forward<E1>(e1), std::forward<E2>(e2));
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Lesser than
+     *
+     * Returns an \ref xfunction for the element-wise
+     * lesser than comparison of \a e1 and \a e2. This
+     * function is equivalent to operator<(E1&&, E2&&).
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto less(E1&& e1, E2&& e2) noexcept -> decltype(std::forward<E1>(e1) < std::forward<E2>(e2))
+    {
+        return std::forward<E1>(e1) < std::forward<E2>(e2);
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Lesser or equal
+     *
+     * Returns an \ref xfunction for the element-wise
+     * lesser or equal comparison of \a e1 and \a e2. This
+     * function is equivalent to operator<=(E1&&, E2&&).
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto less_equal(E1&& e1, E2&& e2) noexcept -> decltype(std::forward<E1>(e1) <= std::forward<E2>(e2))
+    {
+        return std::forward<E1>(e1) <= std::forward<E2>(e2);
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Greater than
+     *
+     * Returns an \ref xfunction for the element-wise
+     * greater than comparison of \a e1 and \a e2. This
+     * function is equivalent to operator>(E1&&, E2&&).
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto greater(E1&& e1, E2&& e2) noexcept -> decltype(std::forward<E1>(e1) > std::forward<E2>(e2))
+    {
+        return std::forward<E1>(e1) > std::forward<E2>(e2);
+    }
+
+    /**
+     * @ingroup comparison_operators
+     * @brief Greater or equal
+     *
+     * Returns an \ref xfunction for the element-wise
+     * greater or equal comparison of \a e1 and \a e2.
+     * This function is equivalent to operator>=(E1&&, E2&&).
+     * @param e1 an \ref xexpression or a scalar
+     * @param e2 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2>
+    inline auto greater_equal(E1&& e1, E2&& e2) noexcept
+        -> decltype(std::forward<E1>(e1) >= std::forward<E2>(e2))
+    {
+        return std::forward<E1>(e1) >= std::forward<E2>(e2);
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief Ternary selection
+     *
+     * Returns an \ref xfunction for the element-wise
+     * ternary selection (i.e. operator ? :) of \a e1,
+     * \a e2 and \a e3.
+     * @param e1 a boolean \ref xexpression
+     * @param e2 an \ref xexpression or a scalar
+     * @param e3 an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+    template <class E1, class E2, class E3>
+    inline auto where(E1&& e1, E2&& e2, E3&& e3) noexcept
+        -> detail::xfunction_type_t<detail::conditional_ternary, E1, E2, E3>
+    {
+        return detail::make_xfunction<detail::conditional_ternary>(
+            std::forward<E1>(e1),
+            std::forward<E2>(e2),
+            std::forward<E3>(e3)
+        );
+    }
+
+    namespace detail
+    {
+        template <layout_type L>
+        struct next_idx_impl;
+
+        template <>
+        struct next_idx_impl<layout_type::row_major>
+        {
+            template <class S, class I>
+            inline auto operator()(const S& shape, I& idx)
+            {
+                for (std::size_t j = shape.size(); j > 0; --j)
+                {
+                    std::size_t i = j - 1;
+                    if (idx[i] >= shape[i] - 1)
+                    {
+                        idx[i] = 0;
+                    }
+                    else
+                    {
+                        idx[i]++;
+                        return idx;
+                    }
+                }
+                // return empty index, happens at last iteration step, but remains unused
+                return I();
+            }
+        };
+
+        template <>
+        struct next_idx_impl<layout_type::column_major>
+        {
+            template <class S, class I>
+            inline auto operator()(const S& shape, I& idx)
+            {
+                for (std::size_t i = 0; i < shape.size(); ++i)
+                {
+                    if (idx[i] >= shape[i] - 1)
+                    {
+                        idx[i] = 0;
+                    }
+                    else
+                    {
+                        idx[i]++;
+                        return idx;
+                    }
+                }
+                // return empty index, happens at last iteration step, but remains unused
+                return I();
+            }
+        };
+
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S, class I>
+        inline auto next_idx(const S& shape, I& idx)
+        {
+            next_idx_impl<L> nii;
+            return nii(shape, idx);
+        }
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief return vector of indices where T is not zero
+     *
+     * @param arr input array
+     * @return vector of vectors, one for each dimension of arr, containing
+     * the indices of the non-zero elements in that dimension
+     */
+    template <class T>
+    inline auto nonzero(const T& arr)
+    {
+        auto shape = arr.shape();
+        using index_type = xindex_type_t<typename T::shape_type>;
+        using size_type = typename T::size_type;
+
+        auto idx = xtl::make_sequence<index_type>(arr.dimension(), 0);
+        std::vector<std::vector<size_type>> indices(arr.dimension());
+
+        size_type total_size = compute_size(shape);
+        for (size_type i = 0; i < total_size; i++, detail::next_idx(shape, idx))
+        {
+            if (arr.element(std::begin(idx), std::end(idx)))
+            {
+                for (std::size_t n = 0; n < indices.size(); ++n)
+                {
+                    indices.at(n).push_back(idx[n]);
+                }
+            }
+        }
+
+        return indices;
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief return vector of indices where condition is true
+     *        (equivalent to \a nonzero(condition))
+     *
+     * @param condition input array
+     * @return vector of \a index_types where condition is not equal to zero
+     */
+    template <class T>
+    inline auto where(const T& condition)
+    {
+        return nonzero(condition);
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief return vector of indices where arr is not zero
+     *
+     * @tparam L the traversal order
+     * @param arr input array
+     * @return vector of index_types where arr is not equal to zero (use `xt::from_indices` to convert)
+     *
+     * @sa xt::from_indices
+     */
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class T>
+    inline auto argwhere(const T& arr)
+    {
+        auto shape = arr.shape();
+        using index_type = xindex_type_t<typename T::shape_type>;
+        using size_type = typename T::size_type;
+
+        auto idx = xtl::make_sequence<index_type>(arr.dimension(), 0);
+        std::vector<index_type> indices;
+
+        size_type total_size = compute_size(shape);
+        for (size_type i = 0; i < total_size; i++, detail::next_idx<L>(shape, idx))
+        {
+            if (arr.element(std::begin(idx), std::end(idx)))
+            {
+                indices.push_back(idx);
+            }
+        }
+
+        return indices;
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief Any
+     *
+     * Returns true if any of the values of \a e is truthy,
+     * false otherwise.
+     * @param e an \ref xexpression
+     * @return a boolean
+     */
+    template <class E>
+    inline bool any(E&& e)
+    {
+        using xtype = std::decay_t<E>;
+        using value_type = typename xtype::value_type;
+        return std::any_of(
+            e.cbegin(),
+            e.cend(),
+            [](const value_type& el)
+            {
+                return el;
+            }
+        );
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief Any
+     *
+     * Returns true if all of the values of \a e are truthy,
+     * false otherwise.
+     * @param e an \ref xexpression
+     * @return a boolean
+     */
+    template <class E>
+    inline bool all(E&& e)
+    {
+        using xtype = std::decay_t<E>;
+        using value_type = typename xtype::value_type;
+        return std::all_of(
+            e.cbegin(),
+            e.cend(),
+            [](const value_type& el)
+            {
+                return el;
+            }
+        );
+    }
+
+    /**
+     * @defgroup casting_operators Casting operators
+     */
+
+    /**
+     * @ingroup casting_operators
+     * @brief Element-wise ``static_cast``.
+     *
+     * Returns an \ref xfunction for the element-wise
+     * static_cast of \a e to type R.
+     *
+     * @param e an \ref xexpression or a scalar
+     * @return an \ref xfunction
+     */
+
+    template <class R, class E>
+    inline auto cast(E&& e) noexcept -> detail::xfunction_type_t<typename detail::cast<R>::functor, E>
+    {
+        return detail::make_xfunction<typename detail::cast<R>::functor>(std::forward<E>(e));
+    }
+
+}
+
+#endif
diff --git a/include/xtensor/xsemantic.hpp b/include/xtensor/core/xsemantic.hpp
similarity index 83%
rename from include/xtensor/xsemantic.hpp
rename to include/xtensor/core/xsemantic.hpp
index 6b9dd419c..05b3248c0 100644
--- a/include/xtensor/xsemantic.hpp
+++ b/include/xtensor/core/xsemantic.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SEMANTIC_HPP
 #define XTENSOR_SEMANTIC_HPP
@@ -12,11 +13,36 @@
 #include <functional>
 #include <utility>
 
-#include "xassign.hpp"
-#include "xexpression.hpp"
+#include "../core/xassign.hpp"
+#include "../core/xexpression_traits.hpp"
 
 namespace xt
 {
+    namespace detail
+    {
+        template <class D>
+        struct is_sharable
+        {
+            static constexpr bool value = true;
+        };
+
+        template <class ET, class S, layout_type L, bool SH, class Tag>
+        struct is_sharable<xfixed_container<ET, S, L, SH, Tag>>
+        {
+            static constexpr bool value = SH;
+        };
+
+        template <class ET, class S, layout_type L, bool SH, class Tag>
+        struct is_sharable<xfixed_adaptor<ET, S, L, SH, Tag>>
+        {
+            static constexpr bool value = SH;
+        };
+    }
+
+    template <class D>
+    using select_expression_base_t = std::
+        conditional_t<detail::is_sharable<D>::value, xsharable_expression<D>, xexpression<D>>;
+
     /**
      * @class xsemantic_base
      * @brief Base interface for assignable xexpressions.
@@ -28,11 +54,11 @@ namespace xt
      *           provides the interface.
      */
     template <class D>
-    class xsemantic_base : public xexpression<D>
+    class xsemantic_base : public select_expression_base_t<D>
     {
     public:
 
-        using base_type = xexpression<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;
@@ -127,6 +153,15 @@ namespace xt
         derived_type& operator=(const xexpression<E>&);
     };
 
+    template <class E>
+    using is_assignable = is_crtp_base_of<xsemantic_base, E>;
+
+    template <class E, class R = void>
+    using enable_assignable = typename std::enable_if<is_assignable<E>::value, R>::type;
+
+    template <class E, class R = void>
+    using disable_assignable = typename std::enable_if<!is_assignable<E>::value, R>::type;
+
     /**
      * @class xcontainer_semantic
      * @brief Implementation of the xsemantic_base interface
@@ -182,6 +217,29 @@ namespace xt
     template <class E, class R = void>
     using disable_xcontainer_semantics = typename std::enable_if<!has_container_semantics<E>::value, R>::type;
 
+
+    template <class D>
+    class xview_semantic;
+
+    template <class E>
+    struct overlapping_memory_checker_traits<
+        E,
+        std::enable_if_t<!addressable_to_expression<E> && is_crtp_base_of<xview_semantic, E>::value>>
+    {
+        static bool check_overlap(const E& expr, const memory_range& dst_range)
+        {
+            if (expr.size() == 0)
+            {
+                return false;
+            }
+            else
+            {
+                using ChildE = std::decay_t<decltype(expr.expression())>;
+                return overlapping_memory_checker_traits<ChildE>::check_overlap(expr.expression(), dst_range);
+            }
+        }
+    };
+
     /**
      * @class xview_semantic
      * @brief Implementation of the xsemantic_base interface for
@@ -349,7 +407,7 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator+=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() + e.derived_cast());
+        return this->derived_cast() = this->derived_cast() + e.derived_cast();
     }
 
     /**
@@ -361,7 +419,7 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator-=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() - e.derived_cast());
+        return this->derived_cast() = this->derived_cast() - e.derived_cast();
     }
 
     /**
@@ -373,7 +431,7 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator*=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() * e.derived_cast());
+        return this->derived_cast() = this->derived_cast() * e.derived_cast();
     }
 
     /**
@@ -385,7 +443,7 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator/=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() / e.derived_cast());
+        return this->derived_cast() = this->derived_cast() / e.derived_cast();
     }
 
     /**
@@ -397,7 +455,7 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator%=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() % e.derived_cast());
+        return this->derived_cast() = this->derived_cast() % e.derived_cast();
     }
 
     /**
@@ -409,7 +467,7 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator&=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() & e.derived_cast());
+        return this->derived_cast() = this->derived_cast() & e.derived_cast();
     }
 
     /**
@@ -421,7 +479,7 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator|=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() | e.derived_cast());
+        return this->derived_cast() = this->derived_cast() | e.derived_cast();
     }
 
     /**
@@ -433,13 +491,15 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator^=(const xexpression<E>& e) -> derived_type&
     {
-        return operator=(this->derived_cast() ^ e.derived_cast());
+        return this->derived_cast() = this->derived_cast() ^ e.derived_cast();
     }
+
     //@}
 
     /**
      * @name Assign functions
      */
+
     /**
      * Assigns the xexpression \c e to \c *this. Ensures no temporary
      * will be used to perform the assignment.
@@ -561,8 +621,22 @@ namespace xt
     template <class E>
     inline auto xsemantic_base<D>::operator=(const xexpression<E>& e) -> derived_type&
     {
+#ifdef XTENSOR_FORCE_TEMPORARY_MEMORY_IN_ASSIGNMENTS
         temporary_type tmp(e);
         return this->derived_cast().assign_temporary(std::move(tmp));
+#else
+        auto&& this_derived = this->derived_cast();
+        auto memory_checker = make_overlapping_memory_checker(this_derived);
+        if (memory_checker.check_overlap(e.derived_cast()))
+        {
+            temporary_type tmp(e);
+            return this_derived.assign_temporary(std::move(tmp));
+        }
+        else
+        {
+            return this->assign(e);
+        }
+#endif
     }
 
     /**************************************
@@ -641,7 +715,7 @@ namespace xt
             using index_type = xindex_type_t<typename xfunction<F, R, CT...>::shape_type>;
             using size_type = typename index_type::size_type;
             size_type size = rhs.dimension();
-            index_type shape = xtl::make_sequence<index_type>(size, size_type(0));
+            index_type shape = uninitialized_shape<index_type>(size);
             bool trivial_broadcast = rhs.broadcast_shape(shape, true);
             return trivial_broadcast;
         }
@@ -665,6 +739,21 @@ namespace xt
         return this->derived_cast();
     }
 
+    namespace xview_semantic_detail
+    {
+        template <class D>
+        auto get_begin(D&& lhs, std::true_type)
+        {
+            return lhs.linear_begin();
+        }
+
+        template <class D>
+        auto get_begin(D&& lhs, std::false_type)
+        {
+            return lhs.begin();
+        }
+    }
+
     template <class D>
     template <class E, class F>
     inline auto xview_semantic<D>::scalar_computed_assign(const E& e, F&& f) -> derived_type&
@@ -672,7 +761,7 @@ namespace xt
         D& d = this->derived_cast();
 
         using size_type = typename D::size_type;
-        auto dst = d.begin();
+        auto dst = xview_semantic_detail::get_begin(d, std::integral_constant<bool, D::contiguous_layout>());
         for (size_type i = d.size(); i > 0; --i)
         {
             *dst = f(*dst, e);
@@ -685,10 +774,12 @@ namespace xt
     template <class E>
     inline auto xview_semantic<D>::operator=(const xexpression<E>& rhs) -> derived_type&
     {
-        bool cond = (rhs.derived_cast().shape().size() == this->derived_cast().dimension()) &&
-            std::equal(this->derived_cast().shape().begin(),
-                       this->derived_cast().shape().end(),
-                       rhs.derived_cast().shape().begin());
+        bool cond = (rhs.derived_cast().shape().size() == this->derived_cast().dimension())
+                    && std::equal(
+                        this->derived_cast().shape().begin(),
+                        this->derived_cast().shape().end(),
+                        rhs.derived_cast().shape().begin()
+                    );
 
         if (!cond)
         {
diff --git a/include/xtensor/core/xshape.hpp b/include/xtensor/core/xshape.hpp
new file mode 100644
index 000000000..1380f4e07
--- /dev/null
+++ b/include/xtensor/core/xshape.hpp
@@ -0,0 +1,578 @@
+/***************************************************************************
+ * 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_XSHAPE_HPP
+#define XTENSOR_XSHAPE_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdlib>
+#include <initializer_list>
+#include <iterator>
+
+#include "../containers/xstorage.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xtensor_forward.hpp"
+
+namespace xt
+{
+    template <class T>
+    using dynamic_shape = svector<T, 4>;
+
+    template <class T, std::size_t N>
+    using static_shape = std::array<T, N>;
+
+    template <std::size_t... X>
+    class fixed_shape;
+
+    using xindex = dynamic_shape<std::size_t>;
+
+    template <class S1, class S2>
+    bool same_shape(const S1& s1, const S2& s2) noexcept;
+
+    template <class U>
+    struct initializer_dimension;
+
+    template <class R, class T>
+    constexpr R shape(T t);
+
+    template <class R = std::size_t, class T, std::size_t N>
+    xt::static_shape<R, N> shape(const T (&aList)[N]);
+
+    template <class S>
+    struct static_dimension;
+
+    template <layout_type L, class S>
+    struct select_layout;
+
+    template <class... S>
+    struct promote_shape;
+
+    template <class... S>
+    struct promote_strides;
+
+    template <class S>
+    struct index_from_shape;
+}
+
+namespace xtl
+{
+    namespace detail
+    {
+        template <class S>
+        struct sequence_builder;
+
+        template <std::size_t... I>
+        struct sequence_builder<xt::fixed_shape<I...>>
+        {
+            using sequence_type = xt::fixed_shape<I...>;
+            using value_type = typename sequence_type::value_type;
+
+            inline static sequence_type make(std::size_t /*size*/)
+            {
+                return sequence_type{};
+            }
+
+            inline static sequence_type make(std::size_t /*size*/, value_type /*v*/)
+            {
+                return sequence_type{};
+            }
+        };
+    }
+}
+
+namespace xt
+{
+    /**
+     * @defgroup xt_xshape Support functions to get/check a shape array.
+     */
+
+    /**************
+     * same_shape *
+     **************/
+
+    /**
+     * Check if two objects have the same shape.
+     *
+     * @ingroup xt_xshape
+     * @param s1 an array
+     * @param s2 an array
+     * @return bool
+     */
+    template <class S1, class S2>
+    inline bool same_shape(const S1& s1, const S2& s2) noexcept
+    {
+        return s1.size() == s2.size() && std::equal(s1.begin(), s1.end(), s2.begin());
+    }
+
+    /*************
+     * has_shape *
+     *************/
+
+    /**
+     * Check if an object has a certain shape.
+     *
+     * @ingroup xt_xshape
+     * @param e an array-like object
+     * @param shape the shape to test
+     * @return bool
+     */
+    template <class E, class S>
+    inline bool has_shape(const E& e, std::initializer_list<S> shape) noexcept
+    {
+        return e.shape().size() == shape.size()
+               && std::equal(e.shape().cbegin(), e.shape().cend(), shape.begin());
+    }
+
+    /**
+     * Check if an object has a certain shape.
+     *
+     * @ingroup xt_xshape
+     * @param e an array-like object
+     * @param shape the shape to test
+     * @return bool
+     */
+    template <class E, class S, class = typename std::enable_if_t<iterable_expression<S>>>
+    inline bool has_shape(const E& e, const S& shape)
+    {
+        return e.shape().size() == shape.size()
+               && std::equal(e.shape().cbegin(), e.shape().cend(), shape.begin());
+    }
+
+    /*************************
+     * initializer_dimension *
+     *************************/
+
+    namespace detail
+    {
+        template <class U>
+        struct initializer_depth_impl
+        {
+            static constexpr std::size_t value = 0;
+        };
+
+        template <class T>
+        struct initializer_depth_impl<std::initializer_list<T>>
+        {
+            static constexpr std::size_t value = 1 + initializer_depth_impl<T>::value;
+        };
+    }
+
+    template <class U>
+    struct initializer_dimension
+    {
+        static constexpr std::size_t value = detail::initializer_depth_impl<U>::value;
+    };
+
+    /*********************
+     * initializer_shape *
+     *********************/
+
+    namespace detail
+    {
+        template <std::size_t I>
+        struct initializer_shape_impl
+        {
+            template <class T>
+            static constexpr std::size_t value(T t)
+            {
+                return t.size() == 0 ? 0 : initializer_shape_impl<I - 1>::value(*t.begin());
+            }
+        };
+
+        template <>
+        struct initializer_shape_impl<0>
+        {
+            template <class T>
+            static constexpr std::size_t value(T t)
+            {
+                return t.size();
+            }
+        };
+
+        template <class R, class U, std::size_t... I>
+        constexpr R initializer_shape(U t, std::index_sequence<I...>)
+        {
+            using size_type = typename R::value_type;
+            return {size_type(initializer_shape_impl<I>::value(t))...};
+        }
+    }
+
+    template <class R, class T>
+    constexpr R shape(T t)
+    {
+        return detail::initializer_shape<R, decltype(t)>(
+            t,
+            std::make_index_sequence<initializer_dimension<decltype(t)>::value>()
+        );
+    }
+
+    /** @brief Generate an xt::static_shape of the given size. */
+    template <class R, class T, std::size_t N>
+    xt::static_shape<R, N> shape(const T (&list)[N])
+    {
+        xt::static_shape<R, N> shape;
+        std::copy(std::begin(list), std::end(list), std::begin(shape));
+        return shape;
+    }
+
+    /********************
+     * static_dimension *
+     ********************/
+
+    namespace detail
+    {
+        template <class T, class E = void>
+        struct static_dimension_impl
+        {
+            static constexpr std::ptrdiff_t value = -1;
+        };
+
+        template <class T>
+        struct static_dimension_impl<T, void_t<decltype(std::tuple_size<T>::value)>>
+        {
+            static constexpr std::ptrdiff_t value = static_cast<std::ptrdiff_t>(std::tuple_size<T>::value);
+        };
+    }
+
+    template <class S>
+    struct static_dimension
+    {
+        static constexpr std::ptrdiff_t value = detail::static_dimension_impl<S>::value;
+    };
+
+    /**
+     * Compute a layout based on a layout and a shape type.
+     *
+     * The main functionality of this function is that it reduces vectors to
+     * ``xt::layout_type::any`` so that assigning a row major 1D container to another
+     * row_major container becomes free.
+     *
+     * @ingroup xt_xshape
+     */
+    template <layout_type L, class S>
+    struct select_layout
+    {
+        static constexpr std::ptrdiff_t static_dimension = xt::static_dimension<S>::value;
+        static constexpr bool is_any = static_dimension != -1 && static_dimension <= 1
+                                       && L != layout_type::dynamic;
+        static constexpr layout_type value = is_any ? layout_type::any : L;
+    };
+
+    /*************************************
+     * promote_shape and promote_strides *
+     *************************************/
+
+    namespace detail
+    {
+        template <class T1, class T2>
+        constexpr std::common_type_t<T1, T2> imax(const T1& a, const T2& b)
+        {
+            return a > b ? a : b;
+        }
+
+        // Variadic meta-function returning the maximal size of std::arrays.
+        template <class... T>
+        struct max_array_size;
+
+        template <>
+        struct max_array_size<>
+        {
+            static constexpr std::size_t value = 0;
+        };
+
+        template <class T, class... Ts>
+        struct max_array_size<T, Ts...>
+            : std::integral_constant<std::size_t, imax(std::tuple_size<T>::value, max_array_size<Ts...>::value)>
+        {
+        };
+
+        // Broadcasting for fixed shapes
+        template <std::size_t IDX, std::size_t... X>
+        struct at
+        {
+            static constexpr std::size_t arr[sizeof...(X)] = {X...};
+            static constexpr std::size_t value = (IDX < sizeof...(X)) ? arr[IDX] : 0;
+        };
+
+        template <class S1, class S2>
+        struct broadcast_fixed_shape;
+
+        template <class IX, class A, class B>
+        struct broadcast_fixed_shape_impl;
+
+        template <std::size_t IX, class A, class B>
+        struct broadcast_fixed_shape_cmp_impl;
+
+        template <std::size_t JX, std::size_t... I, std::size_t... J>
+        struct broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>
+        {
+            // We line the shapes up from the last index
+            // IX may underflow, thus being a very large number
+            static constexpr std::size_t IX = JX - (sizeof...(J) - sizeof...(I));
+
+            // Out of bounds access gives value 0
+            static constexpr std::size_t I_v = at<IX, I...>::value;
+            static constexpr std::size_t J_v = at<JX, J...>::value;
+
+            // we're statically checking if the broadcast shapes are either one on either of them or equal
+            static_assert(!I_v || I_v == 1 || J_v == 1 || J_v == I_v, "broadcast shapes do not match.");
+
+            static constexpr std::size_t ordinate = (I_v > J_v) ? I_v : J_v;
+            static constexpr bool value = (I_v == J_v);
+        };
+
+        template <std::size_t... JX, std::size_t... I, std::size_t... J>
+        struct broadcast_fixed_shape_impl<std::index_sequence<JX...>, fixed_shape<I...>, fixed_shape<J...>>
+        {
+            static_assert(sizeof...(J) >= sizeof...(I), "broadcast shapes do not match.");
+
+            using type = xt::fixed_shape<
+                broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>::ordinate...>;
+            static constexpr bool value = std::conjunction<
+                broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>...>::value;
+        };
+
+        /* broadcast_fixed_shape<fixed_shape<I...>, fixed_shape<J...>>
+         * Just like a call to broadcast_shape(cont S1& input, S2& output),
+         * except that the result shape is alised as type, and the returned
+         * bool is the member value. Asserts on an illegal broadcast, including
+         * the case where pack I is strictly longer than pack J. */
+
+        template <std::size_t... I, std::size_t... J>
+        struct broadcast_fixed_shape<fixed_shape<I...>, fixed_shape<J...>>
+            : broadcast_fixed_shape_impl<std::make_index_sequence<sizeof...(J)>, fixed_shape<I...>, fixed_shape<J...>>
+        {
+        };
+
+        // Simple is_array and only_array meta-functions
+        template <class S>
+        struct is_array
+        {
+            static constexpr bool value = false;
+        };
+
+        template <class T, std::size_t N>
+        struct is_array<std::array<T, N>>
+        {
+            static constexpr bool value = true;
+        };
+
+        template <class S>
+        struct is_fixed : std::false_type
+        {
+        };
+
+        template <std::size_t... N>
+        struct is_fixed<fixed_shape<N...>> : std::true_type
+        {
+        };
+
+        template <class S>
+        struct is_scalar_shape
+        {
+            static constexpr bool value = false;
+        };
+
+        template <class T>
+        struct is_scalar_shape<std::array<T, 0>>
+        {
+            static constexpr bool value = true;
+        };
+
+        template <class... S>
+        using only_array = std::conjunction<std::disjunction<is_array<S>, is_fixed<S>>...>;
+
+        // test that at least one argument is a fixed shape. If yes, then either argument has to be fixed or
+        // scalar
+        template <class... S>
+        using only_fixed = std::integral_constant<
+            bool,
+            std::disjunction<is_fixed<S>...>::value
+                && std::conjunction<std::disjunction<is_fixed<S>, is_scalar_shape<S>>...>::value>;
+
+        template <class... S>
+        using all_fixed = std::conjunction<is_fixed<S>...>;
+
+        // The promote_index meta-function returns std::vector<promoted_value_type> in the
+        // general case and an array of the promoted value type and maximal size if all
+        // arguments are of type std::array
+
+        template <class... S>
+        struct promote_array
+        {
+            using type = std::
+                array<typename std::common_type<typename S::value_type...>::type, max_array_size<S...>::value>;
+        };
+
+        template <>
+        struct promote_array<>
+        {
+            using type = std::array<std::size_t, 0>;
+        };
+
+        template <class S>
+        struct filter_scalar
+        {
+            using type = S;
+        };
+
+        template <class T>
+        struct filter_scalar<std::array<T, 0>>
+        {
+            using type = fixed_shape<1>;
+        };
+
+        template <class S>
+        using filter_scalar_t = typename filter_scalar<S>::type;
+
+        template <class... S>
+        struct promote_fixed : promote_fixed<filter_scalar_t<S>...>
+        {
+        };
+
+        template <std::size_t... I>
+        struct promote_fixed<fixed_shape<I...>>
+        {
+            using type = fixed_shape<I...>;
+            static constexpr bool value = true;
+        };
+
+        template <std::size_t... I, std::size_t... J, class... S>
+        struct promote_fixed<fixed_shape<I...>, fixed_shape<J...>, S...>
+        {
+        private:
+
+            using intermediate = std::conditional_t<
+                (sizeof...(I) > sizeof...(J)),
+                broadcast_fixed_shape<fixed_shape<J...>, fixed_shape<I...>>,
+                broadcast_fixed_shape<fixed_shape<I...>, fixed_shape<J...>>>;
+            using result = promote_fixed<typename intermediate::type, S...>;
+
+        public:
+
+            using type = typename result::type;
+            static constexpr bool value = std::conjunction<intermediate, result>::value;
+        };
+
+        template <bool all_index, bool all_array, class... S>
+        struct select_promote_index;
+
+        template <class... S>
+        struct select_promote_index<true, true, S...> : promote_fixed<S...>
+        {
+        };
+
+        template <>
+        struct select_promote_index<true, true>
+        {
+            // todo correct? used in xvectorize
+            using type = dynamic_shape<std::size_t>;
+        };
+
+        template <class... S>
+        struct select_promote_index<false, true, S...> : promote_array<S...>
+        {
+        };
+
+        template <class... S>
+        struct select_promote_index<false, false, S...>
+        {
+            using type = dynamic_shape<typename std::common_type<typename S::value_type...>::type>;
+        };
+
+        template <class... S>
+        struct promote_index : select_promote_index<only_fixed<S...>::value, only_array<S...>::value, S...>
+        {
+        };
+
+        template <class T>
+        struct index_from_shape_impl
+        {
+            using type = T;
+        };
+
+        template <std::size_t... N>
+        struct index_from_shape_impl<fixed_shape<N...>>
+        {
+            using type = std::array<std::size_t, sizeof...(N)>;
+        };
+    }
+
+    template <typename T>
+    concept fixed_shape_container_concept = detail::is_fixed<typename std::decay_t<T>::shape_type>::value;
+
+    template <class... S>
+    struct promote_shape
+    {
+        using type = typename detail::promote_index<S...>::type;
+    };
+
+    /**
+     * @ingroup xt_xshape
+     */
+    template <class... S>
+    using promote_shape_t = typename promote_shape<S...>::type;
+
+    template <class... S>
+    struct promote_strides
+    {
+        using type = typename detail::promote_index<S...>::type;
+    };
+
+    /**
+     * @ingroup xt_xshape
+     */
+    template <class... S>
+    using promote_strides_t = typename promote_strides<S...>::type;
+
+    template <class S>
+    struct index_from_shape
+    {
+        using type = typename detail::index_from_shape_impl<S>::type;
+    };
+
+    /**
+     * @ingroup xt_xshape
+     */
+    template <class S>
+    using index_from_shape_t = typename index_from_shape<S>::type;
+
+    /**********************
+     * filter_fixed_shape *
+     **********************/
+
+    namespace detail
+    {
+        template <class S>
+        struct filter_fixed_shape_impl
+        {
+            using type = S;
+        };
+
+        template <std::size_t... N>
+        struct filter_fixed_shape_impl<fixed_shape<N...>>
+        {
+            using type = std::array<std::size_t, sizeof...(N)>;
+        };
+    }
+
+    template <class S>
+    struct filter_fixed_shape : detail::filter_fixed_shape_impl<S>
+    {
+    };
+
+    /**
+     * @ingroup xt_xshape
+     */
+    template <class S>
+    using filter_fixed_shape_t = typename filter_fixed_shape<S>::type;
+}
+
+#endif
diff --git a/include/xtensor/core/xstrides.hpp b/include/xtensor/core/xstrides.hpp
new file mode 100644
index 000000000..998ffcd6b
--- /dev/null
+++ b/include/xtensor/core/xstrides.hpp
@@ -0,0 +1,924 @@
+/***************************************************************************
+ * 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_STRIDES_HPP
+#define XTENSOR_STRIDES_HPP
+
+#include <cstddef>
+#include <functional>
+#include <limits>
+#include <numeric>
+
+#include <xtl/xsequence.hpp>
+
+#include "../core/xshape.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../utils/xexception.hpp"
+
+namespace xt
+{
+
+    template <class shape_type>
+    std::size_t compute_size(const shape_type& shape) noexcept;
+
+    /**
+     * @defgroup xt_xstrides Support functions swich between array indices and flat indices
+     */
+
+    /***************
+     * data offset *
+     ***************/
+
+    template <class offset_type, class S>
+    offset_type data_offset(const S& strides) noexcept;
+
+    /**
+     * @brief Return the flat index for an array index.
+     *
+     * Given ``m`` arguments, and dimension ``n``of the array (``n == strides.size()``).
+     *
+     *  -   If ``m == n``, the index is
+     *      ``strides[0] * index[0] + ... + strides[n - 1] * index[n - 1]``.
+     *
+     *  -   If ``m < n`` and the last argument is ``xt::missing`` the indices are zero-padded at
+     *      the end to match the dimension of the array. The index is then
+     *      ``strides[0] * index[0] + ... + strides[m - 1] * index[m - 1]``.
+     *
+     *  -   If ``m < n`` (and the last argument is not ``xt::missing``), the index is
+     *      ``strides[n - m - 1] * index[0] + ... + strides[n - 1] * index[m - 1]``.
+     *
+     *  -   If ``m > n``, then the first ``m - n`` arguments are ignored. The index is then
+     *      ``strides[0] * index[m - n] + ... + strides[n - 1] * index[m - 1]``.
+     *
+     * @ingroup xt_xstrides
+     * @param strides Strides of the array.
+     * @param arg First array index.
+     * @param args Remaining array indices.
+     * @return The flat index.
+     */
+    template <class offset_type, class S, class Arg, class... Args>
+    offset_type data_offset(const S& strides, Arg arg, Args... args) noexcept;
+
+    template <class offset_type, layout_type L = layout_type::dynamic, class S, class... Args>
+    offset_type unchecked_data_offset(const S& strides, Args... args) noexcept;
+
+    template <class offset_type, class S, class It>
+    offset_type element_offset(const S& strides, It first, It last) noexcept;
+
+    /*******************
+     * strides builder *
+     *******************/
+
+    /**
+     * @brief Compute the strides given the shape and the layout of an array.
+     *
+     * @ingroup xt_xstrides
+     * @param shape Shape of the array.
+     * @param l Layout type, see xt::layout_type().
+     * @param strides (output) Strides of the array.
+     * @return The size: the product of the shape.
+     */
+    template <layout_type L = layout_type::dynamic, class shape_type, class strides_type>
+    std::size_t compute_strides(const shape_type& shape, layout_type l, strides_type& strides);
+
+    template <layout_type L = layout_type::dynamic, class shape_type, class strides_type, class backstrides_type>
+    std::size_t
+    compute_strides(const shape_type& shape, layout_type l, strides_type& strides, backstrides_type& backstrides);
+
+    template <class shape_type, class strides_type>
+    void adapt_strides(const shape_type& shape, strides_type& strides) noexcept;
+
+    template <class shape_type, class strides_type, class backstrides_type>
+    void adapt_strides(const shape_type& shape, strides_type& strides, backstrides_type& backstrides) noexcept;
+
+    /*****************
+     * unravel_index *
+     *****************/
+
+    template <class S>
+    S unravel_from_strides(typename S::value_type index, const S& strides, layout_type l = layout_type::row_major);
+
+    template <class S>
+    get_strides_t<S>
+    unravel_index(typename S::value_type index, const S& shape, layout_type l = layout_type::row_major);
+
+    template <class S, class T>
+    std::vector<get_strides_t<S>>
+    unravel_indices(const T& indices, const S& shape, layout_type l = layout_type::row_major);
+
+    /***********************
+     * broadcast functions *
+     ***********************/
+
+    template <class S, class size_type>
+    S uninitialized_shape(size_type size);
+
+    template <class S1, class S2>
+    bool broadcast_shape(const S1& input, S2& output);
+
+    template <class S1, class S2>
+    bool broadcastable(const S1& s1, S2& s2);
+
+    /*************************
+     * check strides overlap *
+     *************************/
+
+    template <layout_type L>
+    struct check_strides_overlap;
+
+    /**********************************
+     * check bounds, without throwing *
+     **********************************/
+
+    /**
+     * @brief Check if the index is within the bounds of the array.
+     *
+     * @param shape Shape of the array.
+     * @param args Array index.
+     * @return true If the index is within the bounds of the array.
+     * @return false Otherwise.
+     */
+    template <class S, class... Args>
+    bool in_bounds(const S& shape, Args&... args);
+
+    /********************************
+     * apply periodicity to indices *
+     *******************************/
+
+    /**
+     * @brief Normalise an index of a periodic array.
+     * For example if the shape is ``(3, 4)`` and the index is ``(3, -4)`` the result is ``(0, 0)``.
+     *
+     * @ingroup xt_xstrides
+     * @param shape Shape of the array.
+     * @param args (input/output) Array index.
+     */
+    template <class S, class... Args>
+    void normalize_periodic(const S& shape, Args&... args);
+
+    /********************************************
+     * utility functions for strided containers *
+     ********************************************/
+
+    template <class C, class It, class size_type>
+    It strided_data_end(const C& c, It begin, layout_type l, size_type offset)
+    {
+        using difference_type = typename std::iterator_traits<It>::difference_type;
+        if (c.size() == 0 || std::find(c.shape().cbegin(), c.shape().cend(), size_type(0)) != c.shape().cend())
+        {
+            return begin;
+        }
+        if (c.dimension() == 0)
+        {
+            ++begin;
+        }
+        else
+        {
+            for (std::size_t i = 0; i != c.dimension(); ++i)
+            {
+                begin += c.strides()[i] * difference_type(c.shape()[i] - 1);
+            }
+            if (l == layout_type::row_major)
+            {
+                begin += c.strides().back();
+            }
+            else
+            {
+                if (offset == 0)
+                {
+                    begin += c.strides().front();
+                }
+            }
+        }
+        return begin;
+    }
+
+    /***********
+     * strides *
+     ***********/
+
+    namespace detail
+    {
+        template <class return_type, class S, class T, class D>
+        inline return_type compute_stride_impl(layout_type layout, const S& shape, T axis, D default_stride)
+        {
+            if (layout == layout_type::row_major)
+            {
+                return std::accumulate(
+                    shape.cbegin() + axis + 1,
+                    shape.cend(),
+                    static_cast<return_type>(1),
+                    std::multiplies<return_type>()
+                );
+            }
+            if (layout == layout_type::column_major)
+            {
+                return std::accumulate(
+                    shape.cbegin(),
+                    shape.cbegin() + axis,
+                    static_cast<return_type>(1),
+                    std::multiplies<return_type>()
+                );
+            }
+            return default_stride;
+        }
+    }
+
+    /**
+     * @brief Choose stride type
+     * @ingroup xt_xstrides
+     */
+    enum class stride_type
+    {
+        internal = 0,  ///< As used internally (with `stride(axis) == 0` if `shape(axis) == 1`)
+        normal = 1,    ///< Normal stride corresponding to storage.
+        bytes = 2,     ///< Normal stride in bytes.
+    };
+
+    /**
+     * @brief Get strides of an object.
+     *
+     * @ingroup xt_xstrides
+     * @param e an array
+     * @param type output stride convention
+     * @return array
+     */
+    template <class E>
+    inline auto strides(const E& e, stride_type type = stride_type::normal) noexcept
+    {
+        using strides_type = typename E::strides_type;
+        using return_type = typename strides_type::value_type;
+        strides_type ret = e.strides();
+        auto shape = e.shape();
+
+        if (type == stride_type::internal)
+        {
+            return ret;
+        }
+
+        for (std::size_t i = 0; i < ret.size(); ++i)
+        {
+            if (shape[i] == 1)
+            {
+                ret[i] = detail::compute_stride_impl<return_type>(e.layout(), shape, i, ret[i]);
+            }
+        }
+
+        if (type == stride_type::bytes)
+        {
+            return_type f = static_cast<return_type>(sizeof(typename E::value_type));
+            std::for_each(
+                ret.begin(),
+                ret.end(),
+                [f](auto& c)
+                {
+                    c *= f;
+                }
+            );
+        }
+
+        return ret;
+    }
+
+    /**
+     * @brief Get stride of an object along an axis.
+     *
+     * @ingroup xt_xstrides
+     * @param e an array
+     * @param axis axis along which to query the stride
+     * @param type output stride convention
+     * @return integer
+     */
+    template <class E>
+    inline auto strides(const E& e, std::size_t axis, stride_type type = stride_type::normal) noexcept
+    {
+        using strides_type = typename E::strides_type;
+        using return_type = typename strides_type::value_type;
+
+        return_type ret = e.strides()[axis];
+
+        if (type == stride_type::internal)
+        {
+            return ret;
+        }
+
+        if (ret == 0)
+        {
+            if (e.shape(axis) == 1)
+            {
+                ret = detail::compute_stride_impl<return_type>(e.layout(), e.shape(), axis, ret);
+            }
+        }
+
+        if (type == stride_type::bytes)
+        {
+            return_type f = static_cast<return_type>(sizeof(typename E::value_type));
+            ret *= f;
+        }
+
+        return ret;
+    }
+
+    /******************
+     * Implementation *
+     ******************/
+
+    namespace detail
+    {
+        template <class shape_type>
+        inline std::size_t compute_size_impl(const shape_type& shape, std::true_type /* is signed */)
+        {
+            using size_type = std::decay_t<typename shape_type::value_type>;
+            return static_cast<std::size_t>(std::abs(
+                std::accumulate(shape.cbegin(), shape.cend(), size_type(1), std::multiplies<size_type>())
+            ));
+        }
+
+        template <class shape_type>
+        inline std::size_t compute_size_impl(const shape_type& shape, std::false_type /* is not signed */)
+        {
+            using size_type = std::decay_t<typename shape_type::value_type>;
+            return static_cast<std::size_t>(
+                std::accumulate(shape.cbegin(), shape.cend(), size_type(1), std::multiplies<size_type>())
+            );
+        }
+    }
+
+    template <class shape_type>
+    inline std::size_t compute_size(const shape_type& shape) noexcept
+    {
+        return detail::compute_size_impl(
+            shape,
+            xtl::is_signed<std::decay_t<typename std::decay_t<shape_type>::value_type>>()
+        );
+    }
+
+    namespace detail
+    {
+
+        template <std::size_t dim, class S>
+        inline auto raw_data_offset(const S&) noexcept
+        {
+            using strides_value_type = std::decay_t<decltype(std::declval<S>()[0])>;
+            return strides_value_type(0);
+        }
+
+        template <std::size_t dim, class S>
+        inline auto raw_data_offset(const S&, missing_type) noexcept
+        {
+            using strides_value_type = std::decay_t<decltype(std::declval<S>()[0])>;
+            return strides_value_type(0);
+        }
+
+        template <std::size_t dim, class S, class Arg, class... Args>
+        inline auto raw_data_offset(const S& strides, Arg arg, Args... args) noexcept
+        {
+            return static_cast<std::ptrdiff_t>(arg) * strides[dim] + raw_data_offset<dim + 1>(strides, args...);
+        }
+
+        template <layout_type L, std::ptrdiff_t static_dim>
+        struct layout_data_offset
+        {
+            template <std::size_t dim, class S, class Arg, class... Args>
+            inline static auto run(const S& strides, Arg arg, Args... args) noexcept
+            {
+                return raw_data_offset<dim>(strides, arg, args...);
+            }
+        };
+
+        template <std::ptrdiff_t static_dim>
+        struct layout_data_offset<layout_type::row_major, static_dim>
+        {
+            using self_type = layout_data_offset<layout_type::row_major, static_dim>;
+
+            template <std::size_t dim, class S, class Arg>
+            inline static auto run(const S& strides, Arg arg) noexcept
+            {
+                if (std::ptrdiff_t(dim) + 1 == static_dim)
+                {
+                    return arg;
+                }
+                else
+                {
+                    return arg * strides[dim];
+                }
+            }
+
+            template <std::size_t dim, class S, class Arg, class... Args>
+            inline static auto run(const S& strides, Arg arg, Args... args) noexcept
+            {
+                return arg * strides[dim] + self_type::template run<dim + 1>(strides, args...);
+            }
+        };
+
+        template <std::ptrdiff_t static_dim>
+        struct layout_data_offset<layout_type::column_major, static_dim>
+        {
+            using self_type = layout_data_offset<layout_type::column_major, static_dim>;
+
+            template <std::size_t dim, class S, class Arg>
+            inline static auto run(const S& strides, Arg arg) noexcept
+            {
+                if (dim == 0)
+                {
+                    return arg;
+                }
+                else
+                {
+                    return arg * strides[dim];
+                }
+            }
+
+            template <std::size_t dim, class S, class Arg, class... Args>
+            inline static auto run(const S& strides, Arg arg, Args... args) noexcept
+            {
+                if (dim == 0)
+                {
+                    return arg + self_type::template run<dim + 1>(strides, args...);
+                }
+                else
+                {
+                    return arg * strides[dim] + self_type::template run<dim + 1>(strides, args...);
+                }
+            }
+        };
+    }
+
+    template <class offset_type, class S>
+    inline offset_type data_offset(const S&) noexcept
+    {
+        return offset_type(0);
+    }
+
+    template <class offset_type, class S, class Arg, class... Args>
+    inline offset_type data_offset(const S& strides, Arg arg, Args... args) noexcept
+    {
+        constexpr std::size_t nargs = sizeof...(Args) + 1;
+        if (nargs == strides.size())
+        {
+            // Correct number of arguments: iterate
+            return static_cast<offset_type>(detail::raw_data_offset<0>(strides, arg, args...));
+        }
+        else if (nargs > strides.size())
+        {
+            // Too many arguments: drop the first
+            return data_offset<offset_type, S>(strides, args...);
+        }
+        else if (detail::last_type_is_missing<Args...>)
+        {
+            // Too few arguments & last argument xt::missing: postfix index with zeros
+            return static_cast<offset_type>(detail::raw_data_offset<0>(strides, arg, args...));
+        }
+        else
+        {
+            // Too few arguments: right to left scalar product
+            auto view = strides.cend() - nargs;
+            return static_cast<offset_type>(detail::raw_data_offset<0>(view, arg, args...));
+        }
+    }
+
+    template <class offset_type, layout_type L, class S, class... Args>
+    inline offset_type unchecked_data_offset(const S& strides, Args... args) noexcept
+    {
+        return static_cast<offset_type>(
+            detail::layout_data_offset<L, static_dimension<S>::value>::template run<0>(strides.cbegin(), args...)
+        );
+    }
+
+    template <class offset_type, class S, class It>
+    inline offset_type element_offset(const S& strides, It first, It last) noexcept
+    {
+        using difference_type = typename std::iterator_traits<It>::difference_type;
+        auto size = static_cast<difference_type>(
+            (std::min)(static_cast<typename S::size_type>(std::distance(first, last)), strides.size())
+        );
+        return std::inner_product(last - size, last, strides.cend() - size, offset_type(0));
+    }
+
+    namespace detail
+    {
+        template <class shape_type, class strides_type, class bs_ptr>
+        inline void adapt_strides(
+            const shape_type& shape,
+            strides_type& strides,
+            bs_ptr backstrides,
+            typename strides_type::size_type i
+        ) noexcept
+        {
+            if (shape[i] == 1)
+            {
+                strides[i] = 0;
+            }
+            (*backstrides)[i] = strides[i] * std::ptrdiff_t(shape[i] - 1);
+        }
+
+        template <class shape_type, class strides_type>
+        inline void adapt_strides(
+            const shape_type& shape,
+            strides_type& strides,
+            std::nullptr_t,
+            typename strides_type::size_type i
+        ) noexcept
+        {
+            if (shape[i] == 1)
+            {
+                strides[i] = 0;
+            }
+        }
+
+        template <layout_type L, class shape_type, class strides_type, class bs_ptr>
+        inline std::size_t
+        compute_strides(const shape_type& shape, layout_type l, strides_type& strides, bs_ptr bs)
+        {
+            using strides_value_type = typename std::decay_t<strides_type>::value_type;
+            strides_value_type data_size = 1;
+
+#if defined(_MSC_VER) && (1931 <= _MSC_VER)
+            // Workaround MSVC compiler optimization bug, xtensor#2568
+            if (0 == shape.size())
+            {
+                return static_cast<std::size_t>(data_size);
+            }
+#endif
+
+            if (L == layout_type::row_major || l == layout_type::row_major)
+            {
+                for (std::size_t i = shape.size(); i != 0; --i)
+                {
+                    strides[i - 1] = data_size;
+                    data_size = strides[i - 1] * static_cast<strides_value_type>(shape[i - 1]);
+                    adapt_strides(shape, strides, bs, i - 1);
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < shape.size(); ++i)
+                {
+                    strides[i] = data_size;
+                    data_size = strides[i] * static_cast<strides_value_type>(shape[i]);
+                    adapt_strides(shape, strides, bs, i);
+                }
+            }
+            return static_cast<std::size_t>(data_size);
+        }
+    }
+
+    template <layout_type L, class shape_type, class strides_type>
+    inline std::size_t compute_strides(const shape_type& shape, layout_type l, strides_type& strides)
+    {
+        return detail::compute_strides<L>(shape, l, strides, nullptr);
+    }
+
+    template <layout_type L, class shape_type, class strides_type, class backstrides_type>
+    inline std::size_t
+    compute_strides(const shape_type& shape, layout_type l, strides_type& strides, backstrides_type& backstrides)
+    {
+        return detail::compute_strides<L>(shape, l, strides, &backstrides);
+    }
+
+    template <class T1, class T2>
+    inline bool
+    stride_match_condition(const T1& stride, const T2& shape, const T1& data_size, bool zero_strides)
+    {
+        return (shape == T2(1) && stride == T1(0) && zero_strides) || (stride == data_size);
+    }
+
+    // zero_strides should be true when strides are set to 0 if the corresponding dimensions are 1
+    template <class shape_type, class strides_type>
+    inline bool
+    do_strides_match(const shape_type& shape, const strides_type& strides, layout_type l, bool zero_strides)
+    {
+        using value_type = typename strides_type::value_type;
+        value_type data_size = 1;
+        if (l == layout_type::row_major)
+        {
+            for (std::size_t i = strides.size(); i != 0; --i)
+            {
+                if (!stride_match_condition(strides[i - 1], shape[i - 1], data_size, zero_strides))
+                {
+                    return false;
+                }
+                data_size *= static_cast<value_type>(shape[i - 1]);
+            }
+            return true;
+        }
+        else if (l == layout_type::column_major)
+        {
+            for (std::size_t i = 0; i < strides.size(); ++i)
+            {
+                if (!stride_match_condition(strides[i], shape[i], data_size, zero_strides))
+                {
+                    return false;
+                }
+                data_size *= static_cast<value_type>(shape[i]);
+            }
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    template <class shape_type, class strides_type>
+    inline void adapt_strides(const shape_type& shape, strides_type& strides) noexcept
+    {
+        for (typename shape_type::size_type i = 0; i < shape.size(); ++i)
+        {
+            detail::adapt_strides(shape, strides, nullptr, i);
+        }
+    }
+
+    template <class shape_type, class strides_type, class backstrides_type>
+    inline void
+    adapt_strides(const shape_type& shape, strides_type& strides, backstrides_type& backstrides) noexcept
+    {
+        for (typename shape_type::size_type i = 0; i < shape.size(); ++i)
+        {
+            detail::adapt_strides(shape, strides, &backstrides, i);
+        }
+    }
+
+    namespace detail
+    {
+        template <class S>
+        inline S unravel_noexcept(typename S::value_type idx, const S& strides, layout_type l) noexcept
+        {
+            using value_type = typename S::value_type;
+            using size_type = typename S::size_type;
+            S result = xtl::make_sequence<S>(strides.size(), 0);
+            if (l == layout_type::row_major)
+            {
+                for (size_type i = 0; i < strides.size(); ++i)
+                {
+                    value_type str = strides[i];
+                    value_type quot = str != 0 ? idx / str : 0;
+                    idx = str != 0 ? idx % str : idx;
+                    result[i] = quot;
+                }
+            }
+            else
+            {
+                for (size_type i = strides.size(); i != 0; --i)
+                {
+                    value_type str = strides[i - 1];
+                    value_type quot = str != 0 ? idx / str : 0;
+                    idx = str != 0 ? idx % str : idx;
+                    result[i - 1] = quot;
+                }
+            }
+            return result;
+        }
+    }
+
+    template <class S>
+    inline S unravel_from_strides(typename S::value_type index, const S& strides, layout_type l)
+    {
+        if (l != layout_type::row_major && l != layout_type::column_major)
+        {
+            XTENSOR_THROW(std::runtime_error, "unravel_index: dynamic layout not supported");
+        }
+        return detail::unravel_noexcept(index, strides, l);
+    }
+
+    template <class S, class T>
+    inline get_value_type_t<T> ravel_from_strides(const T& index, const S& strides)
+    {
+        return element_offset<get_value_type_t<T>>(strides, index.begin(), index.end());
+    }
+
+    template <class S>
+    inline get_strides_t<S> unravel_index(typename S::value_type index, const S& shape, layout_type l)
+    {
+        using strides_type = get_strides_t<S>;
+        using strides_value_type = typename strides_type::value_type;
+        strides_type strides = xtl::make_sequence<strides_type>(shape.size(), 0);
+        compute_strides(shape, l, strides);
+        return unravel_from_strides(static_cast<strides_value_type>(index), strides, l);
+    }
+
+    template <class S, class T>
+    inline std::vector<get_strides_t<S>> unravel_indices(const T& idx, const S& shape, layout_type l)
+    {
+        using strides_type = get_strides_t<S>;
+        using strides_value_type = typename strides_type::value_type;
+        strides_type strides = xtl::make_sequence<strides_type>(shape.size(), 0);
+        compute_strides(shape, l, strides);
+        std::vector<get_strides_t<S>> out(idx.size());
+        auto out_iter = out.begin();
+        auto idx_iter = idx.begin();
+        for (; out_iter != out.end(); ++out_iter, ++idx_iter)
+        {
+            *out_iter = unravel_from_strides(static_cast<strides_value_type>(*idx_iter), strides, l);
+        }
+        return out;
+    }
+
+    template <class S, class T>
+    inline get_value_type_t<T> ravel_index(const T& index, const S& shape, layout_type l)
+    {
+        using strides_type = get_strides_t<S>;
+        strides_type strides = xtl::make_sequence<strides_type>(shape.size(), 0);
+        compute_strides(shape, l, strides);
+        return ravel_from_strides(index, strides);
+    }
+
+    template <class S, class stype>
+    inline S uninitialized_shape(stype size)
+    {
+        using value_type = typename S::value_type;
+        using size_type = typename S::size_type;
+        return xtl::make_sequence<S>(static_cast<size_type>(size), std::numeric_limits<value_type>::max());
+    }
+
+    template <class S1, class S2>
+    inline bool broadcast_shape(const S1& input, S2& output)
+    {
+        bool trivial_broadcast = (input.size() == output.size());
+        // Indices are faster than reverse iterators
+        using value_type = typename S2::value_type;
+        auto output_index = output.size();
+        auto input_index = input.size();
+
+        if (output_index < input_index)
+        {
+            throw_broadcast_error(output, input);
+        }
+        for (; input_index != 0; --input_index, --output_index)
+        {
+            // First case: output = (MAX, MAX, ...., MAX)
+            // output is a new shape that has not been through
+            // the broadcast process yet; broadcast is trivial
+            if (output[output_index - 1] == std::numeric_limits<value_type>::max())
+            {
+                output[output_index - 1] = static_cast<value_type>(input[input_index - 1]);
+            }
+            // Second case: output has been initialized to 1. Broadcast is trivial
+            // only if input is 1 to.
+            else if (output[output_index - 1] == 1)
+            {
+                output[output_index - 1] = static_cast<value_type>(input[input_index - 1]);
+                trivial_broadcast = trivial_broadcast && (input[input_index - 1] == 1);
+            }
+            // Third case: output has been initialized to something different from 1.
+            // if input is 1, then the broadcast is not trivial
+            else if (input[input_index - 1] == 1)
+            {
+                trivial_broadcast = false;
+            }
+            // Last case: input and output must have the same value, else
+            // shape are not compatible and an exception is thrown
+            else if (static_cast<value_type>(input[input_index - 1]) != output[output_index - 1])
+            {
+                throw_broadcast_error(output, input);
+            }
+        }
+        return trivial_broadcast;
+    }
+
+    template <class S1, class S2>
+    inline bool broadcastable(const S1& src_shape, const S2& dst_shape)
+    {
+        auto src_iter = src_shape.crbegin();
+        auto dst_iter = dst_shape.crbegin();
+        bool res = dst_shape.size() >= src_shape.size();
+        for (; src_iter != src_shape.crend() && res; ++src_iter, ++dst_iter)
+        {
+            res = (static_cast<std::size_t>(*src_iter) == static_cast<std::size_t>(*dst_iter))
+                  || (*src_iter == 1);
+        }
+        return res;
+    }
+
+    template <>
+    struct check_strides_overlap<layout_type::row_major>
+    {
+        template <class S1, class S2>
+        static std::size_t get(const S1& s1, const S2& s2)
+        {
+            using value_type = typename S1::value_type;
+            // Indices are faster than reverse iterators
+            auto s1_index = s1.size();
+            auto s2_index = s2.size();
+
+            for (; s2_index != 0; --s1_index, --s2_index)
+            {
+                if (static_cast<value_type>(s1[s1_index - 1]) != static_cast<value_type>(s2[s2_index - 1]))
+                {
+                    break;
+                }
+            }
+            return s1_index;
+        }
+    };
+
+    template <>
+    struct check_strides_overlap<layout_type::column_major>
+    {
+        template <class S1, class S2>
+        static std::size_t get(const S1& s1, const S2& s2)
+        {
+            // Indices are faster than reverse iterators
+            using size_type = typename S1::size_type;
+            using value_type = typename S1::value_type;
+            size_type index = 0;
+
+            // This check is necessary as column major "broadcasting" is still
+            // performed in a row major fashion
+            if (s1.size() != s2.size())
+            {
+                return 0;
+            }
+
+            auto size = s2.size();
+
+            for (; index < size; ++index)
+            {
+                if (static_cast<value_type>(s1[index]) != static_cast<value_type>(s2[index]))
+                {
+                    break;
+                }
+            }
+            return index;
+        }
+    };
+
+    namespace detail
+    {
+        template <class S, std::size_t dim>
+        inline bool check_in_bounds_impl(const S&)
+        {
+            return true;
+        }
+
+        template <class S, std::size_t dim>
+        inline bool check_in_bounds_impl(const S&, missing_type)
+        {
+            return true;
+        }
+
+        template <class S, std::size_t dim, class T, class... Args>
+        inline bool check_in_bounds_impl(const S& shape, T& arg, Args&... args)
+        {
+            if (sizeof...(Args) + 1 > shape.size())
+            {
+                return check_in_bounds_impl<S, dim>(shape, args...);
+            }
+            else
+            {
+                return arg >= T(0) && arg < static_cast<T>(shape[dim])
+                       && check_in_bounds_impl<S, dim + 1>(shape, args...);
+            }
+        }
+    }
+
+    template <class S, class... Args>
+    inline bool check_in_bounds(const S& shape, Args&... args)
+    {
+        return detail::check_in_bounds_impl<S, 0>(shape, args...);
+    }
+
+    namespace detail
+    {
+        template <class S, std::size_t dim>
+        inline void normalize_periodic_impl(const S&)
+        {
+        }
+
+        template <class S, std::size_t dim>
+        inline void normalize_periodic_impl(const S&, missing_type)
+        {
+        }
+
+        template <class S, std::size_t dim, class T, class... Args>
+        inline void normalize_periodic_impl(const S& shape, T& arg, Args&... args)
+        {
+            if (sizeof...(Args) + 1 > shape.size())
+            {
+                normalize_periodic_impl<S, dim>(shape, args...);
+            }
+            else
+            {
+                T n = static_cast<T>(shape[dim]);
+                arg = (n + (arg % n)) % n;
+                normalize_periodic_impl<S, dim + 1>(shape, args...);
+            }
+        }
+    }
+
+    template <class S, class... Args>
+    inline void normalize_periodic(const S& shape, Args&... args)
+    {
+        check_dimension(shape, args...);
+        detail::normalize_periodic_impl<S, 0>(shape, args...);
+    }
+}
+
+#endif
diff --git a/include/xtensor/core/xtensor_config.hpp b/include/xtensor/core/xtensor_config.hpp
new file mode 100644
index 000000000..959a3b2a4
--- /dev/null
+++ b/include/xtensor/core/xtensor_config.hpp
@@ -0,0 +1,132 @@
+/***************************************************************************
+ * 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_CONFIG_HPP
+#define XTENSOR_CONFIG_HPP
+
+#define XTENSOR_VERSION_MAJOR 0
+#define XTENSOR_VERSION_MINOR 27
+#define XTENSOR_VERSION_PATCH 1
+
+
+// Define if the library is going to be using exceptions.
+#if (!defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND))
+#undef XTENSOR_DISABLE_EXCEPTIONS
+#define XTENSOR_DISABLE_EXCEPTIONS
+#endif
+
+// Exception support.
+#if defined(XTENSOR_DISABLE_EXCEPTIONS)
+#include <iostream>
+#define XTENSOR_THROW(_, msg)          \
+    {                                  \
+        std::cerr << msg << std::endl; \
+        std::abort();                  \
+    }
+#else
+#define XTENSOR_THROW(exception, msg) throw exception(msg)
+#endif
+
+// Workaround for some missing constexpr functionality in MSVC 2015 and MSVC 2017 x86
+#if defined(_MSC_VER)
+// The following must not be defined to const, otherwise
+// it prevents generation of copy operators of classes
+// containing XTENSOR_CONSTEXPR_ENHANCED_STATIC members
+#define XTENSOR_CONSTEXPR_ENHANCED_STATIC
+#else
+#define XTENSOR_CONSTEXPR_ENHANCED_STATIC constexpr static
+#endif
+
+#ifndef XTENSOR_DEFAULT_DATA_CONTAINER
+#define XTENSOR_DEFAULT_DATA_CONTAINER(T, A) uvector<T, A>
+#endif
+
+#ifndef XTENSOR_DEFAULT_SHAPE_CONTAINER
+#define XTENSOR_DEFAULT_SHAPE_CONTAINER(T, EA, SA) \
+    xt::svector<typename XTENSOR_DEFAULT_DATA_CONTAINER(T, EA)::size_type, 4, SA, true>
+#endif
+
+#ifdef XTENSOR_USE_XSIMD
+#include <xsimd/xsimd.hpp>
+#define XSIMD_DEFAULT_ALIGNMENT xsimd::default_arch::alignment()
+#endif
+
+
+#ifndef XTENSOR_DEFAULT_ALLOCATOR
+#ifdef XTENSOR_ALLOC_TRACKING
+#ifndef XTENSOR_ALLOC_TRACKING_POLICY
+#define XTENSOR_ALLOC_TRACKING_POLICY xt::alloc_tracking::policy::print
+#endif
+#ifdef XTENSOR_USE_XSIMD
+#include <xsimd/xsimd.hpp>
+#define XTENSOR_DEFAULT_ALLOCATOR(T) \
+    xt::tracking_allocator<T, xsimd::aligned_allocator<T, XSIMD_DEFAULT_ALIGNMENT>, XTENSOR_ALLOC_TRACKING_POLICY>
+#else
+#define XTENSOR_DEFAULT_ALLOCATOR(T) \
+    xt::tracking_allocator<T, std::allocator<T>, XTENSOR_ALLOC_TRACKING_POLICY>
+#endif
+#else
+#ifdef XTENSOR_USE_XSIMD
+
+#define XTENSOR_DEFAULT_ALLOCATOR(T) xsimd::aligned_allocator<T, XTENSOR_DEFAULT_ALIGNMENT>
+#else
+#define XTENSOR_DEFAULT_ALLOCATOR(T) std::allocator<T>
+#endif
+#endif
+#endif
+
+#ifndef XTENSOR_DEFAULT_ALIGNMENT
+#ifdef XTENSOR_USE_XSIMD
+#define XTENSOR_DEFAULT_ALIGNMENT XSIMD_DEFAULT_ALIGNMENT
+#else
+#define XTENSOR_DEFAULT_ALIGNMENT 0
+#endif
+#endif
+
+#ifndef XTENSOR_DEFAULT_LAYOUT
+#define XTENSOR_DEFAULT_LAYOUT ::xt::layout_type::row_major
+#endif
+
+#ifndef XTENSOR_DEFAULT_TRAVERSAL
+#define XTENSOR_DEFAULT_TRAVERSAL ::xt::layout_type::row_major
+#endif
+
+#ifndef XTENSOR_OPENMP_TRESHOLD
+#define XTENSOR_OPENMP_TRESHOLD 0
+#endif
+
+#ifndef XTENSOR_TBB_THRESHOLD
+#define XTENSOR_TBB_THRESHOLD 0
+#endif
+
+#ifndef XTENSOR_SELECT_ALIGN
+#define XTENSOR_SELECT_ALIGN(T) (XTENSOR_DEFAULT_ALIGNMENT != 0 ? XTENSOR_DEFAULT_ALIGNMENT : alignof(T))
+#endif
+
+#ifndef XTENSOR_FIXED_ALIGN
+#define XTENSOR_FIXED_ALIGN XTENSOR_SELECT_ALIGN(void*)
+#endif
+
+#ifdef IN_DOXYGEN
+namespace xtl
+{
+    template <class... T>
+    struct conjunction
+    {
+        constexpr bool value = true;
+    };
+
+    template <class... C>
+    using check_concept = std::enable_if_t<conjunction<C...>::value, int>;
+
+#define XTL_REQUIRES(...) xtl::check_concept<__VA_ARGS__> = 0
+}
+#endif
+
+#endif
diff --git a/include/xtensor/xtensor_forward.hpp b/include/xtensor/core/xtensor_forward.hpp
similarity index 50%
rename from include/xtensor/xtensor_forward.hpp
rename to include/xtensor/core/xtensor_forward.hpp
index 969f8b738..0183b4527 100644
--- a/include/xtensor/xtensor_forward.hpp
+++ b/include/xtensor/core/xtensor_forward.hpp
@@ -1,40 +1,57 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_FORWARD_HPP
 #define XTENSOR_FORWARD_HPP
 
+// This file contains forward declarations and
+// alias types to solve the problem of circular
+// includes. It should not contain anything else
+// and should not bring additional dependencies to
+// the files that include it. So:
+// - do NOT define classes of metafunctions here
+// - do NOT include other headers
+//
+// If you need to do so, something is probably
+// going wrong (either your change, or xtensor
+// needs to be refactored).
+
 #include <memory>
 #include <vector>
 
 #include <xtl/xoptional_sequence.hpp>
 
-#include "xexpression.hpp"
-#include "xlayout.hpp"
-#include "xshape.hpp"
-#include "xstorage.hpp"
-#include "xtensor_config.hpp"
-#include "xtensor_simd.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xtensor_config.hpp"
 
 namespace xt
 {
+    struct xtensor_expression_tag;
+    struct xoptional_expression_tag;
+
     template <class C>
     struct xcontainer_inner_types;
 
     template <class D>
     class xcontainer;
 
-    template <class EC,
-              layout_type L = XTENSOR_DEFAULT_LAYOUT,
-              class SC = XTENSOR_DEFAULT_SHAPE_CONTAINER(typename EC::value_type,
-                                                 typename EC::allocator_type,
-                                                 std::allocator<typename EC::size_type>),
-              class Tag = xtensor_expression_tag>
+    template <class T, class A>
+    class uvector;
+
+    template <class T, std::size_t N, class A, bool Init>
+    class svector;
+
+    template <
+        class EC,
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class SC = XTENSOR_DEFAULT_SHAPE_CONTAINER(typename EC::value_type, typename EC::allocator_type, std::allocator<typename EC::size_type>),
+        class Tag = xtensor_expression_tag>
     class xarray_container;
 
     /**
@@ -42,33 +59,33 @@ namespace xt
      * Alias template on xarray_container with default parameters for data container
      * type and shape / strides container type. This allows to write
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{1., 2.}, {3., 4.}};
-     * \endcode
+     * @endcode
      *
      * instead of the heavier syntax
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray_container<std::vector<double>, std::vector<std::size_t>> a = ...
-     * \endcode
+     * @endcode
      *
      * @tparam T The value type of the elements.
-     * @tparam L The layout_type of the xarray_container (default: row_major).
+     * @tparam L The layout_type of the xarray_container (default: XTENSOR_DEFAULT_LAYOUT).
      * @tparam A The allocator of the container holding the elements.
      * @tparam SA The allocator of the containers holding the shape and the strides.
      */
-    template <class T,
-              layout_type L = XTENSOR_DEFAULT_LAYOUT,
-              class A = XTENSOR_DEFAULT_ALLOCATOR(T),
-              class SA = std::allocator<typename std::vector<T, A>::size_type>>
+    template <
+        class T,
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class A = XTENSOR_DEFAULT_ALLOCATOR(T),
+        class SA = std::allocator<typename std::vector<T, A>::size_type>>
     using xarray = xarray_container<XTENSOR_DEFAULT_DATA_CONTAINER(T, A), L, XTENSOR_DEFAULT_SHAPE_CONTAINER(T, A, SA)>;
 
-    template <class EC,
-              layout_type L = XTENSOR_DEFAULT_LAYOUT,
-              class SC = XTENSOR_DEFAULT_SHAPE_CONTAINER(typename EC::value_type,
-                                                 std::allocator<typename EC::size_type>,
-                                                 std::allocator<typename EC::size_type>),
-              class Tag = xtensor_expression_tag>
+    template <
+        class EC,
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class SC = XTENSOR_DEFAULT_SHAPE_CONTAINER(typename EC::value_type, std::allocator<typename EC::size_type>, std::allocator<typename EC::size_type>),
+        class Tag = xtensor_expression_tag>
     class xarray_adaptor;
 
     /**
@@ -76,17 +93,22 @@ namespace xt
      * Alias template on xarray_container for handling missing values
      *
      * @tparam T The value type of the elements.
-     * @tparam L The layout_type of the container (default: row_major).
+     * @tparam L The layout_type of the container (default: XTENSOR_DEFAULT_LAYOUT).
      * @tparam A The allocator of the container holding the elements.
      * @tparam BA The allocator of the container holding the missing flags.
      * @tparam SA The allocator of the containers holding the shape and the strides.
      */
-    template <class T,
-              layout_type L = XTENSOR_DEFAULT_LAYOUT,
-              class A = XTENSOR_DEFAULT_ALLOCATOR(T),
-              class BC = xtl::xdynamic_bitset<std::size_t>,
-              class SA = std::allocator<typename std::vector<T, A>::size_type>>
-    using xarray_optional = xarray_container<xtl::xoptional_vector<T, A, BC>, L, XTENSOR_DEFAULT_SHAPE_CONTAINER(T, A, SA), xoptional_expression_tag>;
+    template <
+        class T,
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class A = XTENSOR_DEFAULT_ALLOCATOR(T),
+        class BC = xtl::xdynamic_bitset<std::size_t>,
+        class SA = std::allocator<typename std::vector<T, A>::size_type>>
+    using xarray_optional = xarray_container<
+        xtl::xoptional_vector<T, A, BC>,
+        L,
+        XTENSOR_DEFAULT_SHAPE_CONTAINER(T, A, SA),
+        xoptional_expression_tag>;
 
     template <class EC, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
     class xtensor_container;
@@ -96,30 +118,30 @@ namespace xt
      * Alias template on xtensor_container with default parameters for data container
      * type. This allows to write
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xtensor<double, 2> a = {{1., 2.}, {3., 4.}};
-     * \endcode
+     * @endcode
      *
      * instead of the heavier syntax
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xtensor_container<std::vector<double>, 2> a = ...
-     * \endcode
+     * @endcode
      *
      * @tparam T The value type of the elements.
      * @tparam N The dimension of the tensor.
-     * @tparam L The layout_type of the tensor (default: row_major).
+     * @tparam L The layout_type of the tensor (default: XTENSOR_DEFAULT_LAYOUT).
      * @tparam A The allocator of the containers holding the elements.
      */
-    template <class T,
-              std::size_t N,
-              layout_type L = XTENSOR_DEFAULT_LAYOUT,
-              class A = XTENSOR_DEFAULT_ALLOCATOR(T)>
+    template <class T, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class A = XTENSOR_DEFAULT_ALLOCATOR(T)>
     using xtensor = xtensor_container<XTENSOR_DEFAULT_DATA_CONTAINER(T, A), N, L>;
 
     template <class EC, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
     class xtensor_adaptor;
 
+    template <class EC, std::size_t N, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
+    class xtensor_view;
+
     template <std::size_t... N>
     class fixed_shape;
 
@@ -130,10 +152,10 @@ namespace xt
     template <std::size_t... N>
     using xshape = fixed_shape<N...>;
 
-    template <class ET, class S, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
+    template <class ET, class S, layout_type L = XTENSOR_DEFAULT_LAYOUT, bool Sharable = true, class Tag = xtensor_expression_tag>
     class xfixed_container;
 
-    template <class ET, class S, layout_type L = XTENSOR_DEFAULT_LAYOUT, class Tag = xtensor_expression_tag>
+    template <class ET, class S, layout_type L = XTENSOR_DEFAULT_LAYOUT, bool Sharable = true, class Tag = xtensor_expression_tag>
     class xfixed_adaptor;
 
     /**
@@ -141,25 +163,23 @@ namespace xt
      * Alias template on xfixed_container with default parameters for layout
      * type. This allows to write
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xtensor_fixed<double, xt::xshape<2, 2>> a = {{1., 2.}, {3., 4.}};
-     * \endcode
+     * @endcode
      *
      * instead of the syntax
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xfixed_container<double, xt::xshape<2, 2>, xt::layout_type::row_major> a = ...
-     * \endcode
+     * @endcode
      *
      * @tparam T The value type of the elements.
      * @tparam FSH A xshape template shape.
-     * @tparam L The layout_type of the tensor (default: row_major).
-     * @tparam A The allocator of the containers holding the elements.
+     * @tparam L The layout_type of the tensor (default: XTENSOR_DEFAULT_LAYOUT).
+     * @tparam Sharable Whether the tensor can be used in a shared expression.
      */
-    template <class T,
-              class FSH,
-              layout_type L = XTENSOR_DEFAULT_LAYOUT>
-    using xtensor_fixed = xfixed_container<T, FSH, L>;
+    template <class T, class FSH, layout_type L = XTENSOR_DEFAULT_LAYOUT, bool Sharable = true>
+    using xtensor_fixed = xfixed_container<T, FSH, L, Sharable>;
 
     /**
      * @typedef xtensor_optional
@@ -167,15 +187,16 @@ namespace xt
      *
      * @tparam T The value type of the elements.
      * @tparam N The dimension of the tensor.
-     * @tparam L The layout_type of the container (default: row_major).
+     * @tparam L The layout_type of the container (default: XTENSOR_DEFAULT_LAYOUT).
      * @tparam A The allocator of the containers holding the elements.
      * @tparam BA The allocator of the container holding the missing flags.
      */
-    template <class T,
-              std::size_t N,
-              layout_type L = XTENSOR_DEFAULT_LAYOUT,
-              class A = XTENSOR_DEFAULT_ALLOCATOR(T),
-              class BC = xtl::xdynamic_bitset<std::size_t>>
+    template <
+        class T,
+        std::size_t N,
+        layout_type L = XTENSOR_DEFAULT_LAYOUT,
+        class A = XTENSOR_DEFAULT_ALLOCATOR(T),
+        class BC = xtl::xdynamic_bitset<std::size_t>>
     using xtensor_optional = xtensor_container<xtl::xoptional_vector<T, A, BC>, N, L, xoptional_expression_tag>;
 
     template <class CT, class... S>
@@ -183,34 +204,6 @@ namespace xt
 
     template <class F, class... CT>
     class xfunction;
-
-    namespace check_policy
-    {
-        struct none
-        {
-        };
-        struct full
-        {
-        };
-    }
-
-    namespace evaluation_strategy
-    {
-        struct base
-        {
-        };
-        struct immediate : base
-        {
-        };
-        struct lazy : base
-        {
-        };
-        /*
-        struct cached
-        {
-        };
-        */
-    }
 }
 
 #endif
diff --git a/include/xtensor/xvectorize.hpp b/include/xtensor/core/xvectorize.hpp
similarity index 69%
rename from include/xtensor/xvectorize.hpp
rename to include/xtensor/core/xvectorize.hpp
index 5de82cf00..edd199021 100644
--- a/include/xtensor/xvectorize.hpp
+++ b/include/xtensor/core/xvectorize.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_VECTORIZE_HPP
 #define XTENSOR_VECTORIZE_HPP
@@ -12,8 +13,8 @@
 #include <type_traits>
 #include <utility>
 
-#include "xfunction.hpp"
-#include "xutils.hpp"
+#include "../core/xfunction.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
@@ -53,13 +54,9 @@ namespace xt
     template <class F, class R, class... Args>
     xvectorizer<F, R> vectorize(F&& f, R (*)(Args...));
 
-// Workaround for Visual Studio 15.7.1.
-// Error C2668 (ambiguous call to overloaded function) mistaking a declarations
-// for the definition of another overload.
-#ifndef _MSC_VER
     template <class F>
-    auto vectorize(F&& f) -> decltype(vectorize(std::forward<F>(f), std::declval<detail::get_function_type<F>*>()));
-#endif
+    auto vectorize(F&& f)
+        -> decltype(vectorize(std::forward<F>(f), std::declval<detail::get_function_type<F>*>()));
 
     /******************************
      * xvectorizer implementation *
@@ -92,7 +89,8 @@ namespace xt
     }
 
     template <class F>
-    inline auto vectorize(F&& f) -> decltype(vectorize(std::forward<F>(f), std::declval<detail::get_function_type<F>*>()))
+    inline auto vectorize(F&& f)
+        -> decltype(vectorize(std::forward<F>(f), std::declval<detail::get_function_type<F>*>()))
     {
         return vectorize(std::forward<F>(f), static_cast<detail::get_function_type<F>*>(nullptr));
     }
diff --git a/include/xtensor/xbuilder.hpp b/include/xtensor/generators/xbuilder.hpp
similarity index 50%
rename from include/xtensor/xbuilder.hpp
rename to include/xtensor/generators/xbuilder.hpp
index c58663c03..1026b21c7 100644
--- a/include/xtensor/xbuilder.hpp
+++ b/include/xtensor/generators/xbuilder.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
 /**
  * @brief standard mathematical functions for xexpressions
@@ -14,22 +15,21 @@
 #define XTENSOR_BUILDER_HPP
 
 #include <array>
+#include <chrono>
 #include <cmath>
 #include <cstddef>
 #include <functional>
 #include <utility>
 #include <vector>
-#ifdef X_OLD_CLANG
-    #include <initializer_list>
-#endif
 
 #include <xtl/xclosure.hpp>
 #include <xtl/xsequence.hpp>
+#include <xtl/xtype_traits.hpp>
 
-#include "xbroadcast.hpp"
-#include "xfunction.hpp"
-#include "xgenerator.hpp"
-#include "xoperation.hpp"
+#include "../core/xfunction.hpp"
+#include "../core/xoperation.hpp"
+#include "../generators/xgenerator.hpp"
+#include "../views/xbroadcast.hpp"
 
 namespace xt
 {
@@ -48,19 +48,11 @@ namespace xt
         return broadcast(T(1), std::forward<S>(shape));
     }
 
-#ifdef X_OLD_CLANG
-    template <class T, class I>
-    inline auto ones(std::initializer_list<I> shape) noexcept
-    {
-        return broadcast(T(1), shape);
-    }
-#else
     template <class T, class I, std::size_t L>
     inline auto ones(const I (&shape)[L]) noexcept
     {
         return broadcast(T(1), shape);
     }
-#endif
 
     /*********
      * zeros *
@@ -76,19 +68,11 @@ namespace xt
         return broadcast(T(0), std::forward<S>(shape));
     }
 
-#ifdef X_OLD_CLANG
-    template <class T, class I>
-    inline auto zeros(std::initializer_list<I> shape) noexcept
-    {
-        return broadcast(T(0), shape);
-    }
-#else
     template <class T, class I, std::size_t L>
     inline auto zeros(const I (&shape)[L]) noexcept
     {
         return broadcast(T(0), shape);
     }
-#endif
 
     /**
      * Create a xcontainer (xarray, xtensor or xtensor_fixed) with uninitialized values of
@@ -111,17 +95,15 @@ namespace xt
     inline xtensor<T, N, L> empty(const std::array<ST, N>& shape)
     {
         using shape_type = typename xtensor<T, N>::shape_type;
-        return xtensor<T, N, L>(xtl::forward_sequence<shape_type>(shape));
+        return xtensor<T, N, L>(xtl::forward_sequence<shape_type, decltype(shape)>(shape));
     }
 
-#ifndef X_OLD_CLANG
     template <class T, layout_type L = XTENSOR_DEFAULT_LAYOUT, class I, std::size_t N>
-    inline xtensor<T, N, L> empty(const I(&shape)[N])
+    inline xtensor<T, N, L> empty(const I (&shape)[N])
     {
         using shape_type = typename xtensor<T, N>::shape_type;
-        return xtensor<T, N, L>(xtl::forward_sequence<shape_type>(shape));
+        return xtensor<T, N, L>(xtl::forward_sequence<shape_type, decltype(shape)>(shape));
     }
-#endif
 
     template <class T, layout_type L = XTENSOR_DEFAULT_LAYOUT, std::size_t... N>
     inline xtensor_fixed<T, fixed_shape<N...>, L> empty(const fixed_shape<N...>& /*shape*/)
@@ -136,9 +118,9 @@ namespace xt
      * @param e the xexpression from which to extract shape, value type and layout.
      */
     template <class E>
-    inline typename E::temporary_type empty_like(const xexpression<E>& e)
+    inline auto empty_like(const xexpression<E>& e)
     {
-        using xtype = typename E::temporary_type;
+        using xtype = temporary_type_t<E>;
         auto res = xtype::from_shape(e.derived_cast().shape());
         return res;
     }
@@ -151,9 +133,9 @@ namespace xt
      * @param fill_value the value used to set each element of the returned xcontainer.
      */
     template <class E>
-    inline typename E::temporary_type full_like(const xexpression<E>& e, typename E::value_type fill_value)
+    inline auto full_like(const xexpression<E>& e, typename E::value_type fill_value)
     {
-        using xtype = typename E::temporary_type;
+        using xtype = temporary_type_t<E>;
         auto res = xtype::from_shape(e.derived_cast().shape());
         res.fill(fill_value);
         return res;
@@ -164,12 +146,12 @@ namespace xt
      * the same shape, value type and layout as the input xexpression *e*.
      *
      * Note: contrary to zeros(shape), this function returns a non-lazy, allocated container!
-     * Use ``xt::zeros<double>(e.shape());` for a lazy version.
+     * Use ``xt::zeros<double>(e.shape());`` for a lazy version.
      *
      * @param e the xexpression from which to extract shape, value type and layout.
      */
     template <class E>
-    inline typename E::temporary_type zeros_like(const xexpression<E>& e)
+    inline auto zeros_like(const xexpression<E>& e)
     {
         return full_like(e, typename E::value_type(0));
     }
@@ -184,68 +166,162 @@ namespace xt
      * @param e the xexpression from which to extract shape, value type and layout.
      */
     template <class E>
-    inline typename E::temporary_type ones_like(const xexpression<E>& e)
+    inline auto ones_like(const xexpression<E>& e)
     {
         return full_like(e, typename E::value_type(1));
     }
 
     namespace detail
     {
-        template <class T>
-        class arange_impl
+        template <class T, class S>
+        struct get_mult_type_impl
+        {
+            using type = T;
+        };
+
+        template <class T, class R, class P>
+        struct get_mult_type_impl<T, std::chrono::duration<R, P>>
+        {
+            using type = R;
+        };
+
+        template <class T, class S>
+        using get_mult_type = typename get_mult_type_impl<T, S>::type;
+
+        // These methods should be private methods of arange_generator, however thi leads
+        // to ICE on VS2015
+        template <class R, class E, class U, class X, XTL_REQUIRES(xtl::is_integral<X>)>
+        inline void arange_assign_to(xexpression<E>& e, U start, U, X step, bool) noexcept
+        {
+            auto& de = e.derived_cast();
+            U value = start;
+
+            for (auto&& el : de.storage())
+            {
+                el = static_cast<R>(value);
+                value += step;
+            }
+        }
+
+        template <class R, class E, class U, class X, XTL_REQUIRES(std::negation<xtl::is_integral<X>>)>
+        inline void arange_assign_to(xexpression<E>& e, U start, U stop, X step, bool endpoint) noexcept
+        {
+            auto& buf = e.derived_cast().storage();
+            using size_type = decltype(buf.size());
+            using mult_type = get_mult_type<U, X>;
+            size_type num = buf.size();
+            for (size_type i = 0; i < num; ++i)
+            {
+                buf[i] = static_cast<R>(start + step * mult_type(i));
+            }
+            if (endpoint && num > 1)
+            {
+                buf[num - 1] = static_cast<R>(stop);
+            }
+        }
+
+        template <class T, class R = T, class S = T>
+        class arange_generator
         {
         public:
 
-            using value_type = T;
+            using value_type = R;
+            using step_type = S;
 
-            arange_impl(T start, T stop, T step)
-                : m_start(start), m_stop(stop), m_step(step)
+            arange_generator(T start, T stop, S step, size_t num_steps, bool endpoint = false)
+                : m_start(start)
+                , m_stop(stop)
+                , m_step(step)
+                , m_num_steps(num_steps)
+                , m_endpoint(endpoint)
             {
             }
 
             template <class... Args>
-            inline T operator()(Args... args) const
+            inline R operator()(Args... args) const
             {
                 return access_impl(args...);
             }
 
             template <class It>
-            inline T element(It first, It) const
+            inline R element(It first, It) const
             {
-                return m_start + m_step * T(*first);
+                return access_impl(*first);
             }
 
             template <class E>
             inline void assign_to(xexpression<E>& e) const noexcept
             {
-                auto& de = e.derived_cast();
-                value_type value = m_start;
-
-                for (auto& el : de.storage())
-                {
-                    el = value;
-                    value += m_step;
-                }
+                arange_assign_to<R>(e, m_start, m_stop, m_step, m_endpoint);
             }
 
         private:
 
-            value_type m_start;
-            value_type m_stop;
-            value_type m_step;
+            T m_start;
+            T m_stop;
+            step_type m_step;
+            size_t m_num_steps;
+            bool m_endpoint;  // true for setting the last element to m_stop
 
             template <class T1, class... Args>
-            inline T access_impl(T1 t, Args...) const
+            inline R access_impl(T1 t, Args...) const
             {
-                return m_start + m_step * T(t);
+                if (m_endpoint && m_num_steps > 1 && size_t(t) == m_num_steps - 1)
+                {
+                    return static_cast<R>(m_stop);
+                }
+                // Avoids warning when T = char (because char + char => int!)
+                using mult_type = get_mult_type<T, S>;
+                return static_cast<R>(m_start + m_step * mult_type(t));
             }
 
-            inline T access_impl() const
+            inline R access_impl() const
             {
-                return m_start;
+                return static_cast<R>(m_start);
             }
         };
 
+        template <class T, class S>
+        using both_integer = std::conjunction<xtl::is_integral<T>, xtl::is_integral<S>>;
+
+        template <class T, class S>
+        using integer_with_signed_integer = std::conjunction<both_integer<T, S>, xtl::is_signed<S>>;
+
+        template <class T, class S>
+        using integer_with_unsigned_integer = std::conjunction<both_integer<T, S>, std::is_unsigned<S>>;
+
+        template <class T, class S = T, XTL_REQUIRES(std::negation<both_integer<T, S>>)>
+        inline auto arange_impl(T start, T stop, S step = 1) noexcept
+        {
+            std::size_t shape = static_cast<std::size_t>(std::ceil((stop - start) / step));
+            return detail::make_xgenerator(detail::arange_generator<T, T, S>(start, stop, step, shape), {shape});
+        }
+
+        template <class T, class S = T, XTL_REQUIRES(integer_with_signed_integer<T, S>)>
+        inline auto arange_impl(T start, T stop, S step = 1) noexcept
+        {
+            bool empty_cond = (stop - start) / step <= 0;
+            std::size_t shape = 0;
+            if (!empty_cond)
+            {
+                shape = stop > start ? static_cast<std::size_t>((stop - start + step - S(1)) / step)
+                                     : static_cast<std::size_t>((start - stop - step - S(1)) / -step);
+            }
+            return detail::make_xgenerator(detail::arange_generator<T, T, S>(start, stop, step, shape), {shape});
+        }
+
+        template <class T, class S = T, XTL_REQUIRES(integer_with_unsigned_integer<T, S>)>
+        inline auto arange_impl(T start, T stop, S step = 1) noexcept
+        {
+            bool empty_cond = stop <= start;
+            std::size_t shape = 0;
+            if (!empty_cond)
+            {
+                shape = static_cast<std::size_t>((stop - start + step - S(1)) / step);
+            }
+            return detail::make_xgenerator(detail::arange_generator<T, T, S>(start, stop, step, shape), {shape});
+        }
+
         template <class F>
         class fn_impl
         {
@@ -281,6 +357,7 @@ namespace xt
         private:
 
             F m_ft;
+
             template <class It>
             inline value_type access_impl(const It& begin, const It& end) const
             {
@@ -304,12 +381,12 @@ namespace xt
             inline T operator()(const It& /*begin*/, const It& end) const
             {
                 using lvalue_type = typename std::iterator_traits<It>::value_type;
-                return *(end - 1) == *(end - 2) + static_cast<lvalue_type>(static_cast<unsigned int>(m_k)) ? T(1) : T(0);
+                return *(end - 1) == *(end - 2) + static_cast<lvalue_type>(m_k) ? T(1) : T(0);
             }
 
         private:
 
-            int m_k;
+            std::ptrdiff_t m_k;
         };
     }
 
@@ -351,11 +428,10 @@ namespace xt
      * @tparam T value_type of xexpression
      * @return xgenerator that generates the values on access
      */
-    template <class T>
-    inline auto arange(T start, T stop, T step = 1) noexcept
+    template <class T, class S = T>
+    inline auto arange(T start, T stop, S step = 1) noexcept
     {
-        std::size_t shape = static_cast<std::size_t>(std::ceil((stop - start) / step));
-        return detail::make_xgenerator(detail::arange_impl<T>(start, stop, step), {shape});
+        return detail::arange_impl(start, stop, step);
     }
 
     /**
@@ -384,8 +460,11 @@ namespace xt
     inline auto linspace(T start, T stop, std::size_t num_samples = 50, bool endpoint = true) noexcept
     {
         using fp_type = std::common_type_t<T, double>;
-        fp_type step = fp_type(stop - start) / fp_type(num_samples - (endpoint ? 1 : 0));
-        return cast<T>(detail::make_xgenerator(detail::arange_impl<fp_type>(fp_type(start), fp_type(stop), step), {num_samples}));
+        fp_type step = fp_type(stop - start) / std::fmax(fp_type(1), fp_type(num_samples - (endpoint ? 1 : 0)));
+        return detail::make_xgenerator(
+            detail::arange_generator<fp_type, T>(fp_type(start), fp_type(stop), step, num_samples, endpoint),
+            {num_samples}
+        );
     }
 
     /**
@@ -401,80 +480,156 @@ namespace xt
     template <class T>
     inline auto logspace(T start, T stop, std::size_t num_samples, T base = 10, bool endpoint = true) noexcept
     {
-        return cast<T>(pow(std::move(base), linspace(start, stop, num_samples, endpoint)));
+        return pow(std::move(base), linspace(start, stop, num_samples, endpoint));
     }
 
     namespace detail
     {
         template <class... CT>
-        class concatenate_impl
+        class concatenate_access
         {
         public:
 
+            using tuple_type = std::tuple<CT...>;
             using size_type = std::size_t;
-            using value_type = promote_type_t<typename std::decay_t<CT>::value_type...>;
-
-            inline concatenate_impl(std::tuple<CT...>&& t, size_type axis)
-                : m_t(t), m_axis(axis)
-            {
-            }
-
-            template <class... Args>
-            inline value_type operator()(Args... args) const
-            {
-                // TODO: avoid memory allocation
-                return access_impl(xindex({static_cast<size_type>(args)...}));
-            }
+            using value_type = xtl::promote_type_t<typename std::decay_t<CT>::value_type...>;
 
             template <class It>
-            inline value_type element(It first, It last) const
+            inline value_type access(const tuple_type& t, size_type axis, It first, It last) const
             {
-                // TODO: avoid memory allocation
-                return access_impl(xindex(first, last));
-            }
-
-        private:
-
-            inline value_type access_impl(xindex idx) const
-            {
-                auto match = [this, &idx](auto& arr) {
-                    if (idx[this->m_axis] >= arr.shape()[this->m_axis])
+                // trim off extra indices if provided to match behavior of containers
+                auto dim_offset = std::distance(first, last) - std::get<0>(t).dimension();
+                std::size_t axis_dim = *(first + axis + dim_offset);
+                auto match = [&](auto& arr)
+                {
+                    if (axis_dim >= arr.shape()[axis])
                     {
-                        idx[this->m_axis] -= arr.shape()[this->m_axis];
+                        axis_dim -= arr.shape()[axis];
                         return false;
                     }
                     return true;
                 };
 
-                auto get = [&idx](auto& arr) {
-                    return arr[idx];
+                auto get = [&](auto& arr)
+                {
+                    std::size_t offset = 0;
+                    const std::size_t end = arr.dimension();
+                    for (std::size_t i = 0; i < end; i++)
+                    {
+                        const auto& shape = arr.shape();
+                        const std::size_t stride = std::accumulate(
+                            shape.begin() + i + 1,
+                            shape.end(),
+                            size_t(1),
+                            std::multiplies<std::size_t>()
+                        );
+                        if (i == axis)
+                        {
+                            offset += axis_dim * stride;
+                        }
+                        else
+                        {
+                            const auto len = (*(first + i + dim_offset));
+                            offset += len * stride;
+                        }
+                    }
+                    const auto element = arr.begin() + offset;
+                    return *element;
                 };
 
                 size_type i = 0;
                 for (; i < sizeof...(CT); ++i)
                 {
-                    if (apply<bool>(i, match, m_t))
+                    if (apply<bool>(i, match, t))
                     {
                         break;
                     }
                 }
-                return apply<value_type>(i, get, m_t);
+                return apply<value_type>(i, get, t);
             }
+        };
 
-            std::tuple<CT...> m_t;
-            size_type m_axis;
+        template <class... CT>
+        class stack_access
+        {
+        public:
+
+            using tuple_type = std::tuple<CT...>;
+            using size_type = std::size_t;
+            using value_type = xtl::promote_type_t<typename std::decay_t<CT>::value_type...>;
+
+            template <class It>
+            inline value_type access(const tuple_type& t, size_type axis, It first, It) const
+            {
+                auto get_item = [&](auto& arr)
+                {
+                    std::size_t offset = 0;
+                    const std::size_t end = arr.dimension();
+                    std::size_t after_axis = 0;
+                    for (std::size_t i = 0; i < end; i++)
+                    {
+                        if (i == axis)
+                        {
+                            after_axis = 1;
+                        }
+                        const auto& shape = arr.shape();
+                        const std::size_t stride = std::accumulate(
+                            shape.begin() + static_cast<std::ptrdiff_t>(i) + 1,
+                            shape.end(),
+                            std::size_t(1),
+                            std::multiplies<std::size_t>()
+                        );
+                        const auto len = (*(first + static_cast<std::ptrdiff_t>(i + after_axis)));
+                        offset += len * stride;
+                    }
+                    const auto element = arr.begin() + static_cast<std::ptrdiff_t>(offset);
+                    return *element;
+                };
+                size_type i = *(first + static_cast<std::ptrdiff_t>(axis));
+                return apply<value_type>(i, get_item, t);
+            }
         };
 
         template <class... CT>
-        class stack_impl
+        class vstack_access
         {
         public:
 
+            using tuple_type = std::tuple<CT...>;
             using size_type = std::size_t;
-            using value_type = promote_type_t<typename std::decay_t<CT>::value_type...>;
+            using value_type = xtl::promote_type_t<typename std::decay_t<CT>::value_type...>;
 
-            inline stack_impl(std::tuple<CT...>&& t, size_type axis)
-                : m_t(t), m_axis(axis)
+            template <class It>
+            inline value_type access(const tuple_type& t, size_type axis, It first, It last) const
+            {
+                if (std::get<0>(t).dimension() == 1)
+                {
+                    return stack.access(t, axis, first, last);
+                }
+                else
+                {
+                    return concatonate.access(t, axis, first, last);
+                }
+            }
+
+        private:
+
+            concatenate_access<CT...> concatonate;
+            stack_access<CT...> stack;
+        };
+
+        template <template <class...> class F, class... CT>
+        class concatenate_invoker
+        {
+        public:
+
+            using tuple_type = std::tuple<CT...>;
+            using size_type = std::size_t;
+            using value_type = xtl::promote_type_t<typename std::decay_t<CT>::value_type...>;
+
+            inline concatenate_invoker(tuple_type&& t, size_type axis)
+                : m_t(std::move(t))
+                , m_axis(axis)
             {
             }
 
@@ -482,32 +637,32 @@ namespace xt
             inline value_type operator()(Args... args) const
             {
                 // TODO: avoid memory allocation
-                return access_impl(xindex({static_cast<size_type>(args)...}));
+                xindex index({static_cast<size_type>(args)...});
+                return access_method.access(m_t, m_axis, index.begin(), index.end());
             }
 
             template <class It>
             inline value_type element(It first, It last) const
             {
-                // TODO: avoid memory allocation
-                return access_impl(xindex(first, last));
+                return access_method.access(m_t, m_axis, first, last);
             }
 
         private:
 
-            inline value_type access_impl(xindex idx) const
-            {
-                auto get_item = [&idx](auto& arr) {
-                    return arr[idx];
-                };
-                size_type i = idx[m_axis];
-                idx.erase(idx.begin() + std::ptrdiff_t(m_axis));
-                return apply<value_type>(i, get_item, m_t);
-            }
-
-            const std::tuple<CT...> m_t;
-            const size_type m_axis;
+            F<CT...> access_method;
+            tuple_type m_t;
+            size_type m_axis;
         };
 
+        template <class... CT>
+        using concatenate_impl = concatenate_invoker<concatenate_access, CT...>;
+
+        template <class... CT>
+        using stack_impl = concatenate_invoker<stack_access, CT...>;
+
+        template <class... CT>
+        using vstack_impl = concatenate_invoker<vstack_access, CT...>;
+
         template <class CT>
         class repeat_impl
         {
@@ -519,7 +674,8 @@ namespace xt
 
             template <class CTA>
             repeat_impl(CTA&& source, size_type axis)
-                : m_source(std::forward<CTA>(source)), m_axis(axis)
+                : m_source(std::forward<CTA>(source))
+                , m_axis(axis)
             {
             }
 
@@ -553,6 +709,108 @@ namespace xt
         return std::tuple<xtl::const_closure_type_t<Types>...>(std::forward<Types>(args)...);
     }
 
+    namespace detail
+    {
+        template <bool... values>
+        using all_true = std::conjunction<std::integral_constant<bool, values>...>;
+
+        template <class X, class Y, std::size_t axis, class AxesSequence>
+        struct concat_fixed_shape_impl;
+
+        template <class X, class Y, std::size_t axis, std::size_t... Is>
+        struct concat_fixed_shape_impl<X, Y, axis, std::index_sequence<Is...>>
+        {
+            static_assert(X::size() == Y::size(), "Concatenation requires equisized shapes");
+            static_assert(axis < X::size(), "Concatenation requires a valid axis");
+            static_assert(
+                all_true<(axis == Is || X::template get<Is>() == Y::template get<Is>())...>::value,
+                "Concatenation requires compatible shapes and axis"
+            );
+
+            using type = fixed_shape<
+                (axis == Is ? X::template get<Is>() + Y::template get<Is>() : X::template get<Is>())...>;
+        };
+
+        template <std::size_t axis, class X, class Y, class... Rest>
+        struct concat_fixed_shape;
+
+        template <std::size_t axis, class X, class Y>
+        struct concat_fixed_shape<axis, X, Y>
+        {
+            using type = typename concat_fixed_shape_impl<X, Y, axis, std::make_index_sequence<X::size()>>::type;
+        };
+
+        template <std::size_t axis, class X, class Y, class... Rest>
+        struct concat_fixed_shape
+        {
+            using type = typename concat_fixed_shape<axis, X, typename concat_fixed_shape<axis, Y, Rest...>::type>::type;
+        };
+
+        template <std::size_t axis, class... Args>
+        using concat_fixed_shape_t = typename concat_fixed_shape<axis, Args...>::type;
+
+        template <class... CT>
+        using all_fixed_shapes = detail::all_fixed<typename std::decay_t<CT>::shape_type...>;
+
+        struct concat_shape_builder_t
+        {
+            template <class Shape, bool = detail::is_fixed<Shape>::value>
+            struct concat_shape;
+
+            template <class Shape>
+            struct concat_shape<Shape, true>
+            {
+                // Convert `fixed_shape` to `static_shape` to allow runtime dimension calculation.
+                using type = static_shape<typename Shape::value_type, Shape::size()>;
+            };
+
+            template <class Shape>
+            struct concat_shape<Shape, false>
+            {
+                using type = Shape;
+            };
+
+            template <class... Args>
+            static auto build(const std::tuple<Args...>& t, std::size_t axis)
+            {
+                using shape_type = promote_shape_t<
+                    typename concat_shape<typename std::decay_t<Args>::shape_type>::type...>;
+                using source_shape_type = decltype(std::get<0>(t).shape());
+                shape_type new_shape = xtl::forward_sequence<shape_type, source_shape_type>(
+                    std::get<0>(t).shape()
+                );
+
+                auto check_shape = [&axis, &new_shape](auto& arr)
+                {
+                    std::size_t s = new_shape.size();
+                    bool res = s == arr.dimension();
+                    for (std::size_t i = 0; i < s; ++i)
+                    {
+                        res = res && (i == axis || new_shape[i] == arr.shape(i));
+                    }
+                    if (!res)
+                    {
+                        throw_concatenate_error(new_shape, arr.shape());
+                    }
+                };
+                for_each(check_shape, t);
+
+                auto shape_at_axis = [&axis](std::size_t prev, auto& arr) -> std::size_t
+                {
+                    return prev + arr.shape()[axis];
+                };
+                new_shape[axis] += accumulate(shape_at_axis, std::size_t(0), t) - new_shape[axis];
+
+                return new_shape;
+            }
+        };
+
+    }  // namespace detail
+
+    /***************
+     * concatenate *
+     ***************/
+
     /**
      * @brief Concatenates xexpressions along \em axis.
      *
@@ -560,24 +818,26 @@ namespace xt
      * @param axis axis along which elements are concatenated
      * @returns xgenerator evaluating to concatenated elements
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{1, 2, 3}};
      * xt::xarray<double> b = {{2, 3, 4}};
      * xt::xarray<double> c = xt::concatenate(xt::xtuple(a, b)); // => {{1, 2, 3},
-     *                                                                  {2, 3, 4}}
+     *                                                           //     {2, 3, 4}}
      * xt::xarray<double> d = xt::concatenate(xt::xtuple(a, b), 1); // => {{1, 2, 3, 2, 3, 4}}
-     * \endcode
+     * @endcode
      */
     template <class... CT>
     inline auto concatenate(std::tuple<CT...>&& t, std::size_t axis = 0)
     {
-        using shape_type = promote_shape_t<typename std::decay_t<CT>::shape_type...>;
-        shape_type new_shape = xtl::forward_sequence<shape_type>(std::get<0>(t).shape());
-        auto shape_at_axis = [&axis](std::size_t prev, auto& arr) -> std::size_t {
-            return prev + arr.shape()[axis];
-        };
-        new_shape[axis] += accumulate(shape_at_axis, std::size_t(0), t) - new_shape[axis];
-        return detail::make_xgenerator(detail::concatenate_impl<CT...>(std::forward<std::tuple<CT...>>(t), axis), new_shape);
+        const auto shape = detail::concat_shape_builder_t::build(t, axis);
+        return detail::make_xgenerator(detail::concatenate_impl<CT...>(std::move(t), axis), shape);
+    }
+
+    template <std::size_t axis, fixed_shape_container_concept... CT>
+    inline auto concatenate(std::tuple<CT...>&& t)
+    {
+        using shape_type = detail::concat_fixed_shape_t<axis, typename std::decay_t<CT>::shape_type...>;
+        return detail::make_xgenerator(detail::concatenate_impl<CT...>(std::move(t), axis), shape_type{});
     }
 
     namespace detail
@@ -609,22 +869,124 @@ namespace xt
      * @param axis axis along which elements are stacked
      * @returns xgenerator evaluating to stacked elements
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {1, 2, 3};
      * xt::xarray<double> b = {5, 6, 7};
      * xt::xarray<double> s = xt::stack(xt::xtuple(a, b)); // => {{1, 2, 3},
-     *                                                            {5, 6, 7}}
+     *                                                     //     {5, 6, 7}}
      * xt::xarray<double> t = xt::stack(xt::xtuple(a, b), 1); // => {{1, 5},
-     *                                                               {2, 6},
-     *                                                               {3, 7}}
-     * \endcode
+     *                                                        //     {2, 6},
+     *                                                        //     {3, 7}}
+     * @endcode
      */
     template <class... CT>
     inline auto stack(std::tuple<CT...>&& t, std::size_t axis = 0)
     {
         using shape_type = promote_shape_t<typename std::decay_t<CT>::shape_type...>;
-        auto new_shape = detail::add_axis(xtl::forward_sequence<shape_type>(std::get<0>(t).shape()), axis, sizeof...(CT));
-        return detail::make_xgenerator(detail::stack_impl<CT...>(std::forward<std::tuple<CT...>>(t), axis), new_shape);
+        using source_shape_type = decltype(std::get<0>(t).shape());
+        auto new_shape = detail::add_axis(
+            xtl::forward_sequence<shape_type, source_shape_type>(std::get<0>(t).shape()),
+            axis,
+            sizeof...(CT)
+        );
+        return detail::make_xgenerator(detail::stack_impl<CT...>(std::move(t), axis), new_shape);
+    }
+
+    /**
+     * @brief Stack xexpressions in sequence horizontally (column wise).
+     * This is equivalent to concatenation along the second axis, except for 1-D
+     * xexpressions where it concatenate along the first axis.
+     *
+     * @param t \ref xtuple of xexpressions to stack
+     * @return xgenerator evaluating to stacked elements
+     */
+    template <class... CT>
+    inline auto hstack(std::tuple<CT...>&& t)
+    {
+        auto dim = std::get<0>(t).dimension();
+        std::size_t axis = dim > std::size_t(1) ? 1 : 0;
+        return concatenate(std::move(t), axis);
+    }
+
+    namespace detail
+    {
+        template <class S>
+        struct vstack_fixed_shape_impl;
+
+        template <std::size_t N>
+        struct vstack_fixed_shape_impl<fixed_shape<N>>
+        {
+            using type = fixed_shape<1, N>;
+        };
+
+        template <std::size_t I, std::size_t... J>
+        struct vstack_fixed_shape_impl<fixed_shape<I, J...>>
+        {
+            using type = fixed_shape<I, J...>;
+        };
+
+        template <class... CT>
+        struct vstack_fixed_shape
+        {
+            using type = concat_fixed_shape_t<
+                0,
+                typename vstack_fixed_shape_impl<typename std::decay_t<CT>::shape_type>::type...>;
+        };
+
+        template <class... CT>
+        using vstack_fixed_shape_t = typename vstack_fixed_shape<CT...>::type;
+
+        template <class S, class... CT>
+        inline auto vstack_shape(std::tuple<CT...>& t, const S& shape)
+        {
+            using size_type = typename S::value_type;
+            auto res = shape.size() == size_type(1)
+                           ? S({sizeof...(CT), shape[0]})
+                           : concat_shape_builder_t::build(std::move(t), size_type(0));
+            return res;
+        }
+
+        template <class T, class... CT>
+        inline auto vstack_shape(const std::tuple<CT...>&, std::array<T, 1> shape)
+        {
+            std::array<T, 2> res = {sizeof...(CT), shape[0]};
+            return res;
+        }
+    }
+
+    /**
+     * @brief Stack xexpressions in sequence vertically (row wise).
+     * This is equivalent to concatenation along the first axis after
+     * 1-D arrays of shape (N) have been reshape to (1, N).
+     *
+     * @param t \ref xtuple of xexpressions to stack
+     * @return xgenerator evaluating to stacked elements
+     */
+    template <class... CT>
+    inline auto vstack(std::tuple<CT...>&& t)
+    {
+        using shape_type = promote_shape_t<typename std::decay_t<CT>::shape_type...>;
+        using source_shape_type = decltype(std::get<0>(t).shape());
+        auto new_shape = detail::vstack_shape(
+            t,
+            xtl::forward_sequence<shape_type, source_shape_type>(std::get<0>(t).shape())
+        );
+        return detail::make_xgenerator(detail::vstack_impl<CT...>(std::move(t), size_t(0)), new_shape);
+    }
+
+    /**
+     * @brief Stack fixed-shape xexpressions in sequence vertically (row wise).
+     * This overload preserves the result shape at compile time by treating
+     * 1-D fixed shapes as ``(1, N)`` row vectors before concatenation.
+     *
+     * @param t \ref xtuple of fixed-shape xexpressions to stack
+     * @return xgenerator evaluating to stacked elements with a fixed compile-time shape
+     */
+    template <fixed_shape_container_concept... CT>
+    inline auto vstack(std::tuple<CT...>&& t)
+    {
+        using shape_type = detail::vstack_fixed_shape_t<CT...>;
+        return detail::make_xgenerator(detail::vstack_impl<CT...>(std::move(t), size_t(0)), shape_type{});
     }
 
     namespace detail
@@ -633,22 +995,10 @@ namespace xt
         template <std::size_t... I, class... E>
         inline auto meshgrid_impl(std::index_sequence<I...>, E&&... e) noexcept
         {
-#if defined X_OLD_CLANG || defined _MSC_VER
-            const std::array<std::size_t, sizeof...(E)> shape = {e.shape()[0]...};
-            return std::make_tuple(
-                detail::make_xgenerator(
-                    detail::repeat_impl<xclosure_t<E>>(std::forward<E>(e), I),
-                    shape
-                )...
-            );
-#else
-            return std::make_tuple(
-                detail::make_xgenerator(
-                    detail::repeat_impl<xclosure_t<E>>(std::forward<E>(e), I),
-                    {e.shape()[0]...}
-                )...
-            );
-#endif
+            return std::make_tuple(detail::make_xgenerator(
+                detail::repeat_impl<xclosure_t<E>>(std::forward<E>(e), I),
+                {e.shape()[0]...}
+            )...);
         }
     }
 
@@ -678,7 +1028,10 @@ namespace xt
 
             template <class CTA>
             diagonal_fn(CTA&& source, int offset, std::size_t axis_1, std::size_t axis_2)
-                : m_source(std::forward<CTA>(source)), m_offset(offset), m_axis_1(axis_1), m_axis_2(axis_2)
+                : m_source(std::forward<CTA>(source))
+                , m_offset(offset)
+                , m_axis_1(axis_1)
+                , m_axis_2(axis_2)
             {
             }
 
@@ -691,20 +1044,20 @@ namespace xt
                 {
                     if (i != m_axis_1 && i != m_axis_2)
                     {
-                        idx[i] = *begin++;
+                        idx[i] = static_cast<std::size_t>(*begin++);
                     }
                 }
                 using it_vtype = typename std::iterator_traits<It>::value_type;
                 it_vtype uoffset = static_cast<it_vtype>(m_offset);
                 if (m_offset >= 0)
                 {
-                    idx[m_axis_1] = *(begin);
-                    idx[m_axis_2] = *(begin) + uoffset;
+                    idx[m_axis_1] = static_cast<std::size_t>(*(begin));
+                    idx[m_axis_2] = static_cast<std::size_t>(*(begin) + uoffset);
                 }
                 else
                 {
-                    idx[m_axis_1] = *(begin) - uoffset;
-                    idx[m_axis_2] = *(begin);
+                    idx[m_axis_1] = static_cast<std::size_t>(*(begin) -uoffset);
+                    idx[m_axis_2] = static_cast<std::size_t>(*(begin));
                 }
                 return m_source[idx];
             }
@@ -727,7 +1080,8 @@ namespace xt
 
             template <class CTA>
             diag_fn(CTA&& source, int k)
-                : m_source(std::forward<CTA>(source)), m_k(k)
+                : m_source(std::forward<CTA>(source))
+                , m_k(k)
             {
             }
 
@@ -763,7 +1117,9 @@ namespace xt
 
             template <class CTA>
             trilu_fn(CTA&& source, int k, Comp comp)
-                : m_source(std::forward<CTA>(source)), m_k(k), m_comp(comp)
+                : m_source(std::forward<CTA>(source))
+                , m_k(k)
+                , m_comp(comp)
             {
             }
 
@@ -771,7 +1127,9 @@ namespace xt
             inline value_type operator()(It begin, It end) const
             {
                 // have to cast to signed int otherwise -1 can lead to overflow
-                return m_comp(signed_idx_type(*begin) + m_k, signed_idx_type(*(begin + 1))) ? m_source.element(begin, end) : value_type(0);
+                return m_comp(signed_idx_type(*begin) + m_k, signed_idx_type(*(begin + 1)))
+                           ? m_source.element(begin, end)
+                           : value_type(0);
             }
 
         private:
@@ -815,12 +1173,12 @@ namespace xt
      *               from which the diagonals should be taken.
      * @returns xexpression with values of the diagonal
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{1, 2, 3},
      *                         {4, 5, 6}
      *                         {7, 8, 9}};
      * auto b = xt::diagonal(a); // => {1, 5, 9}
-     * \endcode
+     * @endcode
      */
     template <class E>
     inline auto diagonal(E&& arr, int offset = 0, std::size_t axis_1 = 0, std::size_t axis_2 = 1)
@@ -831,7 +1189,7 @@ namespace xt
         auto shape = arr.shape();
         auto dimension = arr.dimension();
 
-        // The following shape calculation code is an almost verbatim adaptation of numpy:
+        // The following shape calculation code is an almost verbatim adaptation of NumPy:
         // https://github.com/numpy/numpy/blob/2aabeafb97bea4e1bfa29d946fbf31e1104e7ae0/numpy/core/src/multiarray/item_selection.c#L1799
         auto ret_shape = xtl::make_sequence<shape_type>(dimension - 1, 0);
         int dim_1 = static_cast<int>(shape[axis_1]);
@@ -852,8 +1210,12 @@ namespace xt
 
         ret_shape.back() = diag_size;
 
-        return detail::make_xgenerator(detail::fn_impl<detail::diagonal_fn<CT>>(detail::diagonal_fn<CT>(std::forward<E>(arr), offset, axis_1, axis_2)),
-                                       ret_shape);
+        return detail::make_xgenerator(
+            detail::fn_impl<detail::diagonal_fn<CT>>(
+                detail::diagonal_fn<CT>(std::forward<E>(arr), offset, axis_1, axis_2)
+            ),
+            ret_shape
+        );
     }
 
     /**
@@ -863,12 +1225,12 @@ namespace xt
      * @param k the offset of the considered diagonal
      * @returns xexpression function with shape n x n and arr on the diagonal
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {1, 5, 9};
      * auto b = xt::diag(a); // => {{1, 0, 0},
      *                       //     {0, 5, 0},
      *                       //     {0, 0, 9}}
-     * \endcode
+     * @endcode
      */
     template <class E>
     inline auto diag(E&& arr, int k = 0)
@@ -876,8 +1238,10 @@ namespace xt
         using CT = xclosure_t<E>;
         std::size_t sk = std::size_t(std::abs(k));
         std::size_t s = arr.shape()[0] + sk;
-        return detail::make_xgenerator(detail::fn_impl<detail::diag_fn<CT>>(detail::diag_fn<CT>(std::forward<E>(arr), k)),
-                                       {s, s});
+        return detail::make_xgenerator(
+            detail::fn_impl<detail::diag_fn<CT>>(detail::diag_fn<CT>(std::forward<E>(arr), k)),
+            {s, s}
+        );
     }
 
     /**
@@ -894,9 +1258,16 @@ namespace xt
     {
         using CT = xclosure_t<E>;
         auto shape = arr.shape();
-        return detail::make_xgenerator(detail::fn_impl<detail::trilu_fn<CT, std::greater_equal<long int>>>(
-                                           detail::trilu_fn<CT, std::greater_equal<long int>>(std::forward<E>(arr), k, std::greater_equal<long int>())),
-                                       shape);
+        return detail::make_xgenerator(
+            detail::fn_impl<detail::trilu_fn<CT, std::greater_equal<long int>>>(
+                detail::trilu_fn<CT, std::greater_equal<long int>>(
+                    std::forward<E>(arr),
+                    k,
+                    std::greater_equal<long int>()
+                )
+            ),
+            shape
+        );
     }
 
     /**
@@ -913,9 +1284,12 @@ namespace xt
     {
         using CT = xclosure_t<E>;
         auto shape = arr.shape();
-        return detail::make_xgenerator(detail::fn_impl<detail::trilu_fn<CT, std::less_equal<long int>>>(
-                                           detail::trilu_fn<CT, std::less_equal<long int>>(std::forward<E>(arr), k, std::less_equal<long int>())),
-                                       shape);
+        return detail::make_xgenerator(
+            detail::fn_impl<detail::trilu_fn<CT, std::less_equal<long int>>>(
+                detail::trilu_fn<CT, std::less_equal<long int>>(std::forward<E>(arr), k, std::less_equal<long int>())
+            ),
+            shape
+        );
     }
 }
 #endif
diff --git a/include/xtensor/xgenerator.hpp b/include/xtensor/generators/xgenerator.hpp
similarity index 63%
rename from include/xtensor/xgenerator.hpp
rename to include/xtensor/generators/xgenerator.hpp
index 69eac5f75..c7dae5b05 100644
--- a/include/xtensor/xgenerator.hpp
+++ b/include/xtensor/generators/xgenerator.hpp
@@ -1,27 +1,28 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_GENERATOR_HPP
 #define XTENSOR_GENERATOR_HPP
 
 #include <algorithm>
 #include <cstddef>
-#include <numeric>
-#include <tuple>
 #include <type_traits>
 #include <utility>
 
 #include <xtl/xsequence.hpp>
 
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xstrides.hpp"
-#include "xutils.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xstrides.hpp"
+#include "../utils/xutils.hpp"
+#include "../views/xstrided_view.hpp"
 
 namespace xt
 {
@@ -57,6 +58,9 @@ namespace xt
     template <class F, class R, class S>
     class xgenerator;
 
+    template <typename T>
+    concept xgenerator_concept = is_specialization_of<xgenerator, std::decay_t<T>>::value;
+
     template <class C, class R, class S>
     struct xiterable_inner_types<xgenerator<C, R, S>>
     {
@@ -65,6 +69,28 @@ namespace xt
         using stepper = const_stepper;
     };
 
+    template <class C, class R, class S>
+    struct xcontainer_inner_types<xgenerator<C, R, S>>
+    {
+        using reference = R;
+        using const_reference = R;
+        using size_type = std::size_t;
+    };
+
+    /*************************************
+     * overlapping_memory_checker_traits *
+     *************************************/
+
+    template <xgenerator_concept E>
+        requires(!addressable_to_expression<std::decay_t<E>>)
+    struct overlapping_memory_checker_traits<E>
+    {
+        static bool check_overlap(const E&, const memory_range&)
+        {
+            return false;
+        }
+    };
+
     /**
      * @class xgenerator
      * @brief Multidimensional function operating on indices.
@@ -77,8 +103,9 @@ namespace xt
      * @tparam S the shape type of the generator
      */
     template <class F, class R, class S>
-    class xgenerator : public xexpression<xgenerator<F, R, S>>,
+    class xgenerator : public xsharable_expression<xgenerator<F, R, S>>,
                        public xconst_iterable<xgenerator<F, R, S>>,
+                       public xconst_accessible<xgenerator<F, R, S>>,
                        public extension::xgenerator_base_t<F, R, S>
     {
     public:
@@ -86,15 +113,17 @@ namespace xt
         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 = value_type;
-        using const_reference = 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 = std::size_t;
+        using size_type = typename inner_types::size_type;
         using difference_type = std::ptrdiff_t;
 
         using iterable_base = xconst_iterable<self_type>;
@@ -104,28 +133,23 @@ namespace xt
         using stepper = typename iterable_base::stepper;
         using const_stepper = typename iterable_base::const_stepper;
 
+        using bool_load_type = xt::bool_load_type<R>;
+
         static constexpr layout_type static_layout = layout_type::dynamic;
         static constexpr bool contiguous_layout = false;
 
         template <class Func>
         xgenerator(Func&& f, const S& shape) noexcept;
 
-        size_type size() const noexcept;
-        size_type dimension() const noexcept;
         const inner_shape_type& shape() const noexcept;
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+        using accessible_base::shape;
 
         template <class... Args>
         const_reference operator()(Args... args) const;
         template <class... Args>
-        const_reference at(Args... args) const;
-        template <class... Args>
         const_reference unchecked(Args... args) const;
-        template <class OS>
-        disable_integral_t<OS, const_reference> operator[](const OS& index) const;
-        template <class I>
-        const_reference operator[](std::initializer_list<I> index) const;
-        const_reference operator[](size_type i) const;
 
         template <class It>
         const_reference element(It first, It last) const;
@@ -141,8 +165,9 @@ namespace xt
         template <class O>
         const_stepper stepper_end(const O& shape, layout_type) const noexcept;
 
-        template <class E, class FE = F, class = std::enable_if_t<has_assign_to<E, FE>::value>>
-        void assign_to(xexpression<E>& e) const noexcept;
+        template <class E, class FE = F>
+        void assign_to(xexpression<E>& e) const noexcept
+            requires(assignable_to_expression<E, FE>);
 
         const functor_type& functor() const noexcept;
 
@@ -152,8 +177,29 @@ namespace xt
         template <class OR, class OF>
         rebind_t<OR, OF> build_generator(OF&& func) const;
 
+        template <class O = xt::dynamic_shape<typename shape_type::value_type>>
+        auto reshape(O&& shape) const&;
+
+        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) &&;
+
     private:
 
+        template <class O>
+        decltype(auto) compute_shape(O&& shape, std::false_type /*signed*/) const;
+
+        template <class O>
+        auto compute_shape(O&& shape, std::true_type /*signed*/) const;
+
+        template <class T>
+        auto compute_shape(std::initializer_list<T> shape) const;
+
         template <std::size_t dim>
         void adapt_index() const;
 
@@ -173,7 +219,7 @@ namespace xt
      */
     //@{
     /**
-     * Constructs an xgenerator applying the specified function over the 
+     * Constructs an xgenerator applying the specified function over the
      * given shape.
      * @param f the function to apply
      * @param shape the shape of the xgenerator
@@ -181,33 +227,17 @@ namespace xt
     template <class F, class R, class S>
     template <class Func>
     inline xgenerator<F, R, S>::xgenerator(Func&& f, const S& shape) noexcept
-        : m_f(std::forward<Func>(f)), m_shape(shape)
+        : m_f(std::forward<Func>(f))
+        , m_shape(shape)
     {
     }
+
     //@}
 
     /**
      * @name Size and shape
      */
     //@{
-    /**
-     * Returns the size of the expression.
-     */
-    template <class F, class R, class S>
-    inline auto xgenerator<F, R, S>::size() const noexcept -> size_type
-    {
-        return compute_size(shape());
-    }
-
-    /**
-     * Returns the number of dimensions of the function.
-     */
-    template <class F, class R, class S>
-    inline auto xgenerator<F, R, S>::dimension() const noexcept -> size_type
-    {
-        return m_shape.size();
-    }
-
     /**
      * Returns the shape of the xgenerator.
      */
@@ -223,11 +253,18 @@ namespace xt
         return static_layout;
     }
 
+    template <class F, class R, class S>
+    inline bool xgenerator<F, R, S>::is_contiguous() const noexcept
+    {
+        return false;
+    }
+
     //@}
 
     /**
      * @name Data
      */
+
     /**
      * Returns the evaluated element at the specified position in the function.
      * @param args a list of indices specifying the position in the function. Indices
@@ -243,23 +280,6 @@ namespace xt
         return m_f(args...);
     }
 
-    /**
-     * Returns a constant reference to the element at the specified position in the expression,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class F, class R, class S>
-    template <class... Args>
-    inline auto xgenerator<F, R, S>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), args...);
-        return this->operator()(args...);
-    }
-
     /**
      * Returns a constant reference to the element at the specified position in the expression.
      * @param args a list of indices specifying the position in the expression. Indices
@@ -268,16 +288,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      *  code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class F, class R, class S>
     template <class... Args>
@@ -286,28 +306,6 @@ namespace xt
         return m_f(args...);
     }
 
-    template <class F, class R, class S>
-    template <class OS>
-    inline auto xgenerator<F, R, S>::operator[](const OS& index) const
-        -> disable_integral_t<OS, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class F, class R, class S>
-    template <class I>
-    inline auto xgenerator<F, R, S>::operator[](std::initializer_list<I> index) const
-        -> const_reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class F, class R, class S>
-    inline auto xgenerator<F, R, S>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
-    }
-
     /**
      * Returns a constant reference to the element at the specified position in the function.
      * @param first iterator starting the sequence of indices
@@ -323,6 +321,7 @@ namespace xt
         XTENSOR_TRY(check_element_index(shape(), first, last));
         return m_f.element(bounded_iterator(first, shape().cbegin()), bounded_iterator(last, shape().cend()));
     }
+
     //@}
 
     /**
@@ -353,13 +352,14 @@ namespace xt
     {
         return false;
     }
+
     //@}
 
     template <class F, class R, class S>
     template <class O>
     inline auto xgenerator<F, R, S>::stepper_begin(const O& shape) const noexcept -> const_stepper
     {
-        size_type offset = shape.size() - dimension();
+        size_type offset = shape.size() - this->dimension();
         return const_stepper(this, offset);
     }
 
@@ -367,13 +367,14 @@ namespace xt
     template <class O>
     inline auto xgenerator<F, R, S>::stepper_end(const O& shape, layout_type) const noexcept -> const_stepper
     {
-        size_type offset = shape.size() - dimension();
+        size_type offset = shape.size() - this->dimension();
         return const_stepper(this, offset, true);
     }
 
     template <class F, class R, class S>
-    template <class E, class, class>
+    template <class E, class FE>
     inline void xgenerator<F, R, S>::assign_to(xexpression<E>& e) const noexcept
+        requires(assignable_to_expression<E, FE>)
     {
         e.derived_cast().resize(m_shape);
         m_f.assign_to(e);
@@ -392,6 +393,96 @@ namespace xt
         return rebind_t<OR, OF>(std::move(func), shape_type(m_shape));
     }
 
+    /**
+     * 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`.
+     * @code{.cpp}
+     * auto a = xt::arange<double>(50).reshape({-1, 10});
+     * //a.shape() is {5, 10}
+     * @endcode
+     * @param shape the new shape (has to have same number of elements as the original generator)
+     */
+    template <class F, class R, class S>
+    template <class O>
+    inline auto xgenerator<F, R, S>::reshape(O&& shape) const&
+    {
+        return reshape_view(*this, compute_shape(shape, xtl::is_signed<typename std::decay_t<O>::value_type>()));
+    }
+
+    template <class F, class R, class S>
+    template <class O>
+    inline auto xgenerator<F, R, S>::reshape(O&& shape) &&
+    {
+        return reshape_view(
+            std::move(*this),
+            compute_shape(shape, xtl::is_signed<typename std::decay_t<O>::value_type>())
+        );
+    }
+
+    template <class F, class R, class S>
+    template <class T>
+    inline auto xgenerator<F, R, S>::reshape(std::initializer_list<T> shape) const&
+    {
+        return reshape_view(*this, compute_shape(shape));
+    }
+
+    template <class F, class R, class S>
+    template <class T>
+    inline auto xgenerator<F, R, S>::reshape(std::initializer_list<T> shape) &&
+    {
+        return reshape_view(std::move(*this), compute_shape(shape));
+    }
+
+    template <class F, class R, class S>
+    template <class O>
+    inline decltype(auto) xgenerator<F, R, S>::compute_shape(O&& shape, std::false_type) const
+    {
+        return xtl::forward_sequence<xt::dynamic_shape<typename shape_type::value_type>, O>(shape);
+    }
+
+    template <class F, class R, class S>
+    template <class O>
+    inline auto xgenerator<F, R, S>::compute_shape(O&& shape, std::true_type) const
+    {
+        using vtype = typename shape_type::value_type;
+        xt::dynamic_shape<vtype> sh(shape.size());
+        using int_type = typename std::decay_t<O>::value_type;
+        int_type accumulator(1);
+        std::size_t neg_idx = 0;
+        std::size_t i = 0;
+        for (std::size_t j = 0; j != shape.size(); ++j, ++i)
+        {
+            auto dim = shape[j];
+            if (dim < 0)
+            {
+                XTENSOR_ASSERT(dim == -1 && !neg_idx);
+                neg_idx = i;
+            }
+            else
+            {
+                sh[j] = static_cast<vtype>(dim);
+            }
+            accumulator *= dim;
+        }
+        if (accumulator < 0)
+        {
+            sh[neg_idx] = this->size()
+                          / static_cast<size_type>(std::make_unsigned_t<int_type>(std::abs(accumulator)));
+        }
+        return sh;
+    }
+
+    template <class F, class R, class S>
+    template <class T>
+    inline auto xgenerator<F, R, S>::compute_shape(std::initializer_list<T> shape) const
+    {
+        using sh_type = xt::dynamic_shape<T>;
+        sh_type sh = xtl::make_sequence<sh_type>(shape.size());
+        std::copy(shape.begin(), shape.end(), sh.begin());
+        return compute_shape(std::move(sh), xtl::is_signed<T>());
+    }
+
     template <class F, class R, class S>
     template <std::size_t dim>
     inline void xgenerator<F, R, S>::adapt_index() const
@@ -402,14 +493,14 @@ namespace xt
     template <std::size_t dim, class I, class... Args>
     inline void xgenerator<F, R, S>::adapt_index(I& arg, Args&... args) const
     {
-        using value_type = typename decltype(m_shape)::value_type;
+        using tmp_value_type = typename decltype(m_shape)::value_type;
         if (sizeof...(Args) + 1 > m_shape.size())
         {
             adapt_index<dim>(args...);
         }
         else
         {
-            if (static_cast<value_type>(arg) >= m_shape[dim] && m_shape[dim] == 1)
+            if (static_cast<tmp_value_type>(arg) >= m_shape[dim] && m_shape[dim] == 1)
             {
                 arg = 0;
             }
@@ -419,23 +510,13 @@ namespace xt
 
     namespace detail
     {
-#ifdef X_OLD_CLANG
-        template <class Functor, class I>
-        inline auto make_xgenerator(Functor&& f, std::initializer_list<I> shape) noexcept
-        {
-            using shape_type = std::vector<std::size_t>;
-            using type = xgenerator<Functor, typename Functor::value_type, shape_type>;
-            return type(std::forward<Functor>(f), xtl::forward_sequence<shape_type>(shape));
-        }
-#else
         template <class Functor, class I, std::size_t L>
         inline auto make_xgenerator(Functor&& f, const I (&shape)[L]) noexcept
         {
             using shape_type = std::array<std::size_t, L>;
             using type = xgenerator<Functor, typename Functor::value_type, shape_type>;
-            return type(std::forward<Functor>(f), xtl::forward_sequence<shape_type>(shape));
+            return type(std::forward<Functor>(f), xtl::forward_sequence<shape_type, decltype(shape)>(shape));
         }
-#endif
 
         template <class Functor, class S>
         inline auto make_xgenerator(Functor&& f, S&& shape) noexcept
diff --git a/include/xtensor/generators/xrandom.hpp b/include/xtensor/generators/xrandom.hpp
new file mode 100644
index 000000000..73b1763ae
--- /dev/null
+++ b/include/xtensor/generators/xrandom.hpp
@@ -0,0 +1,1007 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+/**
+ * @brief functions to obtain xgenerators generating random numbers with given shape
+ */
+
+#ifndef XTENSOR_RANDOM_HPP
+#define XTENSOR_RANDOM_HPP
+
+#include <algorithm>
+#include <functional>
+#include <random>
+#include <type_traits>
+#include <utility>
+
+#include <xtl/xspan.hpp>
+
+#include "../containers/xtensor.hpp"
+#include "../core/xmath.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../generators/xbuilder.hpp"
+#include "../generators/xgenerator.hpp"
+#include "../misc/xtl_concepts.hpp"
+#include "../views/xindex_view.hpp"
+#include "../views/xview.hpp"
+
+namespace xt
+{
+    /*********************
+     * Random generators *
+     *********************/
+
+    namespace random
+    {
+        using default_engine_type = std::mt19937;
+        using seed_type = default_engine_type::result_type;
+
+        default_engine_type& get_default_random_engine();
+        void seed(seed_type seed);
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto rand(const S& shape, T lower = 0, T upper = 1, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto randint(
+            const S& shape,
+            T lower = 0,
+            T upper = (std::numeric_limits<T>::max)(),
+            E& engine = random::get_default_random_engine()
+        );
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto randn(const S& shape, T mean = 0, T std_dev = 1, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class D = double, class E = random::default_engine_type>
+        auto
+        binomial(const S& shape, T trials = 1, D prob = 0.5, E& engine = random::get_default_random_engine());
+
+        template <class T = int, class S, class D = double, class E = random::default_engine_type>
+        auto geometric(const S& shape, D prob = 0.5, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class D = double, class E = random::default_engine_type>
+        auto
+        negative_binomial(const S& shape, T k = 1, D prob = 0.5, E& engine = random::get_default_random_engine());
+
+        template <class T = int, class S, class D = double, class E = random::default_engine_type>
+        auto poisson(const S& shape, D rate = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto exponential(const S& shape, T rate = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto
+        gamma(const S& shape, T alpha = 1.0, T beta = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto weibull(const S& shape, T a = 1.0, T b = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto
+        extreme_value(const S& shape, T a = 0.0, T b = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto
+        lognormal(const S& shape, T mean = 0, T std_dev = 1, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto chi_squared(const S& shape, T deg = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto cauchy(const S& shape, T a = 0.0, T b = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto fisher_f(const S& shape, T m = 1.0, T n = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class S, class E = random::default_engine_type>
+        auto student_t(const S& shape, T n = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto
+        rand(const I (&shape)[L], T lower = 0, T upper = 1, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto randint(
+            const I (&shape)[L],
+            T lower = 0,
+            T upper = (std::numeric_limits<T>::max)(),
+            E& engine = random::get_default_random_engine()
+        );
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto
+        randn(const I (&shape)[L], T mean = 0, T std_dev = 1, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class D = double, class E = random::default_engine_type>
+        auto
+        binomial(const I (&shape)[L], T trials = 1, D prob = 0.5, E& engine = random::get_default_random_engine());
+
+        template <class T = int, class I, std::size_t L, class D = double, class E = random::default_engine_type>
+        auto geometric(const I (&shape)[L], D prob = 0.5, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class D = double, class E = random::default_engine_type>
+        auto negative_binomial(
+            const I (&shape)[L],
+            T k = 1,
+            D prob = 0.5,
+            E& engine = random::get_default_random_engine()
+        );
+
+        template <class T = int, class I, std::size_t L, class D = double, class E = random::default_engine_type>
+        auto poisson(const I (&shape)[L], D rate = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto exponential(const I (&shape)[L], T rate = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto
+        gamma(const I (&shape)[L], T alpha = 1.0, T beta = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto
+        weibull(const I (&shape)[L], T a = 1.0, T b = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto
+        extreme_value(const I (&shape)[L], T a = 0.0, T b = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto lognormal(
+            const I (&shape)[L],
+            T mean = 0.0,
+            T std_dev = 1.0,
+            E& engine = random::get_default_random_engine()
+        );
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto chi_squared(const I (&shape)[L], T deg = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto cauchy(const I (&shape)[L], T a = 0.0, T b = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto
+        fisher_f(const I (&shape)[L], T m = 1.0, T n = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class I, std::size_t L, class E = random::default_engine_type>
+        auto student_t(const I (&shape)[L], T n = 1.0, E& engine = random::get_default_random_engine());
+
+        template <class T, class E = random::default_engine_type>
+        void shuffle(xexpression<T>& e, E& engine = random::get_default_random_engine());
+
+        template <xtl::integral_concept T, class E = random::default_engine_type>
+        xtensor<T, 1> permutation(T e, E& engine = random::get_default_random_engine());
+
+        template <xexpression_concept T, class E = random::default_engine_type>
+        std::decay_t<T> permutation(T&& e, E& engine = random::get_default_random_engine());
+
+        template <class T, class E = random::default_engine_type>
+        xtensor<typename T::value_type, 1> choice(
+            const xexpression<T>& e,
+            std::size_t n,
+            bool replace = true,
+            E& engine = random::get_default_random_engine()
+        );
+
+        template <class T, class W, class E = random::default_engine_type>
+        xtensor<typename T::value_type, 1> choice(
+            const xexpression<T>& e,
+            std::size_t n,
+            const xexpression<W>& weights,
+            bool replace = true,
+            E& engine = random::get_default_random_engine()
+        );
+    }
+
+    namespace detail
+    {
+        template <class T, class E, class D>
+        struct random_impl
+        {
+            using value_type = T;
+
+            random_impl(E& engine, D&& dist)
+                : m_engine(engine)
+                , m_dist(std::move(dist))
+            {
+            }
+
+            template <class... Args>
+            inline value_type operator()(Args...) const
+            {
+                return m_dist(m_engine);
+            }
+
+            template <class It>
+            inline value_type element(It, It) const
+            {
+                return m_dist(m_engine);
+            }
+
+            template <class EX>
+            inline void assign_to(xexpression<EX>& e) const noexcept
+            {
+                // Note: we're not going row/col major here
+                auto& ed = e.derived_cast();
+                for (auto&& el : ed.storage())
+                {
+                    el = m_dist(m_engine);
+                }
+            }
+
+        private:
+
+            E& m_engine;
+            mutable D m_dist;
+        };
+    }
+
+    namespace random
+    {
+        /**
+         * Returns a reference to the default random number engine
+         */
+        inline default_engine_type& get_default_random_engine()
+        {
+            static default_engine_type mt;
+            return mt;
+        }
+
+        /**
+         * Seeds the default random number generator with @p seed
+         * @param seed The seed
+         */
+        inline void seed(seed_type seed)
+        {
+            get_default_random_engine().seed(seed);
+        }
+
+        /**
+         * xexpression with specified @p shape containing uniformly distributed random numbers
+         * in the interval from @p lower to @p upper, excluding upper.
+         *
+         * Numbers are drawn from @c std::uniform_real_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param lower lower bound
+         * @param upper upper bound
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto rand(const S& shape, T lower, T upper, E& engine)
+        {
+            std::uniform_real_distribution<T> dist(lower, upper);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing uniformly distributed
+         * random integers in the interval from @p lower to @p upper, excluding upper.
+         *
+         * Numbers are drawn from @c std::uniform_int_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param lower lower bound
+         * @param upper upper bound
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto randint(const S& shape, T lower, T upper, E& engine)
+        {
+            std::uniform_int_distribution<T> dist(lower, T(upper - 1));
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * the Normal (Gaussian) random number distribution with mean @p mean and
+         * standard deviation @p std_dev.
+         *
+         * Numbers are drawn from @c std::normal_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param mean mean of normal distribution
+         * @param std_dev standard deviation of normal distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto randn(const S& shape, T mean, T std_dev, E& engine)
+        {
+            std::normal_distribution<T> dist(mean, std_dev);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * the binomial random number distribution for @p trials trials with
+         * probability of success equal to @p prob.
+         *
+         * Numbers are drawn from @c std::binomial_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param trials number of Bernoulli trials
+         * @param prob probability of success of each trial
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class D, class E>
+        inline auto binomial(const S& shape, T trials, D prob, E& engine)
+        {
+            std::binomial_distribution<T> dist(trials, prob);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a gemoetric random number distribution with
+         * probability of success equal to @p prob for each of the Bernoulli trials.
+         *
+         * Numbers are drawn from @c std::geometric_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param prob probability of success of each trial
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class D, class E>
+        inline auto geometric(const S& shape, D prob, E& engine)
+        {
+            std::geometric_distribution<T> dist(prob);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a negative binomial random number distribution (also known as Pascal distribution)
+         * that returns the number of successes before @p k trials with probability of success
+         * equal to @p prob for each of the Bernoulli trials.
+         *
+         * Numbers are drawn from @c std::negative_binomial_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param k number of unsuccessful trials
+         * @param prob probability of success of each trial
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class D, class E>
+        inline auto negative_binomial(const S& shape, T k, D prob, E& engine)
+        {
+            std::negative_binomial_distribution<T> dist(k, prob);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a Poisson random number distribution with rate @p rate
+         *
+         * Numbers are drawn from @c std::poisson_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param rate rate of Poisson distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class D, class E>
+        inline auto poisson(const S& shape, D rate, E& engine)
+        {
+            std::poisson_distribution<T> dist(rate);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a exponential random number distribution with rate @p rate
+         *
+         * Numbers are drawn from @c std::exponential_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param rate rate of exponential distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto exponential(const S& shape, T rate, E& engine)
+        {
+            std::exponential_distribution<T> dist(rate);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a gamma random number distribution with shape @p alpha and scale @p beta
+         *
+         * Numbers are drawn from @c std::gamma_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param alpha shape of the gamma distribution
+         * @param beta scale of the gamma distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto gamma(const S& shape, T alpha, T beta, E& engine)
+        {
+            std::gamma_distribution<T> dist(alpha, beta);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a Weibull random number distribution with shape @p a and scale @p b
+         *
+         * Numbers are drawn from @c std::weibull_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param a shape of the weibull distribution
+         * @param b scale of the weibull distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto weibull(const S& shape, T a, T b, E& engine)
+        {
+            std::weibull_distribution<T> dist(a, b);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a extreme value random number distribution with shape @p a and scale @p b
+         *
+         * Numbers are drawn from @c std::extreme_value_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param a shape of the extreme value distribution
+         * @param b scale of the extreme value distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto extreme_value(const S& shape, T a, T b, E& engine)
+        {
+            std::extreme_value_distribution<T> dist(a, b);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * the Log-Normal random number distribution with mean @p mean and
+         * standard deviation @p std_dev.
+         *
+         * Numbers are drawn from @c std::lognormal_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param mean mean of normal distribution
+         * @param std_dev standard deviation of normal distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto lognormal(const S& shape, T mean, T std_dev, E& engine)
+        {
+            std::lognormal_distribution<T> dist(mean, std_dev);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * the chi-squared random number distribution with @p deg degrees of freedom.
+         *
+         * Numbers are drawn from @c std::chi_squared_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param deg degrees of freedom
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto chi_squared(const S& shape, T deg, E& engine)
+        {
+            std::chi_squared_distribution<T> dist(deg);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a Cauchy random number distribution with peak @p a and scale @p b
+         *
+         * Numbers are drawn from @c std::cauchy_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param a peak of the Cauchy distribution
+         * @param b scale of the Cauchy distribution
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto cauchy(const S& shape, T a, T b, E& engine)
+        {
+            std::cauchy_distribution<T> dist(a, b);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a Fisher-f random number distribution with numerator degrees of
+         * freedom equal to @p m and denominator degrees of freedom equal to @p n
+         *
+         * Numbers are drawn from @c std::fisher_f_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param m numerator degrees of freedom
+         * @param n denominator degrees of freedom
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto fisher_f(const S& shape, T m, T n, E& engine)
+        {
+            std::fisher_f_distribution<T> dist(m, n);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * xexpression with specified @p shape containing numbers sampled from
+         * a Student-t random number distribution with degrees of
+         * freedom equal to @p n
+         *
+         * Numbers are drawn from @c std::student_t_distribution.
+         *
+         * @param shape shape of resulting xexpression
+         * @param n degrees of freedom
+         * @param engine random number engine
+         * @tparam T number type to use
+         */
+        template <class T, class S, class E>
+        inline auto student_t(const S& shape, T n, E& engine)
+        {
+            std::student_t_distribution<T> dist(n);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto rand(const I (&shape)[L], T lower, T upper, E& engine)
+        {
+            std::uniform_real_distribution<T> dist(lower, upper);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto randint(const I (&shape)[L], T lower, T upper, E& engine)
+        {
+            std::uniform_int_distribution<T> dist(lower, T(upper - 1));
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto randn(const I (&shape)[L], T mean, T std_dev, E& engine)
+        {
+            std::normal_distribution<T> dist(mean, std_dev);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class D, class E>
+        inline auto binomial(const I (&shape)[L], T trials, D prob, E& engine)
+        {
+            std::binomial_distribution<T> dist(trials, prob);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class D, class E>
+        inline auto geometric(const I (&shape)[L], D prob, E& engine)
+        {
+            std::geometric_distribution<T> dist(prob);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class D, class E>
+        inline auto negative_binomial(const I (&shape)[L], T k, D prob, E& engine)
+        {
+            std::negative_binomial_distribution<T> dist(k, prob);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class D, class E>
+        inline auto poisson(const I (&shape)[L], D rate, E& engine)
+        {
+            std::poisson_distribution<T> dist(rate);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto exponential(const I (&shape)[L], T rate, E& engine)
+        {
+            std::exponential_distribution<T> dist(rate);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto gamma(const I (&shape)[L], T alpha, T beta, E& engine)
+        {
+            std::gamma_distribution<T> dist(alpha, beta);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto weibull(const I (&shape)[L], T a, T b, E& engine)
+        {
+            std::weibull_distribution<T> dist(a, b);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto extreme_value(const I (&shape)[L], T a, T b, E& engine)
+        {
+            std::extreme_value_distribution<T> dist(a, b);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto lognormal(const I (&shape)[L], T mean, T std_dev, E& engine)
+        {
+            std::lognormal_distribution<T> dist(mean, std_dev);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto chi_squared(const I (&shape)[L], T deg, E& engine)
+        {
+            std::chi_squared_distribution<T> dist(deg);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto cauchy(const I (&shape)[L], T a, T b, E& engine)
+        {
+            std::cauchy_distribution<T> dist(a, b);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto fisher_f(const I (&shape)[L], T m, T n, E& engine)
+        {
+            std::fisher_f_distribution<T> dist(m, n);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        template <class T, class I, std::size_t L, class E>
+        inline auto student_t(const I (&shape)[L], T n, E& engine)
+        {
+            std::student_t_distribution<T> dist(n);
+            return detail::make_xgenerator(
+                detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)),
+                shape
+            );
+        }
+
+        /**
+         * Randomly shuffle elements inplace in xcontainer along first axis.
+         * The order of sub-arrays is changed but their contents remain the same.
+         *
+         * @param e xcontainer to shuffle inplace
+         * @param engine random number engine
+         */
+        template <class T, class E>
+        void shuffle(xexpression<T>& e, E& engine)
+        {
+            T& de = e.derived_cast();
+
+            if (de.dimension() == 1)
+            {
+                using size_type = typename T::size_type;
+                auto first = de.begin();
+                auto last = de.end();
+
+                for (size_type i = std::size_t((last - first) - 1); i > 0; --i)
+                {
+                    std::uniform_int_distribution<size_type> dist(0, i);
+                    auto j = dist(engine);
+                    using std::swap;
+                    swap(first[i], first[j]);
+                }
+            }
+            else
+            {
+                using size_type = typename T::size_type;
+                decltype(auto) buf = empty_like(view(de, 0));
+
+                for (size_type i = de.shape()[0] - 1; i > 0; --i)
+                {
+                    std::uniform_int_distribution<size_type> dist(0, i);
+                    size_type j = dist(engine);
+
+                    buf = view(de, j);
+                    view(de, j) = view(de, i);
+                    view(de, i) = buf;
+                }
+            }
+        }
+
+        /**
+         * Randomly permute a sequence, or return a permuted range.
+         *
+         * If the first parameter is an integer, this function creates a new
+         * ``arange(e)`` and returns it randomly permuted. Otherwise, this
+         * function creates a copy of the input, passes it to @sa shuffle and
+         * returns the result.
+         *
+         * @param e input xexpression or integer
+         * @param engine random number engine to use (optional)
+         *
+         * @return randomly permuted copy of container or arange.
+         */
+        template <xtl::integral_concept T, class E>
+        xtensor<T, 1> permutation(T e, E& engine)
+        {
+            xt::xtensor<T, 1> res = xt::arange<T>(e);
+            shuffle(res, engine);
+            return res;
+        }
+
+        /// @cond DOXYGEN_INCLUDE_SFINAE
+        template <xexpression_concept T, class E>
+        std::decay_t<T> permutation(T&& e, E& engine)
+        {
+            using copy_type = std::decay_t<T>;
+            copy_type res = e;
+            shuffle(res, engine);
+            return res;
+        }
+
+        /// @endcond
+
+        /**
+         * Randomly select n unique elements from xexpression e.
+         * Note: this function makes a copy of your data, and only 1D data is accepted.
+         *
+         * @param e expression to sample from
+         * @param n number of elements to sample
+         * @param replace whether to sample with or without replacement
+         * @param engine random number engine
+         *
+         * @return xtensor containing 1D container of sampled elements
+         */
+        template <class T, class E>
+        xtensor<typename T::value_type, 1>
+        choice(const xexpression<T>& e, std::size_t n, bool replace, E& engine)
+        {
+            const auto& de = e.derived_cast();
+            XTENSOR_ASSERT((de.dimension() == 1));
+            XTENSOR_ASSERT((replace || n <= de.size()));
+            using result_type = xtensor<typename T::value_type, 1>;
+            using size_type = typename result_type::size_type;
+            result_type result;
+            result.resize({n});
+
+            if (replace)
+            {
+                auto dist = std::uniform_int_distribution<size_type>(0, de.size() - 1);
+                for (size_type i = 0; i < n; ++i)
+                {
+                    result[i] = de.storage()[dist(engine)];
+                }
+            }
+            else
+            {
+                // Naive resevoir sampling without weighting:
+                std::copy(de.storage().begin(), de.storage().begin() + n, result.begin());
+                size_type i = n;
+                for (auto it = de.storage().begin() + n; it != de.storage().end(); ++it, ++i)
+                {
+                    auto idx = std::uniform_int_distribution<size_type>(0, i)(engine);
+                    if (idx < n)
+                    {
+                        result.storage()[idx] = *it;
+                    }
+                }
+            }
+            return result;
+        }
+
+        /**
+         * Weighted random sampling.
+         *
+         * Randomly sample n unique elements from xexpression ``e`` using the discrete distribution
+         * parametrized by the weights ``w``. When sampling with replacement, this means that the probability
+         * to sample element ``e[i]`` is defined as
+         * ``w[i] / sum(w)``.
+         * Without replacement, this only describes the probability of the first sample element.
+         * In successive samples, the weight of items already sampled is assumed to be zero.
+         *
+         * For weighted random sampling with replacement, binary search with cumulative weights alogrithm is
+         * used. For weighted random sampling without replacement, the algorithm used is the exponential sort
+         * from [Efraimidis and Spirakis](https://linkinghub.elsevier.com/retrieve/pii/S002001900500298X)
+         * (2006) with the ``weight / randexp(1)``
+         * [trick](https://web.archive.org/web/20201021162211/https://krlmlr.github.io/wrswoR/) from Kirill
+         * Müller.
+         *
+         * Note: this function makes a copy of your data, and only 1D data is accepted.
+         *
+         * @param e expression to sample from
+         * @param n number of elements to sample
+         * @param weights expression for the weight distribution.
+         *          Weights must be positive and real-valued but need not sum to 1.
+         * @param replace set true to sample with replacement
+         * @param engine random number engine
+         *
+         * @return xtensor containing 1D container of sampled elements
+         */
+        template <class T, class W, class E>
+        xtensor<typename T::value_type, 1>
+        choice(const xexpression<T>& e, std::size_t n, const xexpression<W>& weights, bool replace, E& engine)
+        {
+            const auto& de = e.derived_cast();
+            const auto& dweights = weights.derived_cast();
+            XTENSOR_ASSERT((de.dimension() == 1));
+            XTENSOR_ASSERT((replace || n <= de.size()));
+            XTENSOR_ASSERT((de.size() == dweights.size()));
+            XTENSOR_ASSERT((de.dimension() == dweights.dimension()));
+            XTENSOR_ASSERT(xt::all(dweights >= 0));
+            static_assert(
+                std::is_floating_point<typename W::value_type>::value,
+                "Weight expression must be of floating point type"
+            );
+            using result_type = xtensor<typename T::value_type, 1>;
+            using size_type = typename result_type::size_type;
+            using weight_type = typename W::value_type;
+            result_type result;
+            result.resize({n});
+
+            if (replace)
+            {
+                // Sample u uniformly in the range [0, sum(weights)[
+                // The index idx of the sampled element is such that weight_cumul[idx - 1] <= u <
+                // weight_cumul[idx]. Where weight_cumul[-1] is implicitly 0, as the empty sum.
+                const auto wc = eval(cumsum(dweights));
+                std::uniform_real_distribution<weight_type> weight_dist{0, wc[wc.size() - 1]};
+                for (auto& x : result)
+                {
+                    const auto u = weight_dist(engine);
+                    const auto idx = static_cast<size_type>(
+                        std::upper_bound(wc.cbegin(), wc.cend(), u) - wc.cbegin()
+                    );
+                    x = de[idx];
+                }
+            }
+            else
+            {
+                // Compute (modified) keys as weight/randexp(1).
+                xtensor<weight_type, 1> keys;
+                keys.resize({dweights.size()});
+                std::exponential_distribution<weight_type> randexp{weight_type(1)};
+                std::transform(
+                    dweights.cbegin(),
+                    dweights.cend(),
+                    keys.begin(),
+                    [&randexp, &engine](auto w)
+                    {
+                        return w / randexp(engine);
+                    }
+                );
+
+                // Find indexes for the n biggest key
+                xtensor<size_type, 1> indices = arange<size_type>(0, dweights.size());
+                std::partial_sort(
+                    indices.begin(),
+                    indices.begin() + n,
+                    indices.end(),
+                    [&keys](auto i, auto j)
+                    {
+                        return keys[i] > keys[j];
+                    }
+                );
+
+                // Return samples with the n biggest keys
+                result = index_view(de, xtl::span<size_type>{indices.data(), n});
+            }
+            return result;
+        }
+
+    }
+}
+
+#endif
diff --git a/include/xtensor/io/xcsv.hpp b/include/xtensor/io/xcsv.hpp
new file mode 100644
index 000000000..70472625e
--- /dev/null
+++ b/include/xtensor/io/xcsv.hpp
@@ -0,0 +1,337 @@
+/***************************************************************************
+ * 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_CSV_HPP
+#define XTENSOR_CSV_HPP
+
+#include <istream>
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "../containers/xtensor.hpp"
+#include "../core/xtensor_config.hpp"
+
+namespace xt
+{
+
+    /**************************************
+     * load_csv and dump_csv declarations *
+     **************************************/
+
+    template <class T, class A = std::allocator<T>>
+    using xcsv_tensor = xtensor_container<std::vector<T, A>, 2, layout_type::row_major>;
+
+    template <class T, class A = std::allocator<T>>
+    xcsv_tensor<T, A> load_csv(
+        std::istream& stream,
+        const char delimiter = ',',
+        const std::size_t skip_rows = 0,
+        const std::ptrdiff_t max_rows = -1,
+        const std::string comments = "#"
+    );
+
+    template <class E>
+    void dump_csv(std::ostream& stream, const xexpression<E>& e);
+
+    /*****************************************
+     * load_csv and dump_csv implementations *
+     *****************************************/
+
+    namespace detail
+    {
+        template <class T>
+        inline T lexical_cast(const std::string& cell)
+        {
+            T res;
+            std::istringstream iss(cell);
+            iss >> res;
+            return res;
+        }
+
+        template <>
+        inline std::string lexical_cast(const std::string& cell)
+        {
+            size_t first = cell.find_first_not_of(' ');
+            if (first == std::string::npos)
+            {
+                return cell;
+            }
+
+            size_t last = cell.find_last_not_of(' ');
+            return cell.substr(first, last == std::string::npos ? cell.size() : last - first + 1);
+        }
+
+        template <>
+        inline float lexical_cast<float>(const std::string& cell)
+        {
+            return std::stof(cell);
+        }
+
+        template <>
+        inline double lexical_cast<double>(const std::string& cell)
+        {
+            return std::stod(cell);
+        }
+
+        template <>
+        inline long double lexical_cast<long double>(const std::string& cell)
+        {
+            return std::stold(cell);
+        }
+
+        template <>
+        inline int lexical_cast<int>(const std::string& cell)
+        {
+            return std::stoi(cell);
+        }
+
+        template <>
+        inline signed char lexical_cast<signed char>(const std::string& cell)
+        {
+            return static_cast<signed char>(std::stoi(cell));
+        }
+
+        template <>
+        inline unsigned char lexical_cast<unsigned char>(const std::string& cell)
+        {
+            return static_cast<unsigned char>(std::stoul(cell));
+        }
+
+        template <>
+        inline long lexical_cast<long>(const std::string& cell)
+        {
+            return std::stol(cell);
+        }
+
+        template <>
+        inline long long lexical_cast<long long>(const std::string& cell)
+        {
+            return std::stoll(cell);
+        }
+
+        template <>
+        inline unsigned int lexical_cast<unsigned int>(const std::string& cell)
+        {
+            return static_cast<unsigned int>(std::stoul(cell));
+        }
+
+        template <>
+        inline unsigned long lexical_cast<unsigned long>(const std::string& cell)
+        {
+            return std::stoul(cell);
+        }
+
+        template <>
+        inline unsigned long long lexical_cast<unsigned long long>(const std::string& cell)
+        {
+            return std::stoull(cell);
+        }
+
+        template <class ST, class T, class OI>
+        ST load_csv_row(std::istream& row_stream, OI output, std::string cell, const char delimiter = ',')
+        {
+            ST length = 0;
+            while (std::getline(row_stream, cell, delimiter))
+            {
+                *output++ = lexical_cast<T>(cell);
+                ++length;
+            }
+            return length;
+        }
+    }
+
+    /**
+     * @brief Load tensor from CSV.
+     *
+     * Returns an \ref xexpression for the parsed CSV
+     * @param stream the input stream containing the CSV encoded values
+     * @param delimiter the character used to separate values. [default: ',']
+     * @param skip_rows the number of lines to skip from the beginning. [default: 0]
+     * @param max_rows the number of lines to read after skip_rows lines; the default is to read all the
+     * lines. [default: -1]
+     * @param comments the string used to indicate the start of a comment. [default: "#"]
+     */
+    template <class T, class A>
+    xcsv_tensor<T, A> load_csv(
+        std::istream& stream,
+        const char delimiter,
+        const std::size_t skip_rows,
+        const std::ptrdiff_t max_rows,
+        const std::string comments
+    )
+    {
+        using tensor_type = xcsv_tensor<T, A>;
+        using storage_type = typename tensor_type::storage_type;
+        using size_type = typename tensor_type::size_type;
+        using inner_shape_type = typename tensor_type::inner_shape_type;
+        using inner_strides_type = typename tensor_type::inner_strides_type;
+        using output_iterator = std::back_insert_iterator<storage_type>;
+
+        storage_type data;
+        size_type nbrow = 0, nbcol = 0, nhead = 0;
+        {
+            output_iterator output(data);
+            std::string row, cell;
+            while (std::getline(stream, row))
+            {
+                if (nhead < skip_rows)
+                {
+                    ++nhead;
+                    continue;
+                }
+                if (std::equal(comments.begin(), comments.end(), row.begin()))
+                {
+                    continue;
+                }
+                if (0 < max_rows && max_rows <= static_cast<const long long>(nbrow))
+                {
+                    break;
+                }
+                std::stringstream row_stream(row);
+                nbcol = detail::load_csv_row<size_type, T, output_iterator>(row_stream, output, cell, delimiter);
+                ++nbrow;
+            }
+        }
+        inner_shape_type shape = {nbrow, nbcol};
+        inner_strides_type strides;  // no need for initializer list for stack-allocated strides_type
+        size_type data_size = compute_strides(shape, layout_type::row_major, strides);
+        // Sanity check for data size.
+        if (data.size() != data_size)
+        {
+            XTENSOR_THROW(std::runtime_error, "Inconsistent row lengths in CSV");
+        }
+        return tensor_type(std::move(data), std::move(shape), std::move(strides));
+    }
+
+    /**
+     * @brief Dump tensor to CSV.
+     *
+     * @param stream the output stream to write the CSV encoded values
+     * @param e the tensor expression to serialize
+     */
+    template <class E>
+    void dump_csv(std::ostream& stream, const xexpression<E>& e)
+    {
+        using size_type = typename E::size_type;
+        const E& ex = e.derived_cast();
+        if (ex.dimension() == 1)
+        {
+            const size_type n = ex.shape()[0];
+            for (size_type i = 0; i != n; ++i)
+            {
+                stream << ex(i);
+                if (i != n - 1)
+                {
+                    stream << ',';
+                }
+            }
+            stream << std::endl;
+        }
+        else if (ex.dimension() == 2)
+        {
+            const size_type nbrows = ex.shape()[0];
+            const size_type nbcols = ex.shape()[1];
+            for (size_type r = 0; r != nbrows; ++r)
+            {
+                for (size_type c = 0; c != nbcols; ++c)
+                {
+                    stream << ex(r, c);
+                    if (c != nbcols - 1)
+                    {
+                        stream << ',';
+                    }
+                }
+                stream << std::endl;
+            }
+        }
+        else
+        {
+            XTENSOR_THROW(std::runtime_error, "Only 1-D and 2-D expressions can be serialized to CSV");
+        }
+    }
+
+    struct xcsv_config
+    {
+        char delimiter;
+        std::size_t skip_rows;
+        std::ptrdiff_t max_rows;
+        std::string comments;
+
+        xcsv_config()
+            : delimiter(',')
+            , skip_rows(0)
+            , max_rows(-1)
+            , comments("#")
+        {
+        }
+    };
+
+    template <class E>
+    void dump_csv(std::ostream& stream, const xexpression<E>& e, const xcsv_config& config)
+    {
+        using size_type = typename E::size_type;
+        const E& ex = e.derived_cast();
+        if (ex.dimension() == 1)
+        {
+            const size_type n = ex.shape()[0];
+            for (size_type i = 0; i != n; ++i)
+            {
+                stream << ex(i);
+                if (i != n - 1)
+                {
+                    stream << config.delimiter;
+                }
+            }
+            stream << std::endl;
+        }
+        else if (ex.dimension() == 2)
+        {
+            const size_type nbrows = ex.shape()[0];
+            const size_type nbcols = ex.shape()[1];
+            for (size_type r = 0; r != nbrows; ++r)
+            {
+                for (size_type c = 0; c != nbcols; ++c)
+                {
+                    stream << ex(r, c);
+                    if (c != nbcols - 1)
+                    {
+                        stream << config.delimiter;
+                    }
+                }
+                stream << std::endl;
+            }
+        }
+        else
+        {
+            XTENSOR_THROW(std::runtime_error, "Only 1-D and 2-D expressions can be serialized to CSV");
+        }
+    }
+
+    template <class E>
+    void load_file(std::istream& stream, xexpression<E>& e, const xcsv_config& config)
+    {
+        e.derived_cast() = load_csv<typename E::value_type>(
+            stream,
+            config.delimiter,
+            config.skip_rows,
+            config.max_rows,
+            config.comments
+        );
+    }
+
+    template <class E>
+    void dump_file(std::ostream& stream, const xexpression<E>& e, const xcsv_config& config)
+    {
+        dump_csv(stream, e, config);
+    }
+}
+
+#endif
diff --git a/include/xtensor/xinfo.hpp b/include/xtensor/io/xinfo.hpp
similarity index 57%
rename from include/xtensor/xinfo.hpp
rename to include/xtensor/io/xinfo.hpp
index 50da4f6cd..478569cc7 100644
--- a/include/xtensor/xinfo.hpp
+++ b/include/xtensor/io/xinfo.hpp
@@ -1,45 +1,18 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_INFO_HPP
 #define XTENSOR_INFO_HPP
 
 #include <string>
 
-#ifndef _MSC_VER
-#  if __cplusplus < 201103
-#    define CONSTEXPR11_TN
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN
-#  elif __cplusplus < 201402
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN noexcept
-#  else
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN constexpr
-#    define NOEXCEPT_TN noexcept
-#  endif
-#else  // _MSC_VER
-#  if _MSC_VER < 1900
-#    define CONSTEXPR11_TN
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN
-#  elif _MSC_VER < 2000
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN
-#    define NOEXCEPT_TN noexcept
-#  else
-#    define CONSTEXPR11_TN constexpr
-#    define CONSTEXPR14_TN constexpr
-#    define NOEXCEPT_TN noexcept
-#  endif
-#endif
+#include "../core/xlayout.hpp"
 
 namespace xt
 {
@@ -47,13 +20,15 @@ namespace xt
     struct static_string
     {
         template <std::size_t N>
-        explicit CONSTEXPR11_TN static_string(const char (&a)[N]) NOEXCEPT_TN
-            : data(a), size(N - 1)
+        explicit constexpr static_string(const char (&a)[N]) noexcept
+            : data(a)
+            , size(N - 1)
         {
         }
 
-        CONSTEXPR11_TN static_string(const char* a, const std::size_t sz) NOEXCEPT_TN
-            : data(a), size(sz)
+        constexpr static_string(const char* a, const std::size_t sz) noexcept
+            : data(a)
+            , size(sz)
         {
         }
 
@@ -62,18 +37,14 @@ namespace xt
     };
 
     template <class T>
-    CONSTEXPR14_TN static_string type_name()
+    constexpr static_string type_name()
     {
 #ifdef __clang__
         static_string p(__PRETTY_FUNCTION__);
         return static_string(p.data + 39, p.size - 39 - 1);
 #elif defined(__GNUC__)
         static_string p(__PRETTY_FUNCTION__);
-#if __cplusplus < 201402
-        return static_string(p.data + 36, p.size - 36 - 1);
-#else
         return static_string(p.data + 54, p.size - 54 - 1);
-#endif
 #elif defined(_MSC_VER)
         static const static_string p(__FUNCSIG__);
         return static_string(p.data + 47, p.size - 47 - 7);
diff --git a/include/xtensor/xio.hpp b/include/xtensor/io/xio.hpp
similarity index 56%
rename from include/xtensor/xio.hpp
rename to include/xtensor/io/xio.hpp
index 7a78a304e..09ee4da58 100644
--- a/include/xtensor/xio.hpp
+++ b/include/xtensor/io/xio.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_IO_HPP
 #define XTENSOR_IO_HPP
@@ -13,13 +14,13 @@
 #include <cstddef>
 #include <iomanip>
 #include <iostream>
-#include <numeric>
 #include <sstream>
 #include <string>
 
-#include "xexpression.hpp"
-#include "xmath.hpp"
-#include "xstrided_view.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xmath.hpp"
+#include "../views/xstrided_view.hpp"
+#include "xtl/xmasked_value_meta.hpp"
 
 namespace xt
 {
@@ -91,31 +92,36 @@ namespace xt
             print_options().precision = precision;
         }
 
-#define DEFINE_LOCAL_PRINT_OPTION(NAME)                                   \
-        class NAME                                                        \
-        {                                                                 \
-        public:                                                           \
-            NAME(int value) : m_value(value)                              \
-            {                                                             \
-                id();                                                     \
-            }                                                             \
-            static int id()                                               \
-            {                                                             \
-                static int id = std::ios_base::xalloc();                  \
-                return id;                                                \
-            }                                                             \
-            int value() const                                             \
-            {                                                             \
-                return m_value;                                           \
-            }                                                             \
-        private:                                                          \
-            int m_value;                                                  \
-        };                                                                \
-        inline std::ostream& operator<<(std::ostream& out, const NAME& n) \
-        {                                                                 \
-            out.iword(NAME::id()) = n.value();                            \
-            return out;                                                   \
-        }
+#define DEFINE_LOCAL_PRINT_OPTION(NAME)                               \
+    class NAME                                                        \
+    {                                                                 \
+    public:                                                           \
+                                                                      \
+        NAME(int value)                                               \
+            : m_value(value)                                          \
+        {                                                             \
+            id();                                                     \
+        }                                                             \
+        static int id()                                               \
+        {                                                             \
+            static int id = std::ios_base::xalloc();                  \
+            return id;                                                \
+        }                                                             \
+        int value() const                                             \
+        {                                                             \
+            return m_value;                                           \
+        }                                                             \
+                                                                      \
+    private:                                                          \
+                                                                      \
+        int m_value;                                                  \
+    };                                                                \
+                                                                      \
+    inline std::ostream& operator<<(std::ostream& out, const NAME& n) \
+    {                                                                 \
+        out.iword(NAME::id()) = n.value();                            \
+        return out;                                                   \
+    }
 
         /**
          * @class line_width
@@ -123,11 +129,11 @@ namespace xt
          * io manipulator used to set the width of the lines when printing
          * an expression.
          *
-         * \code{.cpp}
+         * @code{.cpp}
          * using po = xt::print_options;
-         * xt::xarray<double> a = {{1, 2, 3}, {4, 5, 6}}; 
+         * xt::xarray<double> a = {{1, 2, 3}, {4, 5, 6}};
          * std::cout << po::line_width(100) << a << std::endl;
-         * \endcode
+         * @endcode
          */
         DEFINE_LOCAL_PRINT_OPTION(line_width)
 
@@ -137,42 +143,42 @@ namespace xt
          * io manipulator used to set the threshold after which summarization is
          * triggered.
          *
-         * \code{.cpp}
+         * @code{.cpp}
          * using po = xt::print_options;
-         * xt::xarray<double> a = xt::rand::randn<double>({2000, 500}); 
+         * xt::xarray<double> a = xt::rand::randn<double>({2000, 500});
          * std::cout << po::threshold(50) << a << std::endl;
-         * \endcode
+         * @endcode
          */
         DEFINE_LOCAL_PRINT_OPTION(threshold)
 
-       /**
+        /**
          * @class edge_items
          *
          * io manipulator used to set the number of egde items if
          * the summarization is triggered.
          *
-         * \code{.cpp}
+         * @code{.cpp}
          * using po = xt::print_options;
-         * xt::xarray<double> a = xt::rand::randn<double>({2000, 500}); 
+         * xt::xarray<double> a = xt::rand::randn<double>({2000, 500});
          * std::cout << po::edge_items(5) << a << std::endl;
-         * \endcode
+         * @endcode
          */
         DEFINE_LOCAL_PRINT_OPTION(edge_items)
 
-       /**
+        /**
          * @class precision
          *
          * io manipulator used to set the precision of the floating point values
          * when printing an expression.
          *
-         * \code{.cpp}
+         * @code{.cpp}
          * using po = xt::print_options;
-         * xt::xarray<double> a = xt::rand::randn<double>({2000, 500}); 
+         * xt::xarray<double> a = xt::rand::randn<double>({2000, 500});
          * std::cout << po::precision(5) << a << std::endl;
-         * \endcode
+         * @endcode
          */
         DEFINE_LOCAL_PRINT_OPTION(precision)
-   }
+    }
 
     /**************************************
      * xexpression ostream implementation *
@@ -181,9 +187,16 @@ namespace xt
     namespace detail
     {
         template <class E, class F>
-        std::ostream& xoutput(std::ostream& out, const E& e,
-                              xstrided_slice_vector& slices, F& printer, std::size_t blanks,
-                              std::streamsize element_width, std::size_t edgeitems, std::size_t line_width)
+        std::ostream& xoutput(
+            std::ostream& out,
+            const E& e,
+            xstrided_slice_vector& slices,
+            F& printer,
+            std::size_t blanks,
+            std::streamsize element_width,
+            std::size_t edgeitems,
+            std::size_t line_width
+        )
         {
             using size_type = typename E::size_type;
 
@@ -198,27 +211,32 @@ namespace xt
 
                 size_type i = 0;
                 size_type elems_on_line = 0;
-                size_type ewp2 = static_cast<size_type>(element_width) + size_type(2);
-                size_type line_lim = static_cast<size_type>(std::floor(line_width / ewp2));
+                const size_type ewp2 = static_cast<size_type>(element_width) + size_type(2);
+                const size_type line_lim = static_cast<size_type>(std::floor(line_width / ewp2));
 
                 out << '{';
                 for (; i != size_type(view.shape()[0] - 1); ++i)
                 {
                     if (edgeitems && size_type(view.shape()[0]) > (edgeitems * 2) && i == edgeitems)
                     {
-                        out << "..., ";
-                        if (view.dimension() > 1)
+                        if (view.dimension() == 1 && line_lim != 0 && elems_on_line >= line_lim)
+                        {
+                            out << " ...,";
+                        }
+                        else if (view.dimension() > 1)
                         {
                             elems_on_line = 0;
-                            out << std::endl
-                                << indents;
+                            out << "...," << std::endl << indents;
+                        }
+                        else
+                        {
+                            out << "..., ";
                         }
                         i = size_type(view.shape()[0]) - edgeitems;
                     }
                     if (view.dimension() == 1 && line_lim != 0 && elems_on_line >= line_lim)
                     {
-                        out << std::endl
-                            << indents;
+                        out << std::endl << indents;
                         elems_on_line = 0;
                     }
                     slices.push_back(static_cast<int>(i));
@@ -226,20 +244,18 @@ namespace xt
                     slices.pop_back();
                     elems_on_line++;
 
-                    if (view.dimension() == 1)
+                    if ((view.dimension() == 1) && !(line_lim != 0 && elems_on_line >= line_lim))
                     {
                         out << ' ';
                     }
-                    else
+                    else if (view.dimension() > 1)
                     {
-                        out << std::endl
-                            << indents;
+                        out << std::endl << indents;
                     }
                 }
                 if (view.dimension() == 1 && line_lim != 0 && elems_on_line >= line_lim)
                 {
-                    out << std::endl
-                        << indents;
+                    out << std::endl << indents;
                 }
                 slices.push_back(static_cast<int>(i));
                 xoutput(out, e, slices, printer, blanks + 1, element_width, edgeitems, line_width) << '}';
@@ -249,7 +265,7 @@ namespace xt
         }
 
         template <class F, class E>
-        static void recurser_run(F& fn, const E& e, xstrided_slice_vector& slices, std::size_t lim = 0)
+        void recurser_run(F& fn, const E& e, xstrided_slice_vector& slices, std::size_t lim = 0)
         {
             using size_type = typename E::size_type;
             const auto view = strided_view(e, slices);
@@ -330,7 +346,7 @@ namespace xt
                     buf << std::fixed;
                     buf.precision(m_precision);
                     buf << (*m_it);
-                    if (!m_required_precision)
+                    if (!m_required_precision && !std::isinf(*m_it) && !std::isnan(*m_it))
                     {
                         buf << '.';
                     }
@@ -395,7 +411,8 @@ namespace xt
                     }
                     if (m_required_precision < m_precision)
                     {
-                        while (std::floor(val * std::pow(10, m_required_precision)) != val * std::pow(10, m_required_precision))
+                        while (std::floor(val * std::pow(10, m_required_precision))
+                               != val * std::pow(10, m_required_precision))
                         {
                             m_required_precision++;
                         }
@@ -423,7 +440,10 @@ namespace xt
         };
 
         template <class T>
-        struct printer<T, std::enable_if_t<std::is_integral<typename T::value_type>::value && !std::is_same<typename T::value_type, bool>::value>>
+        struct printer<
+            T,
+            std::enable_if_t<
+                xtl::is_integral<typename T::value_type>::value && !std::is_same<typename T::value_type, bool>::value>>
         {
             using value_type = std::decay_t<typename T::value_type>;
             using cache_type = std::vector<value_type>;
@@ -436,7 +456,7 @@ namespace xt
             void init()
             {
                 m_it = m_cache.cbegin();
-                m_width = 1 + std::streamsize(std::log10(m_max)) + m_sign;
+                m_width = 1 + std::streamsize((m_max > 0) ? std::log10(m_max) : 0) + m_sign;
             }
 
             std::ostream& print_next(std::ostream& out)
@@ -455,7 +475,7 @@ namespace xt
                 {
                     m_max = math::abs(val);
                 }
-                if (std::is_signed<value_type>::value && val < 0)
+                if (xtl::is_signed<value_type>::value && val < 0)
                 {
                     m_sign = true;
                 }
@@ -504,7 +524,7 @@ namespace xt
                     out << "false";
                 }
                 // TODO: the following std::setw(5) isn't working correctly on OSX.
-                //out << std::boolalpha << std::setw(m_width) << (*m_it);
+                // out << std::boolalpha << std::setw(m_width) << (*m_it);
                 ++m_it;
                 return out;
             }
@@ -535,7 +555,8 @@ namespace xt
             using cache_iterator = typename cache_type::const_iterator;
 
             explicit printer(std::streamsize precision)
-                : real_printer(precision), imag_printer(precision)
+                : real_printer(precision)
+                , imag_printer(precision)
             {
             }
 
@@ -592,7 +613,10 @@ namespace xt
         };
 
         template <class T>
-        struct printer<T, std::enable_if_t<!std::is_fundamental<typename T::value_type>::value && !xtl::is_complex<typename T::value_type>::value>>
+        struct printer<
+            T,
+            std::enable_if_t<
+                !xtl::is_fundamental<typename T::value_type>::value && !xtl::is_complex<typename T::value_type>::value>>
         {
             using const_reference = typename T::const_reference;
             using value_type = std::decay_t<typename T::value_type>;
@@ -623,7 +647,14 @@ namespace xt
             void update(const_reference val)
             {
                 std::stringstream buf;
-                buf << val;
+                if constexpr (xtl::is_xmasked_value<value_type>::value)
+                {
+                    buf << +val;
+                }
+                else
+                {
+                    buf << val;
+                }
                 std::string s = buf.str();
                 if (int(s.size()) > m_width)
                 {
@@ -671,22 +702,46 @@ namespace xt
         print_options::print_options_impl res;
         using print_options::edge_items;
         using print_options::line_width;
-        using print_options::threshold;
         using print_options::precision;
+        using print_options::threshold;
 
         res.edge_items = static_cast<int>(out.iword(edge_items::id()));
         res.line_width = static_cast<int>(out.iword(line_width::id()));
         res.threshold = static_cast<int>(out.iword(threshold::id()));
         res.precision = static_cast<int>(out.iword(precision::id()));
 
-        if(!res.edge_items) { res.edge_items = print_options::print_options().edge_items; }
-        else { out.iword(edge_items::id()) = long(0); }
-        if(!res.line_width) { res.line_width = print_options::print_options().line_width; }
-        else { out.iword(line_width::id()) = long(0); }
-        if(!res.threshold) { res.threshold = print_options::print_options().threshold; }
-        else { out.iword(threshold::id()) = long(0); }
-        if(!res.precision) { res.precision = print_options::print_options().precision; }
-        else { out.iword(precision::id()) = long(0); }
+        if (!res.edge_items)
+        {
+            res.edge_items = print_options::print_options().edge_items;
+        }
+        else
+        {
+            out.iword(edge_items::id()) = long(0);
+        }
+        if (!res.line_width)
+        {
+            res.line_width = print_options::print_options().line_width;
+        }
+        else
+        {
+            out.iword(line_width::id()) = long(0);
+        }
+        if (!res.threshold)
+        {
+            res.threshold = print_options::print_options().threshold;
+        }
+        else
+        {
+            out.iword(threshold::id()) = long(0);
+        }
+        if (!res.precision)
+        {
+            res.precision = print_options::print_options().precision;
+        }
+        else
+        {
+            out.iword(precision::id()) = long(0);
+        }
 
         return res;
     }
@@ -694,13 +749,43 @@ namespace xt
     template <class E, class F>
     std::ostream& pretty_print(const xexpression<E>& e, F&& func, std::ostream& out = std::cout)
     {
-        xfunction<detail::custom_formatter<E>, const_xclosure_t<E>> print_fun(detail::custom_formatter<E>(std::forward<F>(func)), e);
+        xfunction<detail::custom_formatter<E>, const_xclosure_t<E>> print_fun(
+            detail::custom_formatter<E>(std::forward<F>(func)),
+            e
+        );
         return pretty_print(print_fun, out);
     }
 
+    namespace detail
+    {
+        template <class S>
+        class fmtflags_guard
+        {
+        public:
+
+            explicit fmtflags_guard(S& stream)
+                : m_stream(stream)
+                , m_flags(stream.flags())
+            {
+            }
+
+            ~fmtflags_guard()
+            {
+                m_stream.flags(m_flags);
+            }
+
+        private:
+
+            S& m_stream;
+            std::ios_base::fmtflags m_flags;
+        };
+    }
+
     template <class E>
     std::ostream& pretty_print(const xexpression<E>& e, std::ostream& out = std::cout)
     {
+        detail::fmtflags_guard<std::ostream> guard(out);
+
         const E& d = e.derived_cast();
 
         std::size_t lim = 0;
@@ -744,360 +829,11 @@ namespace xt
     {
         return pretty_print(e, out);
     }
-
-#ifdef __CLING__
-
-    template <class P>
-    void compute_1d_row(std::stringstream& out, P& printer, const std::size_t& row_idx)
-    {
-        out << "<tr><td style='font-family:monospace;' title='" << row_idx << "'><pre>";
-        printer.print_next(out);
-        out << "</pre></td></tr>";
-    }
-
-    template <class P, class T>
-    void compute_1d_table(std::stringstream& out, P& printer, const T& expr,
-                          const std::size_t& edgeitems)
-    {
-        const auto& dim = expr.shape()[0];
-
-        out << "<table style='border-style:solid;border-width:1px;'><tbody>";
-        if (edgeitems == 0 || 2 * edgeitems >= dim)
-        {
-            for (std::size_t row_idx = 0; row_idx < dim; ++row_idx)
-            {
-                compute_1d_row(out, printer, row_idx);
-            }
-        }
-        else
-        {
-            for (std::size_t row_idx = 0; row_idx < edgeitems; ++row_idx)
-            {
-                compute_1d_row(out, printer, row_idx);
-            }
-            out << "<tr><td><center>...</center></td></tr>";
-            for (std::size_t row_idx = dim - edgeitems; row_idx < dim; ++row_idx)
-            {
-                compute_1d_row(out, printer, row_idx);
-            }
-        }
-        out << "</tbody></table>";
-    }
-
-    template <class P>
-    void compute_2d_element(std::stringstream& out, P& printer, const std::string& idx_str,
-                            const std::size_t& row_idx, const std::size_t& column_idx)
-    {
-        out << "<td style='font-family:monospace;' title='("
-            << idx_str << row_idx << ", " << column_idx << ")'><pre>";
-        printer.print_next(out);
-        out << "</pre></td>";
-    }
-
-    template <class P, class T>
-    void compute_2d_row(std::stringstream& out, P& printer, const T& expr,
-                        const std::size_t& edgeitems, const std::string& idx_str,
-                        const std::size_t& row_idx)
-    {
-        const auto& dim = expr.shape()[expr.dimension() - 1];
-
-        out << "<tr>";
-        if (edgeitems == 0 || 2 * edgeitems >= dim)
-        {
-            for (std::size_t column_idx = 0; column_idx < dim; ++column_idx)
-            {
-                compute_2d_element(out, printer, idx_str, row_idx, column_idx);
-            }
-        }
-        else
-        {
-            for (std::size_t column_idx = 0; column_idx < edgeitems; ++column_idx)
-            {
-                compute_2d_element(out, printer, idx_str, row_idx, column_idx);
-            }
-            out << "<td><center>...</center></td>";
-            for (std::size_t column_idx = dim - edgeitems; column_idx < dim; ++column_idx)
-            {
-                compute_2d_element(out, printer, idx_str, row_idx, column_idx);
-            }
-        }
-        out << "</tr>";
-    }
-
-    template <class P, class T, class I>
-    void compute_2d_table(std::stringstream& out, P& printer, const T& expr,
-                               const std::size_t& edgeitems, const std::vector<I>& idx)
-    {
-        const auto& dim = expr.shape()[expr.dimension() - 2];
-        std::string idx_str;
-        std::for_each(idx.cbegin(), idx.cend(), [&idx_str](const auto& i) {
-            idx_str += std::to_string(i) + ", ";
-        });
-
-        out << "<table style='border-style:solid;border-width:1px;'><tbody>";
-        if (edgeitems == 0 || 2 * edgeitems >= dim)
-        {
-            for (std::size_t row_idx = 0; row_idx < dim; ++row_idx)
-            {
-                compute_2d_row(out, printer, expr, edgeitems, idx_str, row_idx);
-            }
-        }
-        else
-        {
-            for (std::size_t row_idx = 0; row_idx < edgeitems; ++row_idx)
-            {
-                compute_2d_row(out, printer, expr, edgeitems, idx_str, row_idx);
-            }
-            out << "<tr>";
-            for (std::size_t column_idx = 0; column_idx < 2 * edgeitems + 1; ++column_idx)
-            {
-                out << "<td><center>...</center></td>";
-            }
-            out << "</tr>";
-            for (std::size_t row_idx = dim - edgeitems; row_idx < dim; ++row_idx)
-            {
-                compute_2d_row(out, printer, expr, edgeitems, idx_str, row_idx);
-            }
-        }
-        out << "</tbody></table>";
-    }
-
-    template <class P, class T, class I>
-    void compute_nd_row(std::stringstream& out, P& printer, const T& expr,
-                         const std::size_t& edgeitems, const std::vector<I>& idx)
-    {
-        out << "<tr><td>";
-        compute_nd_table_impl(out, printer, expr, edgeitems, idx);
-        out << "</td></tr>";
-    }
-
-    template <class P, class T, class I>
-    void compute_nd_table_impl(std::stringstream& out, P& printer, const T& expr,
-                               const std::size_t& edgeitems, const std::vector<I>& idx)
-    {
-        const auto& displayed_dimension = idx.size();
-        const auto& expr_dim = expr.dimension();
-        const auto& dim = expr.shape()[displayed_dimension];
-
-        if (expr_dim - displayed_dimension == 2)
-        {
-            return compute_2d_table(out, printer, expr, edgeitems, idx);
-        }
-
-        std::vector<I> idx2 = idx;
-        idx2.resize(displayed_dimension + 1);
-
-        out << "<table style='border-style:solid;border-width:1px;'>";
-        if (edgeitems == 0 || 2 * edgeitems >= dim)
-        {
-            for (std::size_t i = 0; i < dim; ++i)
-            {
-                idx2[displayed_dimension] = i;
-                compute_nd_row(out, printer, expr, edgeitems, idx2);
-            }
-        }
-        else
-        {
-            for (std::size_t i = 0; i < edgeitems; ++i)
-            {
-                idx2[displayed_dimension] = i;
-                compute_nd_row(out, printer, expr, edgeitems, idx2);
-            }
-            out << "<tr><td><center>...</center></td></tr>";
-            for (std::size_t i = dim - edgeitems; i < dim; ++i)
-            {
-                idx2[displayed_dimension] = i;
-                compute_nd_row(out, printer, expr, edgeitems, idx2);
-            }
-        }
-        out << "</table>";
-    }
-
-    template <class P, class T>
-    void compute_nd_table(std::stringstream& out, P& printer, const T& expr,
-                          const std::size_t& edgeitems)
-    {
-        if (expr.dimension() == 1)
-        {
-            compute_1d_table(out, printer, expr, edgeitems);
-        }
-        else
-        {
-            std::vector<std::size_t> empty_vector;
-            compute_nd_table_impl(out, printer, expr, edgeitems, empty_vector);
-        }
-    }
-
-    template <class E>
-    xeus::xjson mime_bundle_repr_impl(const E& expr)
-    {
-        std::stringstream out;
-
-        std::size_t edgeitems = 0;
-        std::size_t size = compute_size(expr.shape());
-        if (size > print_options::print_options().threshold)
-        {
-            edgeitems = print_options::print_options().edgeitems;
-        }
-
-        if (print_options::print_options().precision != -1)
-        {
-            out.precision(print_options::print_options().precision);
-        }
-
-        detail::printer<E> printer(out.precision());
-
-        xstrided_slice_vector slice_vector;
-        detail::recurser_run(printer, expr, slice_vector, edgeitems);
-        printer.init();
-
-        compute_nd_table(out, printer, expr, edgeitems);
-
-        auto bundle = xeus::xjson::object();
-        bundle["text/html"] = out.str();
-        return bundle;
-    }
-
-    template <class F, class CT>
-    class xfunctor_view;
-
-    template <class F, class CT>
-    xeus::xjson mime_bundle_repr(const xfunctor_view<F, CT>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class F, class... CT>
-    class xfunction;
-
-    template <class F, class... CT>
-    xeus::xjson mime_bundle_repr(const xfunction<F, CT...>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class EC, layout_type L, class SC, class Tag>
-    class xarray_container;
-
-    template <class EC, layout_type L, class SC, class Tag>
-    xeus::xjson mime_bundle_repr(const xarray_container<EC, L, SC, Tag>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    class xtensor_container;
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    xeus::xjson mime_bundle_repr(const xtensor_container<EC, N, L, Tag>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class ET, class S, layout_type L, class Tag>
-    class xfixed_container;
-
-    template <class ET, class S, layout_type L, class Tag>
-    xeus::xjson mime_bundle_repr(const xfixed_container<ET, S, L, Tag>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class F, class CT, class X>
-    class xreducer;
-
-    template <class F, class CT, class X>
-    xeus::xjson mime_bundle_repr(const xreducer<F, CT, X>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class VE, class FE>
-    class xoptional_assembly;
-
-    template <class VE, class FE>
-    xeus::xjson mime_bundle_repr(const xoptional_assembly<VE, FE>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class VEC, class FEC>
-    class xoptional_assembly_adaptor;
-
-    template <class VEC, class FEC>
-    xeus::xjson mime_bundle_repr(const xoptional_assembly_adaptor<VEC, FEC>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class CT>
-    class xscalar;
-
-    template <class CT>
-    xeus::xjson mime_bundle_repr(const xscalar<CT>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class CT, class X>
-    class xbroadcast;
-
-    template <class CT, class X>
-    xeus::xjson mime_bundle_repr(const xbroadcast<CT, X>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class F, class R, class S>
-    class xgenerator;
-
-    template <class F, class R, class S>
-    xeus::xjson mime_bundle_repr(const xgenerator<F, R, S>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class CT, class... S>
-    class xview;
-
-    template <class CT, class... S>
-    xeus::xjson mime_bundle_repr(const xview<CT, S...>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    class xstrided_view;
-
-    template <class CT, class S, layout_type L, class FST>
-    xeus::xjson mime_bundle_repr(const xstrided_view<CT, S, L, FST>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class CTD, class CTM>
-    class xmasked_view;
-
-    template <class CTD, class CTM>
-    xeus::xjson mime_bundle_repr(const xmasked_view<CTD, CTM>& expr)
-    {
-        return mime_bundle_repr_impl(expr);
-    }
-
-    template <class T, class B>
-    class xmasked_value;
-
-    template <class T, class B>
-    xeus::xjson mime_bundle_repr(const xmasked_value<T, B>& v)
-    {
-        auto bundle = xeus::xjson::object();
-        std::stringstream tmp;
-        tmp << v;
-        bundle["text/plain"] = tmp.str();
-        return bundle;
-    }
-
-#endif
 }
+#endif
+
+// Backward compatibility: include xmime.hpp in xio.hpp by default.
 
+#if defined(__CLING__) || defined(__CLANG_REPL__)
+#include "xmime.hpp"
 #endif
diff --git a/include/xtensor/xjson.hpp b/include/xtensor/io/xjson.hpp
similarity index 59%
rename from include/xtensor/xjson.hpp
rename to include/xtensor/io/xjson.hpp
index b0d33ed8a..18623b7f8 100644
--- a/include/xtensor/xjson.hpp
+++ b/include/xtensor/io/xjson.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_JSON_HPP
 #define XTENSOR_JSON_HPP
@@ -15,7 +16,8 @@
 
 #include <nlohmann/json.hpp>
 
-#include "xstrided_view.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../views/xstrided_view.hpp"
 
 namespace xt
 {
@@ -23,15 +25,16 @@ namespace xt
      * to_json and from_json declaration *
      *************************************/
 
-    template <class E>
-    enable_xexpression<E> to_json(nlohmann::json&, const E&);
+    template <template <typename U, typename V, typename... Args> class M, class E>
+    enable_xexpression<E> to_json(nlohmann::basic_json<M>&, const E&);
 
-    template <class E>
-    enable_xcontainer_semantics<E> from_json(const nlohmann::json&, E&);
+    template <template <typename U, typename V, typename... Args> class M, class E>
+    enable_xcontainer_semantics<E> from_json(const nlohmann::basic_json<M>&, E&);
 
     /// @cond DOXYGEN_INCLUDE_SFINAE
-    template <class E>
-    enable_xview_semantics<E> from_json(const nlohmann::json&, E&);
+    template <template <typename U, typename V, typename... Args> class M, class E>
+    enable_xview_semantics<E> from_json(const nlohmann::basic_json<M>&, E&);
+
     /// @endcond
 
     /****************************************
@@ -40,8 +43,8 @@ namespace xt
 
     namespace detail
     {
-        template <class D>
-        void to_json_impl(nlohmann::json& j, const xexpression<D>& e, xstrided_slice_vector& slices)
+        template <template <typename U, typename V, typename... Args> class M, class D>
+        void to_json_impl(nlohmann::basic_json<M>& j, const xexpression<D>& e, xstrided_slice_vector& slices)
         {
             const auto view = strided_view(e.derived_cast(), slices);
             if (view.dimension() == 0)
@@ -50,13 +53,13 @@ namespace xt
             }
             else
             {
-                j = nlohmann::json::array();
+                j = nlohmann::basic_json<M>::array();
                 using size_type = typename D::size_type;
                 size_type nrows = view.shape()[0];
                 for (size_type i = 0; i != nrows; ++i)
                 {
-                    slices.push_back(i);
-                    nlohmann::json k;
+                    slices.push_back(static_cast<std::ptrdiff_t>(i));
+                    nlohmann::basic_json<M> k;
                     to_json_impl(k, e, slices);
                     j.push_back(std::move(k));
                     slices.pop_back();
@@ -64,14 +67,15 @@ namespace xt
             }
         }
 
-        template <class D>
-        inline void from_json_impl(const nlohmann::json& j, xexpression<D>& e, xstrided_slice_vector& slices)
+        template <template <typename U, typename V, typename... Args> class M, class D>
+        inline void
+        from_json_impl(const nlohmann::basic_json<M>& j, xexpression<D>& e, xstrided_slice_vector& slices)
         {
             auto view = strided_view(e.derived_cast(), slices);
 
             if (view.dimension() == 0)
             {
-                view() = j;
+                view() = j.template get<std::remove_reference_t<decltype(view())>>();
             }
             else
             {
@@ -79,15 +83,16 @@ namespace xt
                 size_type nrows = view.shape()[0];
                 for (size_type i = 0; i != nrows; ++i)
                 {
-                    slices.push_back(i);
-                    const nlohmann::json& k = j[i];
+                    slices.push_back(static_cast<std::ptrdiff_t>(i));
+                    const nlohmann::basic_json<M>& k = j[i];
                     from_json_impl(k, e, slices);
                     slices.pop_back();
                 }
             }
         }
 
-        inline unsigned int json_dimension(const nlohmann::json& j)
+        template <template <typename U, typename V, typename... Args> class M>
+        inline unsigned int json_dimension(const nlohmann::basic_json<M>& j)
         {
             if (j.is_array() && j.size())
             {
@@ -99,8 +104,8 @@ namespace xt
             }
         }
 
-        template <class S>
-        inline void json_shape(const nlohmann::json& j, S& s, std::size_t pos = 0)
+        template <template <typename U, typename V, typename... Args> class M, class S>
+        inline void json_shape(const nlohmann::basic_json<M>& j, S& s, std::size_t pos = 0)
         {
             if (j.is_array())
             {
@@ -124,8 +129,8 @@ namespace xt
      * @param j a JSON object
      * @param e a const \ref xexpression
      */
-    template <class E>
-    inline enable_xexpression<E> to_json(nlohmann::json& j, const E& e)
+    template <template <typename U, typename V, typename... Args> class M, class E>
+    inline enable_xexpression<E> to_json(nlohmann::basic_json<M>& j, const E& e)
     {
         auto sv = xstrided_slice_vector();
         detail::to_json_impl(j, e, sv);
@@ -139,7 +144,7 @@ namespace xt
      * serialization of user-defined types. The method is picked up by
      * argument-dependent lookup.
      *
-     * Note: for converting a JSON object to a value, nlohmann_json requiress
+     * Note: for converting a JSON object to a value, nlohmann_json requires
      * the value type to be default constructible, which is typically not the
      * case for expressions with a view semantics. In this case, from_json can
      * be called directly.
@@ -147,8 +152,8 @@ namespace xt
      * @param j a const JSON object
      * @param e an \ref xexpression
      */
-    template <class E>
-    inline enable_xcontainer_semantics<E> from_json(const nlohmann::json& j, E& e)
+    template <template <typename U, typename V, typename... Args> class M, class E>
+    inline enable_xcontainer_semantics<E> from_json(const nlohmann::basic_json<M>& j, E& e)
     {
         auto dimension = detail::json_dimension(j);
         auto s = xtl::make_sequence<typename E::shape_type>(dimension);
@@ -162,8 +167,8 @@ namespace xt
     }
 
     /// @cond DOXYGEN_INCLUDE_SFINAE
-    template <class E>
-    inline enable_xview_semantics<E> from_json(const nlohmann::json& j, E& e)
+    template <template <typename U, typename V, typename... Args> class M, class E>
+    inline enable_xview_semantics<E> from_json(const nlohmann::basic_json<M>& j, E& e)
     {
         typename E::shape_type s;
         detail::json_shape(j, s);
@@ -171,12 +176,13 @@ namespace xt
         // In the case of a view, we check the size of the container.
         if (!std::equal(s.cbegin(), s.cend(), e.shape().cbegin()))
         {
-            throw std::runtime_error("Shape mismatch when deserializing JSON to view");
+            XTENSOR_THROW(std::runtime_error, "Shape mismatch when deserializing JSON to view");
         }
 
         auto sv = xstrided_slice_vector();
         detail::from_json_impl(j, e, sv);
     }
+
     /// @endcond
 }
 
diff --git a/include/xtensor/io/xmime.hpp b/include/xtensor/io/xmime.hpp
new file mode 100644
index 000000000..3e3502cb0
--- /dev/null
+++ b/include/xtensor/io/xmime.hpp
@@ -0,0 +1,431 @@
+/***************************************************************************
+ * 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_MIME_HPP
+#define XTENSOR_MIME_HPP
+
+#include <cstddef>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "../io/xio.hpp"
+
+namespace xt
+{
+    template <class P, class T>
+    void compute_0d_table(std::stringstream& out, P& /*printer*/, const T& expr)
+    {
+        out << "<table style='border-style:solid;border-width:1px;'><tbody>";
+        out << "<tr><td style='font-family:monospace;'><pre>";
+        out << expr();
+        out << "</pre></td></tr>";
+        out << "</tbody></table>";
+    }
+
+    template <class P>
+    void compute_1d_row(std::stringstream& out, P& printer, const std::size_t& row_idx)
+    {
+        out << "<tr><td style='font-family:monospace;' title='" << row_idx << "'><pre>";
+        printer.print_next(out);
+        out << "</pre></td></tr>";
+    }
+
+    template <class P, class T>
+    void compute_1d_table(std::stringstream& out, P& printer, const T& expr, const std::size_t& edgeitems)
+    {
+        const auto& dim = expr.shape()[0];
+
+        out << "<table style='border-style:solid;border-width:1px;'><tbody>";
+        if (edgeitems == 0 || 2 * edgeitems >= dim)
+        {
+            for (std::size_t row_idx = 0; row_idx < dim; ++row_idx)
+            {
+                compute_1d_row(out, printer, row_idx);
+            }
+        }
+        else
+        {
+            for (std::size_t row_idx = 0; row_idx < edgeitems; ++row_idx)
+            {
+                compute_1d_row(out, printer, row_idx);
+            }
+            out << "<tr><td><center>\u22ee</center></td></tr>";
+            for (std::size_t row_idx = dim - edgeitems; row_idx < dim; ++row_idx)
+            {
+                compute_1d_row(out, printer, row_idx);
+            }
+        }
+        out << "</tbody></table>";
+    }
+
+    template <class P>
+    void compute_2d_element(
+        std::stringstream& out,
+        P& printer,
+        const std::string& idx_str,
+        const std::size_t& row_idx,
+        const std::size_t& column_idx
+    )
+    {
+        out << "<td style='font-family:monospace;' title='(" << idx_str << row_idx << ", " << column_idx
+            << ")'><pre>";
+        printer.print_next(out);
+        out << "</pre></td>";
+    }
+
+    template <class P, class T>
+    void compute_2d_row(
+        std::stringstream& out,
+        P& printer,
+        const T& expr,
+        const std::size_t& edgeitems,
+        const std::string& idx_str,
+        const std::size_t& row_idx
+    )
+    {
+        const auto& dim = expr.shape()[expr.dimension() - 1];
+
+        out << "<tr>";
+        if (edgeitems == 0 || 2 * edgeitems >= dim)
+        {
+            for (std::size_t column_idx = 0; column_idx < dim; ++column_idx)
+            {
+                compute_2d_element(out, printer, idx_str, row_idx, column_idx);
+            }
+        }
+        else
+        {
+            for (std::size_t column_idx = 0; column_idx < edgeitems; ++column_idx)
+            {
+                compute_2d_element(out, printer, idx_str, row_idx, column_idx);
+            }
+            out << "<td><center>\u22ef</center></td>";
+            for (std::size_t column_idx = dim - edgeitems; column_idx < dim; ++column_idx)
+            {
+                compute_2d_element(out, printer, idx_str, row_idx, column_idx);
+            }
+        }
+        out << "</tr>";
+    }
+
+    template <class P, class T, class I>
+    void compute_2d_table(
+        std::stringstream& out,
+        P& printer,
+        const T& expr,
+        const std::size_t& edgeitems,
+        const std::vector<I>& idx
+    )
+    {
+        const auto& dim = expr.shape()[expr.dimension() - 2];
+        const auto& last_dim = expr.shape()[expr.dimension() - 1];
+        std::string idx_str;
+        std::for_each(
+            idx.cbegin(),
+            idx.cend(),
+            [&idx_str](const auto& i)
+            {
+                idx_str += std::to_string(i) + ", ";
+            }
+        );
+
+        std::size_t nb_ellipsis = 2 * edgeitems + 1;
+        if (last_dim <= 2 * edgeitems + 1)
+        {
+            nb_ellipsis = last_dim;
+        }
+
+        out << "<table style='border-style:solid;border-width:1px;'><tbody>";
+        if (edgeitems == 0 || 2 * edgeitems >= dim)
+        {
+            for (std::size_t row_idx = 0; row_idx < dim; ++row_idx)
+            {
+                compute_2d_row(out, printer, expr, edgeitems, idx_str, row_idx);
+            }
+        }
+        else
+        {
+            for (std::size_t row_idx = 0; row_idx < edgeitems; ++row_idx)
+            {
+                compute_2d_row(out, printer, expr, edgeitems, idx_str, row_idx);
+            }
+            out << "<tr>";
+            for (std::size_t column_idx = 0; column_idx < nb_ellipsis; ++column_idx)
+            {
+                if (column_idx == edgeitems && nb_ellipsis != last_dim)
+                {
+                    out << "<td><center>\u22f1</center></td>";
+                }
+                else
+                {
+                    out << "<td><center>\u22ee</center></td>";
+                }
+            }
+            out << "</tr>";
+            for (std::size_t row_idx = dim - edgeitems; row_idx < dim; ++row_idx)
+            {
+                compute_2d_row(out, printer, expr, edgeitems, idx_str, row_idx);
+            }
+        }
+        out << "</tbody></table>";
+    }
+
+    template <class P, class T, class I>
+    void compute_nd_row(
+        std::stringstream& out,
+        P& printer,
+        const T& expr,
+        const std::size_t& edgeitems,
+        const std::vector<I>& idx
+    )
+    {
+        out << "<tr><td>";
+        compute_nd_table_impl(out, printer, expr, edgeitems, idx);
+        out << "</td></tr>";
+    }
+
+    template <class P, class T, class I>
+    void compute_nd_table_impl(
+        std::stringstream& out,
+        P& printer,
+        const T& expr,
+        const std::size_t& edgeitems,
+        const std::vector<I>& idx
+    )
+    {
+        const auto& displayed_dimension = idx.size();
+        const auto& expr_dim = expr.dimension();
+        const auto& dim = expr.shape()[displayed_dimension];
+
+        if (expr_dim - displayed_dimension == 2)
+        {
+            return compute_2d_table(out, printer, expr, edgeitems, idx);
+        }
+
+        std::vector<I> idx2 = idx;
+        idx2.resize(displayed_dimension + 1);
+
+        out << "<table style='border-style:solid;border-width:1px;'>";
+        if (edgeitems == 0 || 2 * edgeitems >= dim)
+        {
+            for (std::size_t i = 0; i < dim; ++i)
+            {
+                idx2[displayed_dimension] = i;
+                compute_nd_row(out, printer, expr, edgeitems, idx2);
+            }
+        }
+        else
+        {
+            for (std::size_t i = 0; i < edgeitems; ++i)
+            {
+                idx2[displayed_dimension] = i;
+                compute_nd_row(out, printer, expr, edgeitems, idx2);
+            }
+            out << "<tr><td><center>\u22ef</center></td></tr>";
+            for (std::size_t i = dim - edgeitems; i < dim; ++i)
+            {
+                idx2[displayed_dimension] = i;
+                compute_nd_row(out, printer, expr, edgeitems, idx2);
+            }
+        }
+        out << "</table>";
+    }
+
+    template <class P, class T>
+    void compute_nd_table(std::stringstream& out, P& printer, const T& expr, const std::size_t& edgeitems)
+    {
+        if (expr.dimension() == 0)
+        {
+            compute_0d_table(out, printer, expr);
+        }
+        else if (expr.dimension() == 1)
+        {
+            compute_1d_table(out, printer, expr, edgeitems);
+        }
+        else
+        {
+            std::vector<std::size_t> empty_vector;
+            compute_nd_table_impl(out, printer, expr, edgeitems, empty_vector);
+        }
+    }
+
+    template <class E>
+    nlohmann::json mime_bundle_repr_impl(const E& expr)
+    {
+        std::stringstream out;
+
+        std::size_t edgeitems = 0;
+        std::size_t size = compute_size(expr.shape());
+        if (size > static_cast<std::size_t>(print_options::print_options().threshold))
+        {
+            edgeitems = static_cast<std::size_t>(print_options::print_options().edge_items);
+        }
+
+        if (print_options::print_options().precision != -1)
+        {
+            out.precision(print_options::print_options().precision);
+        }
+
+        detail::printer<E> printer(out.precision());
+
+        xstrided_slice_vector slice_vector;
+        detail::recurser_run(printer, expr, slice_vector, edgeitems);
+        printer.init();
+
+        compute_nd_table(out, printer, expr, edgeitems);
+
+        auto bundle = nlohmann::json::object();
+        bundle["text/html"] = out.str();
+        return bundle;
+    }
+
+    template <class F, class CT>
+    class xfunctor_view;
+
+    template <class F, class CT>
+    nlohmann::json mime_bundle_repr(const xfunctor_view<F, CT>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class F, class... CT>
+    class xfunction;
+
+    template <class F, class... CT>
+    nlohmann::json mime_bundle_repr(const xfunction<F, CT...>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class EC, layout_type L, class SC, class Tag>
+    class xarray_container;
+
+    template <class EC, layout_type L, class SC, class Tag>
+    nlohmann::json mime_bundle_repr(const xarray_container<EC, L, SC, Tag>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    class xtensor_container;
+
+    template <class EC, std::size_t N, layout_type L, class Tag>
+    nlohmann::json mime_bundle_repr(const xtensor_container<EC, N, L, Tag>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    class xfixed_container;
+
+    template <class ET, class S, layout_type L, bool SH, class Tag>
+    nlohmann::json mime_bundle_repr(const xfixed_container<ET, S, L, SH, Tag>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class F, class CT, class X, class O>
+    class xreducer;
+
+    template <class F, class CT, class X, class O>
+    nlohmann::json mime_bundle_repr(const xreducer<F, CT, X, O>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class VE, class FE>
+    class xoptional_assembly;
+
+    template <class VE, class FE>
+    nlohmann::json mime_bundle_repr(const xoptional_assembly<VE, FE>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class VEC, class FEC>
+    class xoptional_assembly_adaptor;
+
+    template <class VEC, class FEC>
+    nlohmann::json mime_bundle_repr(const xoptional_assembly_adaptor<VEC, FEC>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class CT>
+    class xscalar;
+
+    template <class CT>
+    nlohmann::json mime_bundle_repr(const xscalar<CT>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class CT, class X>
+    class xbroadcast;
+
+    template <class CT, class X>
+    nlohmann::json mime_bundle_repr(const xbroadcast<CT, X>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class F, class R, class S>
+    class xgenerator;
+
+    template <class F, class R, class S>
+    nlohmann::json mime_bundle_repr(const xgenerator<F, R, S>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class CT, class... S>
+    class xview;
+
+    template <class CT, class... S>
+    nlohmann::json mime_bundle_repr(const xview<CT, S...>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    class xstrided_view;
+
+    template <class CT, class S, layout_type L, class FST>
+    nlohmann::json mime_bundle_repr(const xstrided_view<CT, S, L, FST>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class CTD, class CTM>
+    class xmasked_view;
+
+    template <class CTD, class CTM>
+    nlohmann::json mime_bundle_repr(const xmasked_view<CTD, CTM>& expr)
+    {
+        return mime_bundle_repr_impl(expr);
+    }
+
+    template <class T, class B>
+    class xmasked_value;
+
+    template <class T, class B>
+    nlohmann::json mime_bundle_repr(const xmasked_value<T, B>& v)
+    {
+        auto bundle = nlohmann::json::object();
+        std::stringstream tmp;
+        tmp << v;
+        bundle["text/plain"] = tmp.str();
+        return bundle;
+    }
+}
+
+#endif
diff --git a/include/xtensor/xnpy.hpp b/include/xtensor/io/xnpy.hpp
similarity index 64%
rename from include/xtensor/xnpy.hpp
rename to include/xtensor/io/xnpy.hpp
index a3479a62e..ef517f068 100644
--- a/include/xtensor/xnpy.hpp
+++ b/include/xtensor/io/xnpy.hpp
@@ -1,11 +1,12 @@
 /***************************************************************************
-* Copyright (c) 2016, Leon Merten Lohse, 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. *
-****************************************************************************/
+ * Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
+ * Copyright Leon Merten Lohse
+ * 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_NPY_HPP
 #define XTENSOR_NPY_HPP
@@ -13,24 +14,25 @@
 // Derived from https://github.com/llohse/libnpy by Leon Merten Lohse,
 // relicensed from MIT License with permission
 
-#include <xtl/xsequence.hpp>
-
 #include <algorithm>
 #include <complex>
 #include <cstdint>
 #include <fstream>
-#include <iostream>
+#include <memory>
 #include <regex>
 #include <sstream>
 #include <stdexcept>
 #include <string>
-#include <typeinfo>
 #include <vector>
 
-#include "xtensor/xadapt.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xeval.hpp"
-#include "xtensor/xstrides.hpp"
+#include <xtl/xplatform.hpp>
+#include <xtl/xsequence.hpp>
+
+#include "../containers/xadapt.hpp"
+#include "../containers/xarray.hpp"
+#include "../core/xeval.hpp"
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_config.hpp"
 
 namespace xt
 {
@@ -39,95 +41,143 @@ namespace xt
     namespace detail
     {
 
-    /* Compile-time test for byte order.
-       If your compiler does not define these per default, you may want to define
-       one of these constants manually.
-       Defaults to little endian order. */
-#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN || defined(__BIG_ENDIAN__) || \
-    defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) ||             \
-    defined(_MIBSEB) || defined(__MIBSEB) || defined(__MIBSEB__)
-        const bool big_endian = true;
-#else
-        const bool big_endian = false;
-#endif
-
         const char magic_string[] = "\x93NUMPY";
-        const std::size_t magic_string_length = 6;
-
-        const char little_endian_char = '<';
-        const char big_endian_char = '>';
-        const char no_endian_char = '|';
-
-        constexpr char host_endian_char = (big_endian ? big_endian_char : little_endian_char);
+        const std::size_t magic_string_length = sizeof(magic_string) - 1;
 
         template <class O>
-        inline void write_magic(O& ostream,
-                                unsigned char v_major = 1,
-                                unsigned char v_minor = 0)
+        inline void write_magic(O& ostream, unsigned char v_major = 1, unsigned char v_minor = 0)
         {
             ostream.write(magic_string, magic_string_length);
             ostream.put(char(v_major));
             ostream.put(char(v_minor));
         }
 
-        inline void read_magic(std::istream& istream,
-                               unsigned char* v_major,
-                               unsigned char* v_minor)
+        inline void read_magic(std::istream& istream, unsigned char* v_major, unsigned char* v_minor)
         {
-            char* buf = new char[magic_string_length + 2];
-            istream.read(buf, magic_string_length + 2);
+            std::unique_ptr<char[]> buf(new char[magic_string_length + 2]);
+            istream.read(buf.get(), magic_string_length + 2);
 
             if (!istream)
             {
-                throw std::runtime_error("io error: failed reading file");
+                XTENSOR_THROW(std::runtime_error, "io error: failed reading file");
             }
 
             for (std::size_t i = 0; i < magic_string_length; i++)
             {
                 if (buf[i] != magic_string[i])
                 {
-                    throw std::runtime_error("this file do not have a valid npy format.");
+                    XTENSOR_THROW(std::runtime_error, "this file do not have a valid npy format.");
                 }
             }
 
             *v_major = static_cast<unsigned char>(buf[magic_string_length]);
             *v_minor = static_cast<unsigned char>(buf[magic_string_length + 1]);
-            delete[] buf;
         }
 
         template <class T>
         inline char map_type()
         {
-            if (std::is_same<T, float>::value) return 'f';
-            if (std::is_same<T, double>::value) return 'f';
-            if (std::is_same<T, long double>::value) return 'f';
-
-            if (std::is_same<T, char>::value) return 'i';
-            if (std::is_same<T, signed char>::value) return 'i';
-            if (std::is_same<T, short>::value) return 'i';
-            if (std::is_same<T, int>::value) return 'i';
-            if (std::is_same<T, long>::value) return 'i';
-            if (std::is_same<T, long long>::value) return 'i';
-
-            if (std::is_same<T, unsigned char>::value) return 'u';
-            if (std::is_same<T, unsigned short>::value) return 'u';
-            if (std::is_same<T, unsigned int>::value) return 'u';
-            if (std::is_same<T, unsigned long>::value) return 'u';
-            if (std::is_same<T, unsigned long long>::value) return 'u';
-
-            if (std::is_same<T, bool>::value) return 'b';
-
-            if (std::is_same<T, std::complex<float>>::value) return 'c';
-            if (std::is_same<T, std::complex<double>>::value) return 'c';
-            if (std::is_same<T, std::complex<long double>>::value) return 'c';
-
-            throw std::runtime_error("Type not known.");
+            if (std::is_same<T, float>::value)
+            {
+                return 'f';
+            }
+            if (std::is_same<T, double>::value)
+            {
+                return 'f';
+            }
+            if (std::is_same<T, long double>::value)
+            {
+                return 'f';
+            }
+
+            if (std::is_same<T, char>::value)
+            {
+                return 'i';
+            }
+            if (std::is_same<T, signed char>::value)
+            {
+                return 'i';
+            }
+            if (std::is_same<T, short>::value)
+            {
+                return 'i';
+            }
+            if (std::is_same<T, int>::value)
+            {
+                return 'i';
+            }
+            if (std::is_same<T, long>::value)
+            {
+                return 'i';
+            }
+            if (std::is_same<T, long long>::value)
+            {
+                return 'i';
+            }
+
+            if (std::is_same<T, unsigned char>::value)
+            {
+                return 'u';
+            }
+            if (std::is_same<T, unsigned short>::value)
+            {
+                return 'u';
+            }
+            if (std::is_same<T, unsigned int>::value)
+            {
+                return 'u';
+            }
+            if (std::is_same<T, unsigned long>::value)
+            {
+                return 'u';
+            }
+            if (std::is_same<T, unsigned long long>::value)
+            {
+                return 'u';
+            }
+
+            if (std::is_same<T, bool>::value)
+            {
+                return 'b';
+            }
+
+            if (std::is_same<T, std::complex<float>>::value)
+            {
+                return 'c';
+            }
+            if (std::is_same<T, std::complex<double>>::value)
+            {
+                return 'c';
+            }
+            if (std::is_same<T, std::complex<long double>>::value)
+            {
+                return 'c';
+            }
+
+            XTENSOR_THROW(std::runtime_error, "Type not known.");
         }
 
         template <class T>
-        constexpr char get_endianess()
+        inline char get_endianess()
         {
-            return sizeof(T) <= sizeof(char) ? no_endian_char : host_endian_char;
+            constexpr char little_endian_char = '<';
+            constexpr char big_endian_char = '>';
+            constexpr char no_endian_char = '|';
+
+            if (sizeof(T) <= sizeof(char))
+            {
+                return no_endian_char;
+            }
+
+            switch (xtl::endianness())
+            {
+                case xtl::endian::little_endian:
+                    return little_endian_char;
+                case xtl::endian::big_endian:
+                    return big_endian_char;
+                default:
+                    return no_endian_char;
+            }
         }
 
         template <class T>
@@ -147,7 +197,7 @@ namespace xt
             std::regex_match(typestring, sm, re);
             if (sm.size() != 4)
             {
-                throw std::runtime_error("invalid typestring");
+                XTENSOR_THROW(std::runtime_error, "invalid typestring");
             }
         }
 
@@ -160,7 +210,7 @@ namespace xt
             }
             else
             {
-                throw std::runtime_error("unable to unwrap");
+                XTENSOR_THROW(std::runtime_error, "unable to unwrap");
             }
         }
 
@@ -183,9 +233,8 @@ namespace xt
             }
         }
 
-        inline void parse_header(std::string header, std::string& descr,
-                                 bool* fortran_order,
-                                 std::vector<std::size_t>& shape)
+        inline void
+        parse_header(std::string header, std::string& descr, bool* fortran_order, std::vector<std::size_t>& shape)
         {
             // The first 6 bytes are a magic string: exactly "x93NUMPY".
             //
@@ -194,7 +243,7 @@ namespace xt
             //
             // The next 1 byte is an unsigned byte: the minor version number of the file
             // format, e.g. x00. Note: the version of the file format is not tied to the
-            // version of the numpy package.
+            // version of the NumPy package.
             //
             // The next 2 bytes form a little-endian unsigned short int: the length of the
             // header data HEADER_LEN.
@@ -222,7 +271,7 @@ namespace xt
             // remove trailing newline
             if (header.back() != '\n')
             {
-                throw std::runtime_error("invalid header");
+                XTENSOR_THROW(std::runtime_error, "invalid header");
             }
             header.pop_back();
 
@@ -240,15 +289,15 @@ namespace xt
             // make sure all the keys are present
             if (keypos_descr == std::string::npos)
             {
-                throw std::runtime_error("missing 'descr' key");
+                XTENSOR_THROW(std::runtime_error, "missing 'descr' key");
             }
             if (keypos_fortran == std::string::npos)
             {
-                throw std::runtime_error("missing 'fortran_order' key");
+                XTENSOR_THROW(std::runtime_error, "missing 'fortran_order' key");
             }
             if (keypos_shape == std::string::npos)
             {
-                throw std::runtime_error("missing 'shape' key");
+                XTENSOR_THROW(std::runtime_error, "missing 'shape' key");
             }
 
             // Make sure the keys are in order.
@@ -257,7 +306,7 @@ namespace xt
             // TODO: fix
             if (keypos_descr >= keypos_fortran || keypos_fortran >= keypos_shape)
             {
-                throw std::runtime_error("header keys in wrong order");
+                XTENSOR_THROW(std::runtime_error, "header keys in wrong order");
             }
 
             // get the 3 key-value pairs
@@ -292,7 +341,7 @@ namespace xt
             }
             else
             {
-                throw std::runtime_error("invalid fortran_order value");
+                XTENSOR_THROW(std::runtime_error, "invalid fortran_order value");
             }
 
             // parse the shape Python tuple ( x, y, z,)
@@ -317,13 +366,11 @@ namespace xt
                     dim_s = shape_s.substr(pos);
                 }
 
-                pop_char(dim_s, ',');
-
                 if (dim_s.length() == 0)
                 {
                     if (pos_next != std::string::npos)
                     {
-                        throw std::runtime_error("invalid shape");
+                        XTENSOR_THROW(std::runtime_error, "invalid shape");
                     }
                 }
                 else
@@ -347,8 +394,7 @@ namespace xt
         }
 
         template <class O, class S>
-        inline void write_header(O& out, const std::string& descr,
-                                 bool fortran_order, const S& shape)
+        inline void write_header(O& out, const std::string& descr, bool fortran_order, const S& shape)
         {
             std::ostringstream ss_header;
             std::string s_fortran_order;
@@ -369,18 +415,17 @@ namespace xt
                 ss_shape << *shape_it << ", ";
             }
             s_shape = ss_shape.str();
-            if (xtl::sequence_size(shape) > 1)
+            if (std::size(shape) > 1)
             {
                 s_shape = s_shape.erase(s_shape.size() - 2);
             }
-            else if (xtl::sequence_size(shape) == 1)
+            else if (std::size(shape) == 1)
             {
                 s_shape = s_shape.erase(s_shape.size() - 1);
             }
             s_shape += ")";
 
-            ss_header << "{'descr': '" << descr
-                      << "', 'fortran_order': " << s_fortran_order
+            ss_header << "{'descr': '" << descr << "', 'fortran_order': " << s_fortran_order
                       << ", 'shape': " << s_shape << ", }";
 
             std::size_t header_len_pre = ss_header.str().length() + 1;
@@ -393,7 +438,7 @@ namespace xt
                 version[0] = 2;
                 version[1] = 0;
             }
-            std::size_t padding_len = 16 - metadata_len % 16;
+            std::size_t padding_len = 64 - (metadata_len % 64);
             std::string padding(padding_len, ' ');
             ss_header << padding;
             ss_header << std::endl;
@@ -434,17 +479,18 @@ namespace xt
             char header_len_le16[2];
             istream.read(header_len_le16, 2);
 
-            uint16_t header_length = uint16_t(header_len_le16[0] << 0) | uint16_t(header_len_le16[1] << 8);
+            uint16_t header_b0 = static_cast<uint16_t>(static_cast<uint8_t>(header_len_le16[0]));
+            uint16_t header_b1 = static_cast<uint16_t>(static_cast<uint8_t>(header_len_le16[1])) << 8;
+            uint16_t header_length = header_b0 | header_b1;
 
             if ((magic_string_length + 2 + 2 + header_length) % 16 != 0)
             {
                 // TODO: display warning
             }
 
-            char* buf = new char[header_length];
-            istream.read(buf, header_length);
-            std::string header(buf, header_length);
-            delete[] buf;
+            std::unique_ptr<char[]> buf(new char[header_length]);
+            istream.read(buf.get(), header_length);
+            std::string header(buf.get(), header_length);
 
             return header;
         }
@@ -455,18 +501,20 @@ namespace xt
             char header_len_le32[4];
             istream.read(header_len_le32, 4);
 
-            uint32_t header_length = uint32_t(header_len_le32[0] << 0) | uint32_t(header_len_le32[1] << 8) |
-                uint32_t(header_len_le32[2] << 16) | uint32_t(header_len_le32[3] << 24);
+            uint32_t header_b0 = static_cast<uint32_t>(static_cast<uint8_t>(header_len_le32[0]));
+            uint32_t header_b1 = static_cast<uint32_t>(static_cast<uint8_t>(header_len_le32[1])) << 8;
+            uint32_t header_b2 = static_cast<uint32_t>(static_cast<uint8_t>(header_len_le32[2])) << 16;
+            uint32_t header_b3 = static_cast<uint32_t>(static_cast<uint8_t>(header_len_le32[3])) << 24;
+            uint32_t header_length = header_b0 | header_b1 | header_b2 | header_b3;
 
             if ((magic_string_length + 2 + 4 + header_length) % 16 != 0)
             {
                 // TODO: display warning
             }
 
-            char* buf = new char[header_length];
-            istream.read(buf, header_length);
-            std::string header(buf, header_length);
-            delete[] buf;
+            std::unique_ptr<char[]> buf(new char[header_length]);
+            istream.read(buf.get(), header_length);
+            std::string header(buf.get(), header_length);
 
             return header;
         }
@@ -475,9 +523,10 @@ namespace xt
         {
             npy_file() = default;
 
-            npy_file(std::vector<std::size_t>& shape, bool fortran_order,
-                     std::string typestring)
-                : m_shape(shape), m_fortran_order(fortran_order), m_typestring(typestring)
+            npy_file(std::vector<std::size_t>& shape, bool fortran_order, std::string typestring)
+                : m_shape(shape)
+                , m_fortran_order(fortran_order)
+                , m_typestring(typestring)
             {
                 // Allocate memory
                 m_word_size = std::size_t(atoi(&typestring[2]));
@@ -489,22 +538,22 @@ namespace xt
             {
                 if (m_buffer != nullptr)
                 {
-                    delete m_buffer;
+                    std::allocator<char>{}.deallocate(m_buffer, m_n_bytes);
                 }
             }
 
             // delete copy constructor
             npy_file(const npy_file&) = delete;
-            npy_file& operator=(npy_file) = delete;
+            npy_file& operator=(const npy_file&) = delete;
 
             // implement move constructor and assignment
             npy_file(npy_file&& rhs)
-                : m_shape(std::move(rhs.m_shape)),
-                  m_fortran_order(std::move(rhs.m_fortran_order)),
-                  m_word_size(std::move(rhs.m_word_size)),
-                  m_n_bytes(std::move(rhs.m_n_bytes)),
-                  m_typestring(std::move(rhs.m_typestring)),
-                  m_buffer(rhs.m_buffer)
+                : m_shape(std::move(rhs.m_shape))
+                , m_fortran_order(std::move(rhs.m_fortran_order))
+                , m_word_size(std::move(rhs.m_word_size))
+                , m_n_bytes(std::move(rhs.m_n_bytes))
+                , m_typestring(std::move(rhs.m_typestring))
+                , m_buffer(rhs.m_buffer)
             {
                 rhs.m_buffer = nullptr;
             }
@@ -529,7 +578,7 @@ namespace xt
             {
                 if (m_buffer == nullptr)
                 {
-                    throw std::runtime_error("This npy_file has already been cast.");
+                    XTENSOR_THROW(std::runtime_error, "This npy_file has already been cast.");
                 }
                 T* ptr = reinterpret_cast<T*>(&m_buffer[0]);
                 std::vector<std::size_t> strides(m_shape.size());
@@ -538,19 +587,27 @@ namespace xt
                 // check if the typestring matches the given one
                 if (check_type && m_typestring != detail::build_typestring<T>())
                 {
-                    throw std::runtime_error("Cast error: formats not matching "s + m_typestring +
-                                             " vs "s + detail::build_typestring<T>());
+                    XTENSOR_THROW(
+                        std::runtime_error,
+                        "Cast error: formats not matching "s + m_typestring + " vs "s
+                            + detail::build_typestring<T>()
+                    );
                 }
 
-                if ((L == layout_type::column_major && !m_fortran_order) ||
-                    (L == layout_type::row_major && m_fortran_order))
+                if ((L == layout_type::column_major && !m_fortran_order)
+                    || (L == layout_type::row_major && m_fortran_order))
                 {
-                    throw std::runtime_error("Cast error: layout mismatch between npy file and requested layout.");
+                    XTENSOR_THROW(
+                        std::runtime_error,
+                        "Cast error: layout mismatch between npy file and requested layout."
+                    );
                 }
 
-                compute_strides(m_shape,
-                                m_fortran_order ? layout_type::column_major : layout_type::row_major,
-                                strides);
+                compute_strides(
+                    m_shape,
+                    m_fortran_order ? layout_type::column_major : layout_type::row_major,
+                    strides
+                );
                 std::vector<std::size_t> shape(m_shape);
 
                 return std::make_tuple(ptr, sz, std::move(shape), std::move(strides));
@@ -561,24 +618,39 @@ namespace xt
             {
                 auto cast_elems = cast_impl<T, L>(check_type);
                 m_buffer = nullptr;
-                return adapt(std::move(std::get<0>(cast_elems)), std::get<1>(cast_elems),
-                             acquire_ownership(), std::get<2>(cast_elems), std::get<3>(cast_elems));
+                return adapt(
+                    std::move(std::get<0>(cast_elems)),
+                    std::get<1>(cast_elems),
+                    acquire_ownership(),
+                    std::get<2>(cast_elems),
+                    std::get<3>(cast_elems)
+                );
             }
 
             template <class T, layout_type L = layout_type::dynamic>
-            auto cast(bool check_type = true) const &
+            auto cast(bool check_type = true) const&
             {
                 auto cast_elems = cast_impl<T, L>(check_type);
-                return adapt(std::get<0>(cast_elems), std::get<1>(cast_elems),
-                             no_ownership(), std::get<2>(cast_elems), std::get<3>(cast_elems));
+                return adapt(
+                    std::get<0>(cast_elems),
+                    std::get<1>(cast_elems),
+                    no_ownership(),
+                    std::get<2>(cast_elems),
+                    std::get<3>(cast_elems)
+                );
             }
 
             template <class T, layout_type L = layout_type::dynamic>
             auto cast(bool check_type = true) &
             {
                 auto cast_elems = cast_impl<T, L>(check_type);
-                return adapt(std::get<0>(cast_elems), std::get<1>(cast_elems),
-                             no_ownership(), std::get<2>(cast_elems), std::get<3>(cast_elems));
+                return adapt(
+                    std::get<0>(cast_elems),
+                    std::get<1>(cast_elems),
+                    no_ownership(),
+                    std::get<2>(cast_elems),
+                    std::get<3>(cast_elems)
+                );
             }
 
             char* ptr()
@@ -617,7 +689,7 @@ namespace xt
             }
             else
             {
-                throw std::runtime_error("unsupported file format version");
+                XTENSOR_THROW(std::runtime_error, "unsupported file format version");
             }
 
             // parse header
@@ -651,12 +723,13 @@ namespace xt
             detail::write_header(stream, typestring, fortran_order, shape);
 
             std::size_t size = compute_size(shape);
-            stream.write(reinterpret_cast<const char*>(eval_ex.data()),
-                         std::streamsize((sizeof(value_type) * size)));
+            stream.write(
+                reinterpret_cast<const char*>(eval_ex.data()),
+                std::streamsize((sizeof(value_type) * size))
+            );
         }
     }  // namespace detail
 
-
     /**
      * Save xexpression to NumPy npy format
      *
@@ -669,14 +742,44 @@ namespace xt
         std::ofstream stream(filename, std::ofstream::binary);
         if (!stream)
         {
-            throw std::runtime_error("IO Error: failed to open file: "s + filename);
+            XTENSOR_THROW(std::runtime_error, "IO Error: failed to open file: "s + filename);
         }
 
         detail::dump_npy_stream(stream, e);
     }
 
     /**
-     * Loads a npy file (the numpy storage format)
+     * Save xexpression to NumPy npy format in a string
+     *
+     * @param e the xexpression
+     */
+    template <typename E>
+    inline std::string dump_npy(const xexpression<E>& e)
+    {
+        std::stringstream stream;
+        detail::dump_npy_stream(stream, e);
+        return stream.str();
+    }
+
+    /**
+     * Loads a npy file (the NumPy storage format)
+     *
+     * @param stream An input stream from which to load the file
+     * @tparam T select the type of the npy file (note: currently there is
+     *           no dynamic casting if types do not match)
+     * @tparam L select layout_type::column_major if you stored data in
+     *           Fortran format
+     * @return xarray with contents from npy file
+     */
+    template <typename T, layout_type L = layout_type::dynamic>
+    inline auto load_npy(std::istream& stream)
+    {
+        detail::npy_file file = detail::load_npy_file(stream);
+        return std::move(file).cast<T, L>();
+    }
+
+    /**
+     * Loads a npy file (the NumPy storage format)
      *
      * @param filename The filename or path to the file
      * @tparam T select the type of the npy file (note: currently there is
@@ -691,13 +794,11 @@ namespace xt
         std::ifstream stream(filename, std::ifstream::binary);
         if (!stream)
         {
-            throw std::runtime_error("io error: failed to open a file.");
+            XTENSOR_THROW(std::runtime_error, "io error: failed to open a file.");
         }
-        detail::npy_file file = detail::load_npy_file(stream);
-        return std::move(file).cast<T, L>();
+        return load_npy<T, L>(stream);
     }
 
 }  // namespace xt
 
 #endif
-
diff --git a/include/xtensor/xcomplex.hpp b/include/xtensor/misc/xcomplex.hpp
similarity index 53%
rename from include/xtensor/xcomplex.hpp
rename to include/xtensor/misc/xcomplex.hpp
index 074ec1f5f..c803bb77c 100644
--- a/include/xtensor/xcomplex.hpp
+++ b/include/xtensor/misc/xcomplex.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_COMPLEX_HPP
 #define XTENSOR_COMPLEX_HPP
@@ -14,13 +15,19 @@
 
 #include <xtl/xcomplex.hpp>
 
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xexpression.hpp"
-#include "xtensor/xoffset_view.hpp"
+#include "../core/xexpression.hpp"
+#include "../generators/xbuilder.hpp"
+#include "../views/xoffset_view.hpp"
 
 namespace xt
 {
 
+    /**
+     * @defgroup xt_xcomplex Complex numbers
+     *
+     * Defined in ``xtensor/xcomplex.hpp``
+     */
+
     /******************************
      * real and imag declarations *
      ******************************/
@@ -41,14 +48,14 @@ namespace xt
         struct complex_helper
         {
             template <class E>
-            static inline auto real(E&& e) noexcept
+            inline static auto real(E&& e) noexcept
             {
                 using real_type = typename std::decay_t<E>::value_type::value_type;
                 return xoffset_view<xclosure_t<E>, real_type, 0>(std::forward<E>(e));
             }
 
             template <class E>
-            static inline auto imag(E&& e) noexcept
+            inline static auto imag(E&& e) noexcept
             {
                 using real_type = typename std::decay_t<E>::value_type::value_type;
                 return xoffset_view<xclosure_t<E>, real_type, sizeof(real_type)>(std::forward<E>(e));
@@ -59,13 +66,13 @@ namespace xt
         struct complex_helper<false>
         {
             template <class E>
-            static inline decltype(auto) real(E&& e) noexcept
+            inline static decltype(auto) real(E&& e) noexcept
             {
-                return e;
+                return std::forward<E>(e);
             }
 
             template <class E>
-            static inline auto imag(E&& e) noexcept
+            inline static auto imag(E&& e) noexcept
             {
                 return zeros<typename std::decay_t<E>::value_type>(e.shape());
             }
@@ -75,15 +82,19 @@ namespace xt
         struct complex_expression_helper
         {
             template <class E>
-            static inline auto real(E&& e) noexcept
+            inline static decltype(auto) real(E&& e) noexcept
             {
-                return detail::complex_helper<xtl::is_complex<typename std::decay_t<E>::value_type>::value>::real(e);
+                return detail::complex_helper<xtl::is_complex<typename std::decay_t<E>::value_type>::value>::real(
+                    std::forward<E>(e)
+                );
             }
 
             template <class E>
-            static inline auto imag(E&& e) noexcept
+            inline static decltype(auto) imag(E&& e) noexcept
             {
-                return detail::complex_helper<xtl::is_complex<typename std::decay_t<E>::value_type>::value>::imag(e);
+                return detail::complex_helper<xtl::is_complex<typename std::decay_t<E>::value_type>::value>::imag(
+                    std::forward<E>(e)
+                );
             }
         };
 
@@ -91,13 +102,13 @@ namespace xt
         struct complex_expression_helper<false>
         {
             template <class E>
-            static inline decltype(auto) real(E&& e) noexcept
+            inline static decltype(auto) real(E&& e) noexcept
             {
                 return xtl::forward_real(std::forward<E>(e));
             }
 
             template <class E>
-            static inline decltype(auto) imag(E&& e) noexcept
+            inline static decltype(auto) imag(E&& e) noexcept
             {
                 return xtl::forward_imag(std::forward<E>(e));
             }
@@ -105,72 +116,74 @@ namespace xt
     }
 
     /**
-     * @brief Returns an \ref xexpression representing the real part of the given expression.
+     * Return an xt::xexpression representing the real part of the given expression.
      *
-     * @tparam e the \ref xexpression
+     * The returned expression either hold a const reference to @p e or a copy
+     * depending on whether @p e is an lvalue or an rvalue.
      *
-     * The returned expression either hold a const reference to \p e or a copy
-     * depending on whether \p e is an lvalue or an rvalue.
+     * @ingroup xt_xcomplex
+     * @tparam e The xt::xexpression
      */
     template <class E>
     inline decltype(auto) real(E&& e) noexcept
     {
-        return detail::complex_expression_helper<is_xexpression<std::decay_t<E>>::value>::real(std::forward<E>(e));
+        return detail::complex_expression_helper<is_xexpression<std::decay_t<E>>::value>::real(std::forward<E>(e
+        ));
     }
 
     /**
-     * @brief Returns an \ref xexpression representing the imaginary part of the given expression.
+     * Return an xt::xexpression representing the imaginary part of the given expression.
      *
-     * @tparam e the \ref xexpression
+     * The returned expression either hold a const reference to @p e or a copy
+     * depending on whether @p e is an lvalue or an rvalue.
      *
-     * The returned expression either hold a const reference to \p e or a copy
-     * depending on whether \p e is an lvalue or an rvalue.
+     * @ingroup xt_xcomplex
+     * @tparam e The xt::xexpression
      */
     template <class E>
     inline decltype(auto) imag(E&& e) noexcept
     {
-        return detail::complex_expression_helper<is_xexpression<std::decay_t<E>>::value>::imag(std::forward<E>(e));
+        return detail::complex_expression_helper<is_xexpression<std::decay_t<E>>::value>::imag(std::forward<E>(e
+        ));
     }
 
-#define UNARY_COMPLEX_FUNCTOR(NS, NAME)                             \
-    struct NAME##_fun                                               \
-    {                                                               \
-        template <class T>                                          \
-        constexpr auto operator()(const T& t) const                 \
-        {                                                           \
-            using NS::NAME;                                         \
-            return NAME(t);                                         \
-        }                                                           \
-                                                                    \
-        template <class B>                                          \
-        constexpr auto simd_apply(const B& t) const                 \
-        {                                                           \
-            using NS::NAME;                                         \
-            return NAME(t);                                         \
-        }                                                           \
+#define UNARY_COMPLEX_FUNCTOR(NS, NAME)             \
+    struct NAME##_fun                               \
+    {                                               \
+        template <class T>                          \
+        constexpr auto operator()(const T& t) const \
+        {                                           \
+            using NS::NAME;                         \
+            return NAME(t);                         \
+        }                                           \
+                                                    \
+        template <class B>                          \
+        constexpr auto simd_apply(const B& t) const \
+        {                                           \
+            using NS::NAME;                         \
+            return NAME(t);                         \
+        }                                           \
     }
 
     namespace math
     {
         namespace detail
         {
-            // libc++ (OSX) conj is unfortunately broken and returns
-            // std::complex<T> instead of T.
             template <class T>
-            constexpr T conj_impl(const T& c)
+            constexpr std::complex<T> conj_impl(const std::complex<T>& c)
             {
-                return c;
+                return std::complex<T>(c.real(), -c.imag());
             }
 
             template <class T>
-            constexpr std::complex<T> conj_impl(const std::complex<T>& c)
+            constexpr std::complex<T> conj_impl(const T& real)
             {
-                return std::complex<T>(c.real(), -c.imag());
+                return std::complex<T>(real, 0);
             }
 
 #ifdef XTENSOR_USE_XSIMD
-            template <class X>
-            constexpr X conj_impl(const xsimd::simd_complex_batch<X>& z)
+            template <class T, class A>
+            xsimd::complex_batch_type_t<xsimd::batch<T, A>> conj_impl(const xsimd::batch<T, A>& z)
             {
                 return xsimd::conj(z);
             }
@@ -185,9 +198,10 @@ namespace xt
 #undef UNARY_COMPLEX_FUNCTOR
 
     /**
-     * @brief Returns an \ref xfunction evaluating to the complex conjugate of the given expression.
+     * Return an xt::xfunction evaluating to the complex conjugate of the given expression.
      *
-     * @param e the \ref xexpression
+     * @ingroup xt_xcomplex
+     * @param e the xt::xexpression
      */
     template <class E>
     inline auto conj(E&& e) noexcept
@@ -198,8 +212,10 @@ namespace xt
     }
 
     /**
-     * @brief Calculates the phase angle (in radians) elementwise for the complex numbers in e.
-     * @param e the \ref xexpression
+     * Calculates the phase angle (in radians) elementwise for the complex numbers in @p e.
+     *
+     * @ingroup xt_xcomplex
+     * @param e the xt::xexpression
      */
     template <class E>
     inline auto arg(E&& e) noexcept
@@ -210,9 +226,12 @@ namespace xt
     }
 
     /**
-     * @brief Calculates the phase angle elementwise for the complex numbers in e.
-     * Note that this function might be slightly less perfomant than \ref arg.
-     * @param e the \ref xexpression
+     * Calculates the phase angle elementwise for the complex numbers in @p e.
+     *
+     * Note that this function might be slightly less performant than xt::arg.
+     *
+     * @ingroup xt_xcomplex
+     * @param e the xt::xexpression
      * @param deg calculate angle in degrees instead of radians
      */
     template <class E>
@@ -228,9 +247,11 @@ namespace xt
     }
 
     /**
-     * Calculates the squared magnitude elementwise for the complex numbers in e.
-     * Equivalent to pow(real(e), 2) + pow(imag(e), 2).
-     * @param e the \ref xexpression
+     * Calculates the squared magnitude elementwise for the complex numbers in @p e.
+     *
+     * Equivalent to ``xt::pow(xt::real(e), 2) + xt::pow(xt::imag(e), 2)``.
+     * @ingroup xt_xcomplex
+     * @param e the xt::xexpression
      */
     template <class E>
     inline auto norm(E&& e) noexcept
diff --git a/include/xtensor/xexpression_holder.hpp b/include/xtensor/misc/xexpression_holder.hpp
similarity index 76%
rename from include/xtensor/xexpression_holder.hpp
rename to include/xtensor/misc/xexpression_holder.hpp
index ae6077c2a..f720cc006 100644
--- a/include/xtensor/xexpression_holder.hpp
+++ b/include/xtensor/misc/xexpression_holder.hpp
@@ -1,21 +1,22 @@
 /***************************************************************************
-* Copyright (c) 2017, 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. *
-****************************************************************************/
+ * 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_XEXPRESSION_HOLDER_HPP
 #define XTENSOR_XEXPRESSION_HOLDER_HPP
 
-#include <nlohmann/json.hpp>
+#include <memory>
 
-#include "xtl/xany.hpp"
+#include <nlohmann/json.hpp>
 
-#include "xarray.hpp"
-#include "xjson.hpp"
+#include "../containers/xarray.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../io/xjson.hpp"
 
 namespace xt
 {
@@ -28,13 +29,13 @@ namespace xt
         class xexpression_wrapper;
     }
 
-    class xexpression_holder // Value semantic
+    class xexpression_holder  // Value semantic
     {
     public:
 
         using implementation_type = detail::xexpression_holder_impl;
 
-        xexpression_holder();
+        xexpression_holder() = default;
 
         template <class E>
         xexpression_holder(E&& expr);
@@ -51,26 +52,27 @@ namespace xt
         void to_json(nlohmann::json&) const;
         void from_json(const nlohmann::json&);
 
-        ~xexpression_holder();
-
     private:
 
         void init_pointer_from_json(const nlohmann::json&);
         void check_holder() const;
 
-        implementation_type* p_holder;
+        std::unique_ptr<implementation_type> p_holder;
     };
 
     /*************************************
      * to_json and from_json declaration *
      *************************************/
 
+    /// @cond DOXYGEN_INCLUDE_SFINAE
     void to_json(nlohmann::json& j, const xexpression_holder& o);
     void from_json(const nlohmann::json& j, xexpression_holder& o);
 
+    /// @endcond
+
     namespace detail
     {
-        class xexpression_holder_impl // Entity semantic
+        class xexpression_holder_impl  // Entity semantic
         {
         public:
 
@@ -94,6 +96,7 @@ namespace xt
         class xexpression_wrapper : public xexpression_holder_impl
         {
         public:
+
             template <class E>
             xexpression_wrapper(E&& expr);
 
@@ -114,11 +117,6 @@ namespace xt
         };
     }
 
-    inline xexpression_holder::xexpression_holder()
-        : p_holder(nullptr)
-    {
-    }
-
     template <class E>
     inline xexpression_holder::xexpression_holder(E&& expr)
         : p_holder(new detail::xexpression_wrapper<E>(std::forward<E>(expr)))
@@ -136,9 +134,8 @@ namespace xt
     }
 
     inline xexpression_holder::xexpression_holder(xexpression_holder&& holder)
-        : p_holder(holder.p_holder)
+        : p_holder(std::move(holder.p_holder))
     {
-        holder.p_holder = nullptr;
     }
 
     inline xexpression_holder& xexpression_holder::operator=(const xexpression_holder& holder)
@@ -172,7 +169,7 @@ namespace xt
     {
         if (!j.is_array())
         {
-            throw std::runtime_error("Received a JSON that does not contain a tensor");
+            XTENSOR_THROW(std::runtime_error, "Received a JSON that does not contain a tensor");
         }
 
         if (p_holder == nullptr)
@@ -192,41 +189,37 @@ namespace xt
         if (j.is_number())
         {
             xt::xarray<double> empty_arr;
-            p_holder = new detail::xexpression_wrapper<xt::xarray<double>>(std::move(empty_arr));
+            p_holder.reset(new detail::xexpression_wrapper<xt::xarray<double>>(std::move(empty_arr)));
         }
 
         if (j.is_boolean())
         {
             xt::xarray<bool> empty_arr;
-            p_holder = new detail::xexpression_wrapper<xt::xarray<bool>>(std::move(empty_arr));
+            p_holder.reset(new detail::xexpression_wrapper<xt::xarray<bool>>(std::move(empty_arr)));
         }
 
         if (j.is_string())
         {
             xt::xarray<std::string> empty_arr;
-            p_holder = new detail::xexpression_wrapper<xt::xarray<std::string>>(std::move(empty_arr));
+            p_holder.reset(new detail::xexpression_wrapper<xt::xarray<std::string>>(std::move(empty_arr)));
         }
 
-        throw std::runtime_error("Received a JSON with a tensor that contains unsupported data type");
+        XTENSOR_THROW(std::runtime_error, "Received a JSON with a tensor that contains unsupported data type");
     }
 
     inline void xexpression_holder::check_holder() const
     {
         if (p_holder == nullptr)
         {
-            throw std::runtime_error("The holder does not contain an expression");
+            XTENSOR_THROW(std::runtime_error, "The holder does not contain an expression");
         }
     }
 
-    inline xexpression_holder::~xexpression_holder()
-    {
-        delete p_holder;
-    }
-
     /****************************************
      * to_json and from_json implementation *
      ****************************************/
 
+    /// @cond DOXYGEN_INCLUDE_SFINAE
     inline void to_json(nlohmann::json& j, const xexpression_holder& o)
     {
         o.to_json(j);
@@ -237,13 +230,15 @@ namespace xt
         o.from_json(j);
     }
 
+    /// @endcond
+
     namespace detail
     {
         template <class CTE>
         template <class E>
         inline xexpression_wrapper<CTE>::xexpression_wrapper(E&& expr)
-            : xexpression_holder_impl(),
-              m_expression(std::forward<E>(expr))
+            : xexpression_holder_impl()
+            , m_expression(std::forward<E>(expr))
         {
         }
 
@@ -267,8 +262,8 @@ namespace xt
 
         template <class CTE>
         inline xexpression_wrapper<CTE>::xexpression_wrapper(const xexpression_wrapper& wrapper)
-            : xexpression_holder_impl(),
-              m_expression(wrapper.m_expression)
+            : xexpression_holder_impl()
+            , m_expression(wrapper.m_expression)
         {
         }
     }
diff --git a/include/xtensor/misc/xfft.hpp b/include/xtensor/misc/xfft.hpp
new file mode 100644
index 000000000..caf37145e
--- /dev/null
+++ b/include/xtensor/misc/xfft.hpp
@@ -0,0 +1,235 @@
+#ifdef XTENSOR_USE_TBB
+#include <oneapi/tbb.h>
+#endif
+#include <stdexcept>
+
+#include <xtl/xcomplex.hpp>
+
+#include "../containers/xarray.hpp"
+#include "../core/xmath.hpp"
+#include "../core/xnoalias.hpp"
+#include "../generators/xbuilder.hpp"
+#include "../misc/xcomplex.hpp"
+#include "../views/xaxis_slice_iterator.hpp"
+#include "../views/xview.hpp"
+#include "./xtl_concepts.hpp"
+
+namespace xt
+{
+    namespace fft
+    {
+        namespace detail
+        {
+            template <xtl::complex_concept E>
+            inline auto radix2(E&& e)
+            {
+                using namespace xt::placeholders;
+                using namespace std::complex_literals;
+                using value_type = typename std::decay_t<E>::value_type;
+                using precision = typename value_type::value_type;
+                auto N = e.size();
+                const bool powerOfTwo = !(N == 0) && !(N & (N - 1));
+                // check for power of 2
+                if (!powerOfTwo || N == 0)
+                {
+                    // TODO: Replace implementation with dft
+                    XTENSOR_THROW(std::runtime_error, "FFT Implementation requires power of 2");
+                }
+                auto pi = xt::numeric_constants<precision>::PI;
+                xt::xtensor<value_type, 1> ev = e;
+                if (N <= 1)
+                {
+                    return ev;
+                }
+                else
+                {
+#ifdef XTENSOR_USE_TBB
+                    xt::xtensor<value_type, 1> even;
+                    xt::xtensor<value_type, 1> odd;
+                    oneapi::tbb::parallel_invoke(
+                        [&]
+                        {
+                            even = radix2(xt::view(ev, xt::range(0, _, 2)));
+                        },
+                        [&]
+                        {
+                            odd = radix2(xt::view(ev, xt::range(1, _, 2)));
+                        }
+                    );
+#else
+                    auto even = radix2(xt::view(ev, xt::range(0, _, 2)));
+                    auto odd = radix2(xt::view(ev, xt::range(1, _, 2)));
+#endif
+
+                    auto range = xt::arange<double>(static_cast<double>(N) / 2);
+                    auto exp = xt::exp(static_cast<value_type>(-2i) * pi * range / N);
+                    auto t = exp * odd;
+                    auto first_half = even + t;
+                    auto second_half = even - t;
+                    // TODO: should be a call to stack if performance was improved
+                    auto spectrum = xt::xtensor<value_type, 1>::from_shape({N});
+                    xt::view(spectrum, xt::range(0, N / 2)) = first_half;
+                    xt::view(spectrum, xt::range(N / 2, N)) = second_half;
+                    return spectrum;
+                }
+            }
+
+            template <typename E>
+            auto transform_bluestein(E&& data)
+            {
+                using value_type = typename std::decay_t<E>::value_type;
+                using precision = typename value_type::value_type;
+
+                // Find a power-of-2 convolution length m such that m >= n * 2 + 1
+                const std::size_t n = data.size();
+                size_t m = static_cast<size_t>(std::ceil(std::log2(n * 2 + 1)));
+                m = static_cast<size_t>(std::pow(2, m));
+
+                // Trignometric table
+                auto exp_table = xt::xtensor<std::complex<precision>, 1>::from_shape({n});
+                xt::xtensor<std::size_t, 1> i = xt::pow(xt::linspace<std::size_t>(0, n - 1, n), 2);
+                i %= (n * 2);
+
+                auto angles = xt::eval(precision{3.141592653589793238463} * i / n);
+                auto j = std::complex<precision>(0, 1);
+                exp_table = xt::exp(-angles * j);
+
+                // Temporary vectors and preprocessing
+                auto av = xt::empty<std::complex<precision>>({m});
+                xt::view(av, xt::range(0, n)) = data * exp_table;
+
+
+                auto bv = xt::empty<std::complex<precision>>({m});
+                xt::view(bv, xt::range(0, n)) = ::xt::conj(exp_table);
+                xt::view(bv, xt::range(-n + 1, xt::placeholders::_)) = xt::view(
+                    ::xt::conj(xt::flip(exp_table)),
+                    xt::range(xt::placeholders::_, -1)
+                );
+
+                // Convolution
+                auto xv = radix2(av);
+                auto yv = radix2(bv);
+                auto spectrum_k = xv * yv;
+                auto complex_args = xt::conj(spectrum_k);
+                auto fft_res = radix2(complex_args);
+                auto cv = xt::conj(fft_res) / m;
+
+                return xt::eval(xt::view(cv, xt::range(0, n)) * exp_table);
+            }
+        }  // namespace detail
+
+        /**
+         * @brief 1D FFT of an Nd array along a specified axis
+         * @param e an Nd expression to be transformed to the fourier domain
+         * @param axis the axis along which to perform the 1D FFT
+         * @return a transformed xarray of the specified precision
+         */
+        template <class E>
+        inline auto fft(E&& e, std::ptrdiff_t axis = -1)
+        {
+            using value_type = typename std::decay<E>::type::value_type;
+            if (e.dimension() == 0)
+            {
+                XTENSOR_THROW(std::runtime_error, "Cannot take the FFT of a scalar expression");
+            }
+            if constexpr (xtl::is_complex<typename std::decay<E>::type::value_type>::value)
+            {
+                using precision = typename value_type::value_type;
+                const auto saxis = xt::normalize_axis(e.dimension(), axis);
+                const size_t N = e.shape(saxis);
+                const bool powerOfTwo = !(N == 0) && !(N & (N - 1));
+                xt::xarray<std::complex<precision>> out = xt::eval(e);
+                auto begin = xt::axis_slice_begin(out, saxis);
+                auto end = xt::axis_slice_end(out, saxis);
+                for (auto iter = begin; iter != end; iter++)
+                {
+                    if (powerOfTwo)
+                    {
+                        xt::noalias(*iter) = detail::radix2(*iter);
+                    }
+                    else
+                    {
+                        xt::noalias(*iter) = detail::transform_bluestein(*iter);
+                    }
+                }
+                return out;
+            }
+            else
+            {
+                return fft(xt::cast<std::complex<value_type>>(e), axis);
+            }
+        }
+
+        template <class E>
+        inline auto ifft(E&& e, std::ptrdiff_t axis = -1)
+        {
+            if (e.dimension() == 0)
+            {
+                XTENSOR_THROW(std::runtime_error, "Cannot take the iFFT of a scalar expression");
+            }
+            if constexpr (xtl::is_complex<typename std::decay<E>::type::value_type>::value)
+            {
+                // check the length of the data on that axis
+                const std::size_t n = e.shape(xt::normalize_axis(e.dimension(), axis));
+                if (n == 0)
+                {
+                    XTENSOR_THROW(std::runtime_error, "Cannot take the iFFT along an empty dimention");
+                }
+                auto complex_args = xt::conj(e);
+                auto fft_res = xt::fft::fft(complex_args, axis);
+                fft_res = xt::conj(fft_res);
+                return fft_res;
+            }
+            else
+            {
+                using value_type = typename std::decay<E>::type::value_type;
+                return ifft(xt::cast<std::complex<value_type>>(e), axis);
+            }
+        }
+
+        /*
+         * @brief performs a circular fft convolution xvec and yvec must
+         *        be the same shape.
+         * @param xvec first array of the convolution
+         * @param yvec second array of the convolution
+         * @param axis axis along which to perform the convolution
+         */
+        template <typename E1, typename E2>
+        auto convolve(E1&& xvec, E2&& yvec, std::ptrdiff_t axis = -1)
+        {
+            // we could broadcast but that could get complicated???
+            if (xvec.dimension() != yvec.dimension())
+            {
+                XTENSOR_THROW(std::runtime_error, "Mismatched dimentions");
+            }
+
+            auto saxis = xt::normalize_axis(xvec.dimension(), axis);
+            if (xvec.shape(saxis) != yvec.shape(saxis))
+            {
+                XTENSOR_THROW(std::runtime_error, "Mismatched lengths along slice axis");
+            }
+
+            const std::size_t n = xvec.shape(saxis);
+
+            auto xv = fft(xvec, axis);
+            auto yv = fft(yvec, axis);
+
+            auto begin_x = xt::axis_slice_begin(xv, saxis);
+            auto end_x = xt::axis_slice_end(xv, saxis);
+            auto iter_y = xt::axis_slice_begin(yv, saxis);
+
+            for (auto iter = begin_x; iter != end_x; iter++)
+            {
+                (*iter) = (*iter_y++) * (*iter);
+            }
+
+            auto outvec = ifft(xv, axis);
+
+            // Scaling (because this FFT implementation omits it)
+            outvec = outvec / n;
+
+            return outvec;
+        }
+
+    }
+}  // namespace xt::fft
diff --git a/include/xtensor/misc/xhistogram.hpp b/include/xtensor/misc/xhistogram.hpp
new file mode 100644
index 000000000..a389c4fb9
--- /dev/null
+++ b/include/xtensor/misc/xhistogram.hpp
@@ -0,0 +1,624 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+/**
+ * @brief construct histogram
+ */
+
+#ifndef XTENSOR_HISTOGRAM_HPP
+#define XTENSOR_HISTOGRAM_HPP
+
+#include "../containers/xtensor.hpp"
+#include "../misc/xset_operation.hpp"
+#include "../misc/xsort.hpp"
+#include "../views/xview.hpp"
+
+using namespace xt::placeholders;
+
+namespace xt
+{
+    /**
+     * @defgroup digitize Digitize helpers
+     * @brief Helpers for assigning values to histogram bins.
+     */
+
+    /**
+     * @ingroup digitize
+     * @brief Return the indices of the bins to which each value in input array belongs.
+     *
+     * @param data The data.
+     * @param bin_edges The bin-edges. It has to be 1-dimensional and monotonic.
+     * @param right Indicating whether the intervals include the right or the left bin edge.
+     * @return Output array of indices, of same shape as x.
+     */
+    template <class E1, class E2>
+    inline auto digitize(E1&& data, E2&& bin_edges, bool right = false)
+    {
+        XTENSOR_ASSERT(bin_edges.dimension() == 1);
+        XTENSOR_ASSERT(bin_edges.size() >= 2);
+        XTENSOR_ASSERT(std::is_sorted(bin_edges.cbegin(), bin_edges.cend()));
+        XTENSOR_ASSERT(xt::amin(data)[0] >= bin_edges[0]);
+        XTENSOR_ASSERT(xt::amax(data)[0] <= bin_edges[bin_edges.size() - 1]);
+
+        return xt::searchsorted(std::forward<E2>(bin_edges), std::forward<E1>(data), right);
+    }
+
+    namespace detail
+    {
+        template <class R = double, class E1, class E2, class E3>
+        inline auto histogram_imp(E1&& data, E2&& bin_edges, E3&& weights, bool density, bool equal_bins)
+        {
+            using size_type = common_size_type_t<std::decay_t<E1>, std::decay_t<E2>, std::decay_t<E3>>;
+            using value_type = typename std::decay_t<E3>::value_type;
+
+            XTENSOR_ASSERT(data.dimension() == 1);
+            XTENSOR_ASSERT(weights.dimension() == 1);
+            XTENSOR_ASSERT(bin_edges.dimension() == 1);
+            XTENSOR_ASSERT(weights.size() == data.size());
+            XTENSOR_ASSERT(bin_edges.size() >= 2);
+            XTENSOR_ASSERT(std::is_sorted(bin_edges.cbegin(), bin_edges.cend()));
+
+            size_t n_bins = bin_edges.size() - 1;
+            xt::xtensor<value_type, 1> count = xt::zeros<value_type>({n_bins});
+
+            if (equal_bins)
+            {
+                std::array<typename std::decay_t<E2>::value_type, 2> bounds = xt::minmax(bin_edges)();
+                auto left = static_cast<double>(bounds[0]);
+                auto right = static_cast<double>(bounds[1]);
+                double norm = 1. / (right - left);
+                for (size_t i = 0; i < data.size(); ++i)
+                {
+                    auto v = static_cast<double>(data(i));
+                    // left and right are not bounds of data
+                    if (v >= left && v < right)
+                    {
+                        auto i_bin = static_cast<size_t>(static_cast<double>(n_bins) * (v - left) * norm);
+                        count(i_bin) += weights(i);
+                    }
+                    else if (v == right)
+                    {
+                        count(n_bins - 1) += weights(i);
+                    }
+                }
+            }
+            else
+            {
+                auto sorter = xt::argsort(data);
+
+                size_type ibin = 0;
+
+                for (auto& idx : sorter)
+                {
+                    auto item = data[idx];
+
+                    if (item < bin_edges[0])
+                    {
+                        continue;
+                    }
+
+                    if (item > bin_edges[n_bins])
+                    {
+                        break;
+                    }
+
+                    while (item >= bin_edges[ibin + 1] && ibin < n_bins - 1)
+                    {
+                        ++ibin;
+                    }
+
+                    count[ibin] += weights[idx];
+                }
+            }
+
+            xt::xtensor<R, 1> prob = xt::cast<R>(count);
+
+            if (density)
+            {
+                R n = static_cast<R>(data.size());
+                for (size_type i = 0; i < bin_edges.size() - 1; ++i)
+                {
+                    prob[i] /= (static_cast<R>(bin_edges[i + 1] - bin_edges[i]) * n);
+                }
+            }
+
+            return prob;
+        }
+
+    }  // detail
+
+    /**
+     * @defgroup histogram Histogram functions
+     * @brief Helpers for computing histograms and histogram bin edges.
+     */
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the histogram of a set of data.
+     *
+     * @param data The data.
+     * @param bin_edges The bin-edges. It has to be 1-dimensional and monotonic.
+     * @param weights Weight factors corresponding to each data-point.
+     * @param density If true the resulting integral is normalized to 1. [default: false]
+     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
+     */
+    template <class R = double, class E1, class E2, class E3>
+    inline auto histogram(E1&& data, E2&& bin_edges, E3&& weights, bool density = false)
+    {
+        return detail::histogram_imp<R>(
+            std::forward<E1>(data),
+            std::forward<E2>(bin_edges),
+            std::forward<E3>(weights),
+            density,
+            false
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the histogram of a set of data.
+     *
+     * @param data The data.
+     * @param bin_edges The bin-edges.
+     * @param density If true the resulting integral is normalized to 1. [default: false]
+     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
+     */
+    template <class R = double, class E1, class E2>
+    inline auto histogram(E1&& data, E2&& bin_edges, bool density = false)
+    {
+        using value_type = typename std::decay_t<E1>::value_type;
+
+        auto n = data.size();
+
+        return detail::histogram_imp<R>(
+            std::forward<E1>(data),
+            std::forward<E2>(bin_edges),
+            xt::ones<value_type>({n}),
+            density,
+            false
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the histogram of a set of data.
+     *
+     * @param data The data.
+     * @param bins The number of bins. [default: 10]
+     * @param density If true the resulting integral is normalized to 1. [default: false]
+     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
+     */
+    template <class R = double, class E1>
+    inline auto histogram(E1&& data, std::size_t bins = 10, bool density = false)
+    {
+        using value_type = typename std::decay_t<E1>::value_type;
+
+        auto n = data.size();
+
+        return detail::histogram_imp<R>(
+            std::forward<E1>(data),
+            histogram_bin_edges(data, xt::ones<value_type>({n}), bins),
+            xt::ones<value_type>({n}),
+            density,
+            true
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the histogram of a set of data.
+     *
+     * @param data The data.
+     * @param bins The number of bins.
+     * @param left The lower-most edge.
+     * @param right The upper-most edge.
+     * @param density If true the resulting integral is normalized to 1. [default: false]
+     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
+     */
+    template <class R = double, class E1, class E2>
+    inline auto histogram(E1&& data, std::size_t bins, E2 left, E2 right, bool density = false)
+    {
+        using value_type = typename std::decay_t<E1>::value_type;
+
+        auto n = data.size();
+
+        return detail::histogram_imp<R>(
+            std::forward<E1>(data),
+            histogram_bin_edges(data, left, right, bins),
+            xt::ones<value_type>({n}),
+            density,
+            true
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the histogram of a set of data.
+     *
+     * @param data The data.
+     * @param bins The number of bins.
+     * @param weights Weight factors corresponding to each data-point.
+     * @param density If true the resulting integral is normalized to 1. [default: false]
+     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
+     */
+    template <class R = double, class E1, class E2>
+    inline auto histogram(E1&& data, std::size_t bins, E2&& weights, bool density = false)
+    {
+        return detail::histogram_imp<R>(
+            std::forward<E1>(data),
+            histogram_bin_edges(data, weights, bins),
+            std::forward<E2>(weights),
+            density,
+            true
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the histogram of a set of data.
+     *
+     * @param data The data.
+     * @param bins The number of bins.
+     * @param left The lower-most edge.
+     * @param right The upper-most edge.
+     * @param weights Weight factors corresponding to each data-point.
+     * @param density If true the resulting integral is normalized to 1. [default: false]
+     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
+     */
+    template <class R = double, class E1, class E2, class E3>
+    inline auto histogram(E1&& data, std::size_t bins, E2&& weights, E3 left, E3 right, bool density = false)
+    {
+        return detail::histogram_imp<R>(
+            std::forward<E1>(data),
+            histogram_bin_edges(data, weights, left, right, bins),
+            std::forward<E2>(weights),
+            density,
+            true
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Defines different algorithms to be used in "histogram_bin_edges"
+     */
+    enum class histogram_algorithm
+    {
+        automatic,
+        linspace,
+        logspace,
+        uniform
+    };
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
+     *
+     * @param data The data.
+     * @param weights Weight factors corresponding to each data-point.
+     * @param left The lower-most edge.
+     * @param right The upper-most edge.
+     * @param bins The number of bins. [default: 10]
+     * @param mode The type of algorithm to use. [default: "auto"]
+     * @return An one-dimensional xarray<double>, length: bins+1.
+     */
+    template <class E1, class E2, class E3>
+    inline auto histogram_bin_edges(
+        E1&& data,
+        E2&& weights,
+        E3 left,
+        E3 right,
+        std::size_t bins = 10,
+        histogram_algorithm mode = histogram_algorithm::automatic
+    )
+    {
+        // counter and return type
+        using size_type = common_size_type_t<std::decay_t<E1>, std::decay_t<E2>>;
+        using value_type = typename std::decay_t<E1>::value_type;
+        using weights_type = typename std::decay_t<E2>::value_type;
+
+        // basic checks
+        // - rank
+        XTENSOR_ASSERT(data.dimension() == 1);
+        XTENSOR_ASSERT(weights.dimension() == 1);
+        // - size
+        XTENSOR_ASSERT(weights.size() == data.size());
+        // - bounds
+        XTENSOR_ASSERT(left <= right);
+        // - non-empty
+        XTENSOR_ASSERT(bins > std::size_t(0));
+
+        // act on different modes
+        switch (mode)
+        {
+            // bins of equal width
+            case histogram_algorithm::automatic:
+            {
+                xt::xtensor<value_type, 1> bin_edges = xt::linspace<value_type>(left, right, bins + 1);
+                return bin_edges;
+            }
+
+            // bins of equal width
+            case histogram_algorithm::linspace:
+            {
+                xt::xtensor<value_type, 1> bin_edges = xt::linspace<value_type>(left, right, bins + 1);
+                return bin_edges;
+            }
+
+            // bins of logarithmically increasing size
+            case histogram_algorithm::logspace:
+            {
+                using rhs_value_type = std::conditional_t<xtl::is_integral<value_type>::value, double, value_type>;
+
+                xtensor<value_type, 1> bin_edges = xt::cast<value_type>(
+                    xt::logspace<rhs_value_type>(std::log10(left), std::log10(right), bins + 1)
+                );
+
+                // TODO: replace above with below after 'xsimd' fix
+                // xt::xtensor<value_type,1> bin_edges = xt::logspace<value_type>(
+                //     std::log10(left), std::log10(right), bins+1);
+
+                return bin_edges;
+            }
+
+            // same amount of data in each bin
+            case histogram_algorithm::uniform:
+            {
+                // indices that sort "data"
+                auto sorter = xt::argsort(data);
+
+                // histogram: all of equal 'height'
+                // - height
+                weights_type w = xt::sum<weights_type>(weights)[0] / static_cast<weights_type>(bins);
+                // - apply to all bins
+                xt::xtensor<weights_type, 1> count = w * xt::ones<weights_type>({bins});
+
+                // take cumulative sum, to act as easy look-up
+                count = xt::cumsum(count);
+
+                // edges
+                // - allocate
+                std::vector<size_t> shape = {bins + 1};
+                xt::xtensor<value_type, 1> bin_edges = xtensor<value_type, 1>::from_shape(shape);
+                // - first/last edge
+                bin_edges[0] = left;
+                bin_edges[bins] = right;
+                // - cumulative weight
+                weights_type cum_weight = static_cast<weights_type>(0);
+                // - current bin
+                size_type ibin = 0;
+                // - loop to find interior bin-edges
+                for (size_type i = 0; i < weights.size(); ++i)
+                {
+                    if (cum_weight >= count[ibin])
+                    {
+                        bin_edges[ibin + 1] = data[sorter[i]];
+                        ++ibin;
+                    }
+                    cum_weight += weights[sorter[i]];
+                }
+                return bin_edges;
+            }
+
+            // bins of equal width
+            default:
+            {
+                xt::xtensor<value_type, 1> bin_edges = xt::linspace<value_type>(left, right, bins + 1);
+                return bin_edges;
+            }
+        }
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
+     *
+     * @param data The data.
+     * @param weights Weight factors corresponding to each data-point.
+     * @param bins The number of bins. [default: 10]
+     * @param mode The type of algorithm to use. [default: "auto"]
+     * @return An one-dimensional xarray<double>, length: bins+1.
+     */
+    template <class E1, class E2>
+    inline auto histogram_bin_edges(
+        E1&& data,
+        E2&& weights,
+        std::size_t bins = 10,
+        histogram_algorithm mode = histogram_algorithm::automatic
+    )
+    {
+        using value_type = typename std::decay_t<E1>::value_type;
+        std::array<value_type, 2> left_right;
+        left_right = xt::minmax(data)();
+
+        return histogram_bin_edges(
+            std::forward<E1>(data),
+            std::forward<E2>(weights),
+            left_right[0],
+            left_right[1],
+            bins,
+            mode
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
+     *
+     * @param data The data.
+     * @param bins The number of bins. [default: 10]
+     * @param mode The type of algorithm to use. [default: "auto"]
+     * @return An one-dimensional xarray<double>, length: bins+1.
+     */
+    template <class E1>
+    inline auto
+    histogram_bin_edges(E1&& data, std::size_t bins = 10, histogram_algorithm mode = histogram_algorithm::automatic)
+    {
+        using value_type = typename std::decay_t<E1>::value_type;
+
+        auto n = data.size();
+        std::array<value_type, 2> left_right;
+        left_right = xt::minmax(data)();
+
+        return histogram_bin_edges(
+            std::forward<E1>(data),
+            xt::ones<value_type>({n}),
+            left_right[0],
+            left_right[1],
+            bins,
+            mode
+        );
+    }
+
+    /**
+     * @ingroup histogram
+     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
+     *
+     * @param data The data.
+     * @param left The lower-most edge.
+     * @param right The upper-most edge.
+     * @param bins The number of bins. [default: 10]
+     * @param mode The type of algorithm to use. [default: "auto"]
+     * @return An one-dimensional xarray<double>, length: bins+1.
+     */
+    template <class E1, class E2>
+    inline auto histogram_bin_edges(
+        E1&& data,
+        E2 left,
+        E2 right,
+        std::size_t bins = 10,
+        histogram_algorithm mode = histogram_algorithm::automatic
+    )
+    {
+        using value_type = typename std::decay_t<E1>::value_type;
+
+        auto n = data.size();
+
+        return histogram_bin_edges(std::forward<E1>(data), xt::ones<value_type>({n}), left, right, bins, mode);
+    }
+
+    /**
+     * Count number of occurrences of each value in array of non-negative ints.
+     *
+     * The number of bins (of size 1) is one larger than the largest value in x.
+     * If minlength is specified, there will be at least this number of bins in
+     * the output array (though it will be longer if necessary, depending on the
+     * contents of x). Each bin gives the number of occurrences of its index
+     * value in x. If weights is specified the input array is weighted by it,
+     * i.e. if a value ``n`` is found at position ``i``, ``out[n] += weight[i]``
+     * instead of ``out[n] += 1``.
+     *
+     * @param data the 1D container with integers to count into bins
+     * @param weights a 1D container with the same number of elements as ``data``
+     * @param minlength The minlength
+     *
+     * @return 1D container with the bincount
+     */
+    template <class E1, class E2, XTL_REQUIRES(is_xexpression<std::decay_t<E2>>)>
+    inline auto bincount(E1&& data, E2&& weights, std::size_t minlength = 0)
+    {
+        using result_value_type = typename std::decay_t<E2>::value_type;
+        using input_value_type = typename std::decay_t<E1>::value_type;
+        using size_type = typename std::decay_t<E1>::size_type;
+
+        static_assert(
+            xtl::is_integral<typename std::decay_t<E1>::value_type>::value,
+            "Bincount data has to be integral type."
+        );
+        XTENSOR_ASSERT(data.dimension() == 1);
+        XTENSOR_ASSERT(weights.dimension() == 1);
+
+        std::array<input_value_type, 2> left_right;
+        left_right = xt::minmax(data)();
+
+        if (left_right[0] < input_value_type(0))
+        {
+            XTENSOR_THROW(std::runtime_error, "Data argument for bincount can only contain positive integers!");
+        }
+
+        xt::xtensor<result_value_type, 1> res = xt::zeros<result_value_type>(
+            {(std::max)(minlength, std::size_t(left_right[1] + 1))}
+        );
+
+        for (size_type i = 0; i < data.size(); ++i)
+        {
+            res(data(i)) += weights(i);
+        }
+
+        return res;
+    }
+
+    template <class E1>
+    inline auto bincount(E1&& data, std::size_t minlength = 0)
+    {
+        return bincount(
+            std::forward<E1>(data),
+            xt::ones<typename std::decay_t<E1>::value_type>(data.shape()),
+            minlength
+        );
+    }
+
+    /**
+     * Get the number of items in each bin, given the fraction of items per bin.
+     * The output is such that the total number of items of all bins is exactly "N".
+     *
+     * @param N the number of items to distribute
+     * @param weights fraction of items per bin: a 1D container whose size is the number of bins
+     *
+     * @return 1D container with the number of items per bin
+     */
+    template <class E>
+    inline xt::xtensor<size_t, 1> bin_items(size_t N, E&& weights)
+    {
+        if (weights.size() <= std::size_t(1))
+        {
+            xt::xtensor<size_t, 1> n = N * xt::ones<size_t>({1});
+            return n;
+        }
+
+#ifdef XTENSOR_ENABLE_ASSERT
+        using value_type = typename std::decay_t<E>::value_type;
+
+        XTENSOR_ASSERT(xt::all(weights >= static_cast<value_type>(0)));
+        XTENSOR_ASSERT(xt::sum(weights)() > static_cast<value_type>(0));
+#endif
+
+        xt::xtensor<double, 1> P = xt::cast<double>(weights) / static_cast<double>(xt::sum(weights)());
+        xt::xtensor<size_t, 1> n = xt::ceil(static_cast<double>(N) * P);
+
+        if (xt::sum(n)() == N)
+        {
+            return n;
+        }
+
+        xt::xtensor<size_t, 1> d = xt::zeros<size_t>(P.shape());
+        xt::xtensor<size_t, 1> sorter = xt::argsort(P);
+        sorter = xt::view(sorter, xt::range(P.size(), _, -1));
+        sorter = xt::view(sorter, xt::range(0, xt::sum(n)(0) - N));
+        xt::view(d, xt::keep(sorter)) = 1;
+        n -= d;
+
+        return n;
+    }
+
+    /**
+     * Get the number of items in each bin, with each bin having approximately the same number of
+     * items in it,under the constraint that the total number of items of all bins is exactly "N".
+     *
+     * @param N the number of items to distribute
+     * @param bins the number of bins
+     *
+     * @return 1D container with the number of items per bin
+     */
+    inline xt::xtensor<size_t, 1> bin_items(size_t N, size_t bins)
+    {
+        return bin_items(N, xt::ones<double>({bins}));
+    }
+}
+
+#endif
diff --git a/include/xtensor/misc/xmanipulation.hpp b/include/xtensor/misc/xmanipulation.hpp
new file mode 100644
index 000000000..56a78ca4b
--- /dev/null
+++ b/include/xtensor/misc/xmanipulation.hpp
@@ -0,0 +1,1151 @@
+/***************************************************************************
+ * 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_MANIPULATION_HPP
+#define XTENSOR_MANIPULATION_HPP
+
+#include <algorithm>
+#include <utility>
+
+#include <xtl/xcompare.hpp>
+#include <xtl/xsequence.hpp>
+
+#include "../core/xtensor_config.hpp"
+#include "../generators/xbuilder.hpp"
+#include "../utils/xexception.hpp"
+#include "../utils/xutils.hpp"
+#include "../views/xrepeat.hpp"
+#include "../views/xstrided_view.hpp"
+#include "xtl_concepts.hpp"
+
+namespace xt
+{
+    /**
+     * @defgroup xt_xmanipulation Array manipulation
+     */
+
+    namespace check_policy
+    {
+        struct none
+        {
+        };
+
+        struct full
+        {
+        };
+    }
+
+    template <class E>
+    auto transpose(E&& e) noexcept;
+
+    template <class E, class S, class Tag = check_policy::none>
+    auto transpose(E&& e, S&& permutation, Tag check_policy = Tag());
+
+    template <class E>
+    auto swapaxes(E&& e, std::ptrdiff_t axis1, std::ptrdiff_t axis2);
+
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E>
+    auto ravel(E&& e);
+
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E>
+    auto flatten(E&& e);
+
+    template <layout_type L, class T>
+    auto flatnonzero(const T& arr);
+
+    template <class E>
+    auto trim_zeros(E&& e, const std::string& direction = "fb");
+
+    template <class E>
+    auto squeeze(E&& e);
+
+    template <class E, xtl::non_integral_concept S, class Tag = check_policy::none>
+    auto squeeze(E&& e, S&& axis, Tag check_policy = Tag());
+
+    template <class E>
+    auto expand_dims(E&& e, std::size_t axis);
+
+    template <std::size_t N, class E>
+    auto atleast_Nd(E&& e);
+
+    template <class E>
+    auto atleast_1d(E&& e);
+
+    template <class E>
+    auto atleast_2d(E&& e);
+
+    template <class E>
+    auto atleast_3d(E&& e);
+
+    template <class E>
+    auto split(E& e, std::size_t n, std::size_t axis = 0);
+
+    template <class E>
+    auto hsplit(E& e, std::size_t n);
+
+    template <class E>
+    auto vsplit(E& e, std::size_t n);
+
+    template <class E>
+    auto flip(E&& e);
+
+    template <class E>
+    auto flip(E&& e, std::size_t axis);
+
+    template <std::ptrdiff_t N = 1, class E>
+    auto rot90(E&& e, const std::array<std::ptrdiff_t, 2>& axes = {0, 1});
+
+    template <class E>
+    auto roll(E&& e, std::ptrdiff_t shift);
+
+    template <class E>
+    auto roll(E&& e, std::ptrdiff_t shift, std::ptrdiff_t axis);
+
+    template <class E>
+    auto repeat(E&& e, std::size_t repeats, std::size_t axis);
+
+    template <class E>
+    auto repeat(E&& e, const std::vector<std::size_t>& repeats, std::size_t axis);
+
+    template <class E>
+    auto repeat(E&& e, std::vector<std::size_t>&& repeats, std::size_t axis);
+
+    /****************************
+     * transpose implementation *
+     ****************************/
+
+    namespace detail
+    {
+        inline layout_type transpose_layout_noexcept(layout_type l) noexcept
+        {
+            layout_type result = l;
+            if (l == layout_type::row_major)
+            {
+                result = layout_type::column_major;
+            }
+            else if (l == layout_type::column_major)
+            {
+                result = layout_type::row_major;
+            }
+            return result;
+        }
+
+        inline layout_type transpose_layout(layout_type l)
+        {
+            if (l != layout_type::row_major && l != layout_type::column_major)
+            {
+                XTENSOR_THROW(transpose_error, "cannot compute transposed layout of dynamic layout");
+            }
+            return transpose_layout_noexcept(l);
+        }
+
+        template <class E, class S>
+        inline auto transpose_impl(E&& e, S&& permutation, check_policy::none)
+        {
+            if (std::size(permutation) != e.dimension())
+            {
+                XTENSOR_THROW(transpose_error, "Permutation does not have the same size as shape");
+            }
+
+            // permute stride and shape
+            using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
+            shape_type temp_shape;
+            resize_container(temp_shape, e.shape().size());
+
+            using strides_type = get_strides_t<shape_type>;
+            strides_type temp_strides;
+            resize_container(temp_strides, e.strides().size());
+
+            using size_type = typename std::decay_t<E>::size_type;
+            for (std::size_t i = 0; i < e.shape().size(); ++i)
+            {
+                if (std::size_t(permutation[i]) >= e.dimension())
+                {
+                    XTENSOR_THROW(transpose_error, "Permutation contains wrong axis");
+                }
+                size_type perm = static_cast<size_type>(permutation[i]);
+                temp_shape[i] = e.shape()[perm];
+                temp_strides[i] = e.strides()[perm];
+            }
+
+            layout_type new_layout = layout_type::dynamic;
+            if (std::is_sorted(std::begin(permutation), std::end(permutation)))
+            {
+                // keep old layout
+                new_layout = e.layout();
+            }
+            else if (std::is_sorted(std::begin(permutation), std::end(permutation), std::greater<>()))
+            {
+                new_layout = transpose_layout_noexcept(e.layout());
+            }
+
+            return strided_view(
+                std::forward<E>(e),
+                std::move(temp_shape),
+                std::move(temp_strides),
+                get_offset<XTENSOR_DEFAULT_LAYOUT>(e),
+                new_layout
+            );
+        }
+
+        template <class E, class S>
+        inline auto transpose_impl(E&& e, S&& permutation, check_policy::full)
+        {
+            // check if axis appears twice in permutation
+            for (std::size_t i = 0; i < std::size(permutation); ++i)
+            {
+                for (std::size_t j = i + 1; j < std::size(permutation); ++j)
+                {
+                    if (permutation[i] == permutation[j])
+                    {
+                        XTENSOR_THROW(transpose_error, "Permutation contains axis more than once");
+                    }
+                }
+            }
+            return transpose_impl(std::forward<E>(e), std::forward<S>(permutation), check_policy::none());
+        }
+
+        template <class E, class S, class X>
+        inline void compute_transposed_strides(E&& e, const S& shape, X& strides)
+        {
+            if constexpr (data_interface_expression<std::decay_t<E>>)
+            {
+                std::copy(e.strides().crbegin(), e.strides().crend(), strides.begin());
+            }
+            else
+            {
+                // In the case where E does not have a data interface, the transposition
+                // makes use of a flat storage adaptor that has layout XTENSOR_DEFAULT_TRAVERSAL
+                // which should be the one inverted.
+                layout_type l = transpose_layout(XTENSOR_DEFAULT_TRAVERSAL);
+                compute_strides(shape, l, strides);
+            }
+        }
+    }
+
+    /**
+     * Returns a transpose view by reversing the dimensions of xexpression e
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input expression
+     */
+    template <class E>
+    inline auto transpose(E&& e) noexcept
+    {
+        using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
+        shape_type shape;
+        resize_container(shape, e.shape().size());
+        std::copy(e.shape().crbegin(), e.shape().crend(), shape.begin());
+
+        get_strides_t<shape_type> strides;
+        resize_container(strides, e.shape().size());
+        detail::compute_transposed_strides(e, shape, strides);
+
+        layout_type new_layout = detail::transpose_layout_noexcept(e.layout());
+
+        return strided_view(
+            std::forward<E>(e),
+            std::move(shape),
+            std::move(strides),
+            detail::get_offset<XTENSOR_DEFAULT_TRAVERSAL>(e),
+            new_layout
+        );
+    }
+
+    /**
+     * Returns a transpose view by permuting the xexpression e with @p permutation.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input expression
+     * @param permutation the sequence containing permutation
+     * @param check_policy the check level (check_policy::full() or check_policy::none())
+     * @tparam Tag selects the level of error checking on permutation vector defaults to check_policy::none.
+     */
+    template <class E, class S, class Tag>
+    inline auto transpose(E&& e, S&& permutation, Tag check_policy)
+    {
+        return detail::transpose_impl(std::forward<E>(e), std::forward<S>(permutation), check_policy);
+    }
+
+    /// @cond DOXYGEN_INCLUDE_SFINAE
+    template <class E, class I, std::size_t N, class Tag = check_policy::none>
+    inline auto transpose(E&& e, const I (&permutation)[N], Tag check_policy = Tag())
+    {
+        return detail::transpose_impl(std::forward<E>(e), permutation, check_policy);
+    }
+
+    /// @endcond
+
+    /*****************************
+     *  swapaxes implementation  *
+     *****************************/
+
+    namespace detail
+    {
+        template <class S>
+        inline S swapaxes_perm(std::size_t dim, std::ptrdiff_t axis1, std::ptrdiff_t axis2)
+        {
+            const std::size_t ax1 = normalize_axis(dim, axis1);
+            const std::size_t ax2 = normalize_axis(dim, axis2);
+            auto perm = xtl::make_sequence<S>(dim, 0);
+            using id_t = typename S::value_type;
+            std::iota(perm.begin(), perm.end(), id_t(0));
+            perm[ax1] = ax2;
+            perm[ax2] = ax1;
+            return perm;
+        }
+    }
+
+    /**
+     * Return a new expression with two axes interchanged.
+     *
+     * The two axis parameter @p axis and @p axis2 are interchangable.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e The input expression
+     * @param axis1 First axis to swap
+     * @param axis2 Second axis to swap
+     */
+    template <class E>
+    inline auto swapaxes(E&& e, std::ptrdiff_t axis1, std::ptrdiff_t axis2)
+    {
+        const auto dim = e.dimension();
+        check_axis_in_dim(axis1, dim, "Parameter axis1");
+        check_axis_in_dim(axis2, dim, "Parameter axis2");
+
+        using strides_t = get_strides_t<typename std::decay_t<E>::shape_type>;
+        return transpose(std::forward<E>(e), detail::swapaxes_perm<strides_t>(dim, axis1, axis2));
+    }
+
+    /*****************************
+     *  moveaxis implementation  *
+     *****************************/
+
+    namespace detail
+    {
+        template <class S>
+        inline S moveaxis_perm(std::size_t dim, std::ptrdiff_t src, std::ptrdiff_t dest)
+        {
+            using id_t = typename S::value_type;
+
+            const std::size_t src_norm = normalize_axis(dim, src);
+            const std::size_t dest_norm = normalize_axis(dim, dest);
+
+            // Initializing to src_norm handles case where `dest == -1` and the loop
+            // does not go check `perm_idx == dest_norm` a `dim+1`th time.
+            auto perm = xtl::make_sequence<S>(dim, src_norm);
+            id_t perm_idx = 0;
+            for (id_t i = 0; xtl::cmp_less(i, dim); ++i)
+            {
+                if (xtl::cmp_equal(perm_idx, dest_norm))
+                {
+                    perm[perm_idx] = src_norm;
+                    ++perm_idx;
+                }
+                if (xtl::cmp_not_equal(i, src_norm))
+                {
+                    perm[perm_idx] = i;
+                    ++perm_idx;
+                }
+            }
+            return perm;
+        }
+    }
+
+    /**
+     * Return a new expression with an axis move to a new position.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e The input expression
+     * @param src Original position of the axis to move
+     * @param dest Destination position for the original axis.
+     */
+    template <class E>
+    inline auto moveaxis(E&& e, std::ptrdiff_t src, std::ptrdiff_t dest)
+    {
+        const auto dim = e.dimension();
+        check_axis_in_dim(src, dim, "Parameter src");
+        check_axis_in_dim(dest, dim, "Parameter dest");
+
+        using strides_t = get_strides_t<typename std::decay_t<E>::shape_type>;
+        return xt::transpose(std::forward<E>(e), detail::moveaxis_perm<strides_t>(e.dimension(), src, dest));
+    }
+
+    /************************************
+     * ravel and flatten implementation *
+     ************************************/
+
+    namespace detail
+    {
+        template <class E, layout_type L>
+        struct expression_iterator_getter
+        {
+            using iterator = decltype(std::declval<E>().template begin<L>());
+            using const_iterator = decltype(std::declval<E>().template cbegin<L>());
+
+            inline static iterator begin(E& e)
+            {
+                return e.template begin<L>();
+            }
+
+            inline static const_iterator cbegin(E& e)
+            {
+                return e.template cbegin<L>();
+            }
+
+            inline static auto size(E& e)
+            {
+                return e.size();
+            }
+        };
+    }
+
+    /**
+     * Return a flatten view of the given expression. No copy is made.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input expression
+     * @tparam L the layout used to read the elements of e.
+     *     If no parameter is specified, XTENSOR_DEFAULT_TRAVERSAL is used.
+     * @tparam E the type of the expression
+     */
+    template <layout_type L, class E>
+    inline auto ravel(E&& e)
+    {
+        using iterator = decltype(e.template begin<L>());
+        using iterator_getter = detail::expression_iterator_getter<std::remove_reference_t<E>, L>;
+        auto size = e.size();
+        auto adaptor = make_xiterator_adaptor(std::forward<E>(e), iterator_getter());
+        constexpr layout_type layout = std::is_pointer<iterator>::value ? L : layout_type::dynamic;
+        using type = xtensor_view<decltype(adaptor), 1, layout, extension::get_expression_tag_t<E>>;
+        return type(std::move(adaptor), {size});
+    }
+
+    /**
+     * Return a flatten view of the given expression.
+     *
+     * No copy is made.
+     * This method is equivalent to ravel and is provided for API sameness with NumPy.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input expression
+     * @tparam L the layout used to read the elements of e.
+     *     If no parameter is specified, XTENSOR_DEFAULT_TRAVERSAL is used.
+     * @tparam E the type of the expression
+     * @sa ravel
+     */
+    template <layout_type L, class E>
+    inline auto flatten(E&& e)
+    {
+        return ravel<L>(std::forward<E>(e));
+    }
+
+    /**
+     * Return indices that are non-zero in the flattened version of arr.
+     *
+     * Equivalent to ``nonzero(ravel<layout_type>(arr))[0];``
+     *
+     * @param arr input array
+     * @return indices that are non-zero in the flattened version of arr
+     */
+    template <layout_type L, class T>
+    inline auto flatnonzero(const T& arr)
+    {
+        return nonzero(ravel<L>(arr))[0];
+    }
+
+    /*****************************
+     * trim_zeros implementation *
+     *****************************/
+
+    /**
+     * Trim zeros at beginning, end or both of 1D sequence.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e input xexpression
+     * @param direction string of either 'f' for trim from beginning, 'b' for trim from end
+     *                  or 'fb' (default) for both.
+     * @return returns a view without zeros at the beginning and end
+     */
+    template <class E>
+    inline auto trim_zeros(E&& e, const std::string& direction)
+    {
+        XTENSOR_ASSERT_MSG(e.dimension() == 1, "Dimension for trim_zeros has to be 1.");
+
+        std::ptrdiff_t begin = 0, end = static_cast<std::ptrdiff_t>(e.size());
+
+        auto find_fun = [](const auto& i)
+        {
+            return i != 0;
+        };
+
+        if (direction.find("f") != std::string::npos)
+        {
+            begin = std::find_if(e.cbegin(), e.cend(), find_fun) - e.cbegin();
+        }
+
+        if (direction.find("b") != std::string::npos && begin != end)
+        {
+            end -= std::find_if(e.crbegin(), e.crend(), find_fun) - e.crbegin();
+        }
+
+        return strided_view(std::forward<E>(e), {range(begin, end)});
+    }
+
+    /**************************
+     * squeeze implementation *
+     **************************/
+
+    /**
+     * Returns a squeeze view of the given expression.
+     *
+     * No copy is made. Squeezing an expression removes dimensions of extent 1.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input expression
+     * @tparam E the type of the expression
+     */
+    template <class E>
+    inline auto squeeze(E&& e)
+    {
+        dynamic_shape<std::size_t> new_shape;
+        dynamic_shape<std::ptrdiff_t> new_strides;
+        std::copy_if(
+            e.shape().cbegin(),
+            e.shape().cend(),
+            std::back_inserter(new_shape),
+            [](std::size_t i)
+            {
+                return i != 1;
+            }
+        );
+        decltype(auto) old_strides = detail::get_strides<XTENSOR_DEFAULT_LAYOUT>(e);
+        std::copy_if(
+            old_strides.cbegin(),
+            old_strides.cend(),
+            std::back_inserter(new_strides),
+            [](std::ptrdiff_t i)
+            {
+                return i != 0;
+            }
+        );
+
+        return strided_view(std::forward<E>(e), std::move(new_shape), std::move(new_strides), 0, e.layout());
+    }
+
+    namespace detail
+    {
+        template <class E, class S>
+        inline auto squeeze_impl(E&& e, S&& axis, check_policy::none)
+        {
+            std::size_t new_dim = e.dimension() - axis.size();
+            dynamic_shape<std::size_t> new_shape(new_dim);
+            dynamic_shape<std::ptrdiff_t> new_strides(new_dim);
+
+            decltype(auto) old_strides = detail::get_strides<XTENSOR_DEFAULT_LAYOUT>(e);
+
+            for (std::size_t i = 0, ix = 0; i < e.dimension(); ++i)
+            {
+                if (axis.cend() == std::find(axis.cbegin(), axis.cend(), i))
+                {
+                    new_shape[ix] = e.shape()[i];
+                    new_strides[ix++] = old_strides[i];
+                }
+            }
+
+            return strided_view(std::forward<E>(e), std::move(new_shape), std::move(new_strides), 0, e.layout());
+        }
+
+        template <class E, class S>
+        inline auto squeeze_impl(E&& e, S&& axis, check_policy::full)
+        {
+            for (auto ix : axis)
+            {
+                if (static_cast<std::size_t>(ix) > e.dimension())
+                {
+                    XTENSOR_THROW(std::runtime_error, "Axis argument to squeeze > dimension of expression");
+                }
+                if (e.shape()[static_cast<std::size_t>(ix)] != 1)
+                {
+                    XTENSOR_THROW(std::runtime_error, "Trying to squeeze axis != 1");
+                }
+            }
+            return squeeze_impl(std::forward<E>(e), std::forward<S>(axis), check_policy::none());
+        }
+    }
+
+    /**
+     * Remove single-dimensional entries from the shape of an xexpression
+     *
+     * @ingroup xt_xmanipulation
+     * @param e input xexpression
+     * @param axis integer or container of integers, select a subset of single-dimensional
+     *        entries of the shape.
+     * @param check_policy select check_policy. With check_policy::full(), selecting an axis
+     *        which is greater than one will throw a runtime_error.
+     */
+    template <class E, xtl::non_integral_concept S, class Tag>
+    inline auto squeeze(E&& e, S&& axis, Tag check_policy)
+    {
+        return detail::squeeze_impl(std::forward<E>(e), std::forward<S>(axis), check_policy);
+    }
+
+    /// @cond DOXYGEN_INCLUDE_SFINAE
+    template <class E, class I, std::size_t N, class Tag = check_policy::none>
+    inline auto squeeze(E&& e, const I (&axis)[N], Tag check_policy = Tag())
+    {
+        using arr_t = std::array<I, N>;
+        return detail::squeeze_impl(
+            std::forward<E>(e),
+            xtl::forward_sequence<arr_t, decltype(axis)>(axis),
+            check_policy
+        );
+    }
+
+    template <class E, class Tag = check_policy::none>
+    inline auto squeeze(E&& e, std::size_t axis, Tag check_policy = Tag())
+    {
+        return squeeze(std::forward<E>(e), std::array<std::size_t, 1>{{axis}}, check_policy);
+    }
+
+    /// @endcond
+
+    /******************************
+     * expand_dims implementation *
+     ******************************/
+
+    /**
+     * Expand the shape of an xexpression.
+     *
+     * Insert a new axis that will appear at the axis position in the expanded array shape.
+     * This will return a ``strided_view`` with a ``xt::newaxis()`` at the indicated axis.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e input xexpression
+     * @param axis axis to expand
+     * @return returns a ``strided_view`` with expanded dimension
+     */
+    template <class E>
+    inline auto expand_dims(E&& e, std::size_t axis)
+    {
+        xstrided_slice_vector sv(e.dimension() + 1, all());
+        sv[axis] = newaxis();
+        return strided_view(std::forward<E>(e), std::move(sv));
+    }
+
+    /*****************************
+     * atleast_Nd implementation *
+     *****************************/
+
+    /**
+     * Expand dimensions of xexpression to at least `N`
+     *
+     * This adds ``newaxis()`` slices to a ``strided_view`` until
+     * the dimension of the view reaches at least `N`.
+     * Note: dimensions are added equally at the beginning and the end.
+     * For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1).
+     *
+     * @ingroup xt_xmanipulation
+     * @param e input xexpression
+     * @tparam N the number of requested dimensions
+     * @return ``strided_view`` with expanded dimensions
+     */
+    template <std::size_t N, class E>
+    inline auto atleast_Nd(E&& e)
+    {
+        xstrided_slice_vector sv((std::max)(e.dimension(), N), all());
+        if (e.dimension() < N)
+        {
+            std::size_t i = 0;
+            std::size_t end = static_cast<std::size_t>(std::round(double(N - e.dimension()) / double(N)));
+            for (; i < end; ++i)
+            {
+                sv[i] = newaxis();
+            }
+            i += e.dimension();
+            for (; i < N; ++i)
+            {
+                sv[i] = newaxis();
+            }
+        }
+        return strided_view(std::forward<E>(e), std::move(sv));
+    }
+
+    /**
+     * Expand to at least 1D
+     *
+     * @ingroup xt_xmanipulation
+     * @sa atleast_Nd
+     */
+    template <class E>
+    inline auto atleast_1d(E&& e)
+    {
+        return atleast_Nd<1>(std::forward<E>(e));
+    }
+
+    /**
+     * Expand to at least 2D
+     *
+     * @ingroup xt_xmanipulation
+     * @sa atleast_Nd
+     */
+    template <class E>
+    inline auto atleast_2d(E&& e)
+    {
+        return atleast_Nd<2>(std::forward<E>(e));
+    }
+
+    /**
+     * Expand to at least 3D
+     *
+     * @ingroup xt_xmanipulation
+     * @sa atleast_Nd
+     */
+    template <class E>
+    inline auto atleast_3d(E&& e)
+    {
+        return atleast_Nd<3>(std::forward<E>(e));
+    }
+
+    /************************
+     * split implementation *
+     ************************/
+
+    /**
+     * Split xexpression along axis into subexpressions
+     *
+     * This splits an xexpression along the axis in `n` equal parts and
+     * returns a vector of ``strided_view``.
+     * Calling split with axis > dimension of e or a `n` that does not result in
+     * an equal division of the xexpression will throw a runtime_error.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e input xexpression
+     * @param n number of elements to return
+     * @param axis axis along which to split the expression
+     */
+    template <class E>
+    inline auto split(E& e, std::size_t n, std::size_t axis)
+    {
+        if (axis >= e.dimension())
+        {
+            XTENSOR_THROW(std::runtime_error, "Split along axis > dimension.");
+        }
+
+        std::size_t ax_sz = e.shape()[axis];
+        xstrided_slice_vector sv(e.dimension(), all());
+        std::size_t step = ax_sz / n;
+        std::size_t rest = ax_sz % n;
+
+        if (rest)
+        {
+            XTENSOR_THROW(std::runtime_error, "Split does not result in equal division.");
+        }
+
+        std::vector<decltype(strided_view(e, sv))> result;
+        for (std::size_t i = 0; i < n; ++i)
+        {
+            sv[axis] = range(i * step, (i + 1) * step);
+            result.emplace_back(strided_view(e, sv));
+        }
+        return result;
+    }
+
+    /**
+     * Split an xexpression into subexpressions horizontally (column-wise)
+     *
+     * This method is equivalent to ``split(e, n, 1)``.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e input xexpression
+     * @param n number of elements to return
+     */
+    template <class E>
+    inline auto hsplit(E& e, std::size_t n)
+    {
+        return split(e, n, std::size_t(1));
+    }
+
+    /**
+     * Split an xexpression into subexpressions vertically (row-wise)
+     *
+     * This method is equivalent to ``split(e, n, 0)``.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e input xexpression
+     * @param n number of elements to return
+     */
+    template <class E>
+    inline auto vsplit(E& e, std::size_t n)
+    {
+        return split(e, n, std::size_t(0));
+    }
+
+    /***********************
+     * flip implementation *
+     ***********************/
+
+    /**
+     * Reverse the order of elements in an xexpression along every axis.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @return returns a view with the result of the flip.
+     */
+    template <class E>
+    inline auto flip(E&& e)
+    {
+        using size_type = typename std::decay_t<E>::size_type;
+        auto r = flip(e, 0);
+        for (size_type d = 1; d < e.dimension(); ++d)
+        {
+            r = flip(r, d);
+        }
+        return r;
+    }
+
+    /**
+     * Reverse the order of elements in an xexpression along the given axis.
+     *
+     * Note: A NumPy/Matlab style `flipud(arr)` is equivalent to `xt::flip(arr, 0)`,
+     * `fliplr(arr)` to `xt::flip(arr, 1)`.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @param axis the axis along which elements should be reversed
+     * @return returns a view with the result of the flip
+     */
+    template <class E>
+    inline auto flip(E&& e, std::size_t axis)
+    {
+        using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
+
+        shape_type shape;
+        resize_container(shape, e.shape().size());
+        std::copy(e.shape().cbegin(), e.shape().cend(), shape.begin());
+
+        get_strides_t<shape_type> strides;
+        decltype(auto) old_strides = detail::get_strides<XTENSOR_DEFAULT_LAYOUT>(e);
+        resize_container(strides, old_strides.size());
+        std::copy(old_strides.cbegin(), old_strides.cend(), strides.begin());
+
+        strides[axis] *= -1;
+        std::size_t offset = static_cast<std::size_t>(
+            static_cast<std::ptrdiff_t>(e.data_offset())
+            + old_strides[axis] * (static_cast<std::ptrdiff_t>(e.shape()[axis]) - 1)
+        );
+
+        return strided_view(std::forward<E>(e), std::move(shape), std::move(strides), offset);
+    }
+
+    /************************
+     * rot90 implementation *
+     ************************/
+
+    namespace detail
+    {
+        template <std::ptrdiff_t N>
+        struct rot90_impl;
+
+        template <>
+        struct rot90_impl<0>
+        {
+            template <class E>
+            inline auto operator()(E&& e, const std::array<std::size_t, 2>& /*axes*/)
+            {
+                return std::forward<E>(e);
+            }
+        };
+
+        template <>
+        struct rot90_impl<1>
+        {
+            template <class E>
+            inline auto operator()(E&& e, const std::array<std::size_t, 2>& axes)
+            {
+                using std::swap;
+
+                dynamic_shape<std::ptrdiff_t> axes_list(e.shape().size());
+                std::iota(axes_list.begin(), axes_list.end(), 0);
+                swap(axes_list[axes[0]], axes_list[axes[1]]);
+
+                return transpose(flip(std::forward<E>(e), axes[1]), std::move(axes_list));
+            }
+        };
+
+        template <>
+        struct rot90_impl<2>
+        {
+            template <class E>
+            inline auto operator()(E&& e, const std::array<std::size_t, 2>& axes)
+            {
+                return flip(flip(std::forward<E>(e), axes[0]), axes[1]);
+            }
+        };
+
+        template <>
+        struct rot90_impl<3>
+        {
+            template <class E>
+            inline auto operator()(E&& e, const std::array<std::size_t, 2>& axes)
+            {
+                using std::swap;
+
+                dynamic_shape<std::ptrdiff_t> axes_list(e.shape().size());
+                std::iota(axes_list.begin(), axes_list.end(), 0);
+                swap(axes_list[axes[0]], axes_list[axes[1]]);
+
+                return flip(transpose(std::forward<E>(e), std::move(axes_list)), axes[1]);
+            }
+        };
+    }
+
+    /**
+     * Rotate an array by 90 degrees in the plane specified by axes.
+     *
+     * Rotation direction is from the first towards the second axis.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @param axes the array is rotated in the plane defined by the axes. Axes must be different.
+     * @tparam N number of times the array is rotated by 90 degrees. Default is 1.
+     * @return returns a view with the result of the rotation
+     */
+    template <std::ptrdiff_t N, class E>
+    inline auto rot90(E&& e, const std::array<std::ptrdiff_t, 2>& axes)
+    {
+        auto ndim = static_cast<std::ptrdiff_t>(e.shape().size());
+
+        if (axes[0] == axes[1] || std::abs(axes[0] - axes[1]) == ndim)
+        {
+            XTENSOR_THROW(std::runtime_error, "Axes must be different");
+        }
+
+        auto norm_axes = forward_normalize<std::array<std::size_t, 2>>(e, axes);
+        constexpr std::ptrdiff_t n = (4 + (N % 4)) % 4;
+
+        return detail::rot90_impl<n>()(std::forward<E>(e), norm_axes);
+    }
+
+    /***********************
+     * roll implementation *
+     ***********************/
+
+    /**
+     * Roll an expression.
+     *
+     * The expression is flatten before shifting, after which the original
+     * shape is restore. Elements that roll beyond the last position are
+     * re-introduced at the first. This function does not change the input
+     * expression.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @param shift the number of places by which elements are shifted
+     * @return a roll of the input expression
+     */
+    template <class E>
+    inline auto roll(E&& e, std::ptrdiff_t shift)
+    {
+        auto cpy = empty_like(e);
+
+        if (cpy.size() == 0)
+        {
+            return cpy;
+        }
+
+        const auto flat_size = static_cast<std::ptrdiff_t>(cpy.size());
+        while (shift < 0)
+        {
+            shift += flat_size;
+        }
+
+        shift %= flat_size;
+        std::copy(e.begin(), e.end() - shift, std::copy(e.end() - shift, e.end(), cpy.begin()));
+
+        return cpy;
+    }
+
+    namespace detail
+    {
+        /**
+         * Algorithm adapted from pythran/pythonic/numpy/roll.hpp
+         */
+
+        template <class To, class From, class S>
+        To roll(To to, From from, std::ptrdiff_t shift, std::size_t axis, const S& shape, std::size_t M)
+        {
+            std::ptrdiff_t dim = std::ptrdiff_t(shape[M]);
+            std::ptrdiff_t offset = std::accumulate(
+                shape.begin() + M + 1,
+                shape.end(),
+                std::ptrdiff_t(1),
+                std::multiplies<std::ptrdiff_t>()
+            );
+            if (shape.size() == M + 1)
+            {
+                if (axis == M)
+                {
+                    const auto split = from + (dim - shift) * offset;
+                    for (auto iter = split, end = from + dim * offset; iter != end; iter += offset, ++to)
+                    {
+                        *to = *iter;
+                    }
+                    for (auto iter = from, end = split; iter != end; iter += offset, ++to)
+                    {
+                        *to = *iter;
+                    }
+                }
+                else
+                {
+                    for (auto iter = from, end = from + dim * offset; iter != end; iter += offset, ++to)
+                    {
+                        *to = *iter;
+                    }
+                }
+            }
+            else
+            {
+                if (axis == M)
+                {
+                    const auto split = from + (dim - shift) * offset;
+                    for (auto iter = split, end = from + dim * offset; iter != end; iter += offset)
+                    {
+                        to = roll(to, iter, shift, axis, shape, M + 1);
+                    }
+                    for (auto iter = from, end = split; iter != end; iter += offset)
+                    {
+                        to = roll(to, iter, shift, axis, shape, M + 1);
+                    }
+                }
+                else
+                {
+                    for (auto iter = from, end = from + dim * offset; iter != end; iter += offset)
+                    {
+                        to = roll(to, iter, shift, axis, shape, M + 1);
+                    }
+                }
+            }
+            return to;
+        }
+    }
+
+    /**
+     * Roll an expression along a given axis.
+     *
+     * Elements that roll beyond the last position are re-introduced at the first.
+     * This function does not change the input expression.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @param shift the number of places by which elements are shifted
+     * @param axis the axis along which elements are shifted.
+     * @return a roll of the input expression
+     */
+    template <class E>
+    inline auto roll(E&& e, std::ptrdiff_t shift, std::ptrdiff_t axis)
+    {
+        auto cpy = empty_like(e);
+        const auto& shape = cpy.shape();
+        const auto dim = cpy.dimension();
+
+        if (axis < -static_cast<std::ptrdiff_t>(dim) || axis >= static_cast<std::ptrdiff_t>(dim))
+        {
+            XTENSOR_THROW(std::runtime_error, "axis is not within shape dimension.");
+        }
+
+        if (cpy.size() == 0)
+        {
+            return cpy;
+        }
+
+        std::size_t saxis = normalize_axis(dim, axis);
+        const auto axis_dim = static_cast<std::ptrdiff_t>(shape[saxis]);
+
+        while (shift < 0)
+        {
+            shift += axis_dim;
+        }
+
+        detail::roll(cpy.begin(), e.begin(), shift, saxis, shape, 0);
+        return cpy;
+    }
+
+    /****************************
+     * repeat implementation    *
+     ****************************/
+
+    namespace detail
+    {
+        template <class E, class R>
+        inline auto make_xrepeat(E&& e, R&& r, typename std::decay_t<E>::size_type axis)
+        {
+            const auto casted_axis = static_cast<typename std::decay_t<E>::size_type>(axis);
+            if (r.size() != e.shape(casted_axis))
+            {
+                XTENSOR_THROW(std::invalid_argument, "repeats must have the same size as the specified axis");
+            }
+            return xrepeat<const_xclosure_t<E>, R>(std::forward<E>(e), std::forward<R>(r), axis);
+        }
+    }
+
+    /**
+     * Repeat elements of an expression along a given axis.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @param repeats The number of repetition of each elements.
+     *     @p repeats is broadcasted to fit the shape of the given @p axis.
+     * @param axis the axis along which to repeat the value
+     * @return an expression with the same shape as ``e``, except along the given ``axis``
+     */
+    template <class E>
+    inline auto repeat(E&& e, std::size_t repeats, std::size_t axis)
+    {
+        const auto casted_axis = static_cast<typename std::decay_t<E>::size_type>(axis);
+        std::vector<std::size_t> broadcasted_repeats(e.shape(casted_axis));
+        std::fill(broadcasted_repeats.begin(), broadcasted_repeats.end(), repeats);
+        return repeat(std::forward<E>(e), std::move(broadcasted_repeats), axis);
+    }
+
+    /**
+     * Repeat elements of an expression along a given axis.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @param repeats The number of repetition of each elements.
+     *     The size of @p repeats must match the shape of the given @p axis.
+     * @param axis the axis along which to repeat the value
+     *
+     * @return an expression with the same shape as ``e``, except along the given ``axis``
+     */
+    template <class E>
+    inline auto repeat(E&& e, const std::vector<std::size_t>& repeats, std::size_t axis)
+    {
+        return detail::make_xrepeat(std::forward<E>(e), repeats, axis);
+    }
+
+    /**
+     * Repeat elements of an expression along a given axis.
+     *
+     * @ingroup xt_xmanipulation
+     * @param e the input xexpression
+     * @param repeats The number of repetition of each elements.
+     *     The size of @p repeats must match the shape of the given @p axis.
+     * @param axis the axis along which to repeat the value
+     * @return an expression with the same shape as ``e``, except along the given ``axis``
+     */
+    template <class E>
+    inline auto repeat(E&& e, std::vector<std::size_t>&& repeats, std::size_t axis)
+    {
+        return detail::make_xrepeat(std::forward<E>(e), std::move(repeats), axis);
+    }
+}
+
+#endif
diff --git a/include/xtensor/misc/xpad.hpp b/include/xtensor/misc/xpad.hpp
new file mode 100644
index 000000000..1204632f3
--- /dev/null
+++ b/include/xtensor/misc/xpad.hpp
@@ -0,0 +1,323 @@
+/***************************************************************************
+ * 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_PAD_HPP
+#define XTENSOR_PAD_HPP
+
+#include "../containers/xarray.hpp"
+#include "../containers/xtensor.hpp"
+#include "../views/xstrided_view.hpp"
+#include "../views/xview.hpp"
+
+using namespace xt::placeholders;  // to enable _ syntax
+
+namespace xt
+{
+    /**
+     * @brief Defines different algorithms to be used in ``xt::pad``:
+     * - ``constant``: Pads with a constant value.
+     * - ``symmetric``: Pads with the reflection of the vector mirrored along the edge of the array.
+     * - ``reflect``: Pads with the reflection of the vector mirrored on the first and last values
+     *   of the vector along each axis.
+     * - ``wrap``: Pads with the wrap of the vector along the axis. The first values are used to pad
+     *   the end and the end values are used to pad the beginning.
+     * - ``periodic`` : ``== wrap`` (pads with periodic repetitions of the vector).
+     *
+     * OpenCV to xtensor:
+     * - ``BORDER_CONSTANT == constant``
+     * - ``BORDER_REFLECT == symmetric``
+     * - ``BORDER_REFLECT_101 == reflect``
+     * - ``BORDER_WRAP == wrap``
+     */
+    enum class pad_mode
+    {
+        constant,
+        symmetric,
+        reflect,
+        wrap,
+        periodic,
+        edge
+    };
+
+    namespace detail
+    {
+        template <class S, class T>
+        inline bool check_pad_width(const std::vector<std::vector<S>>& pad_width, const T& shape)
+        {
+            if (pad_width.size() != shape.size())
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+
+    /**
+     * @brief Pad an array.
+     *
+     * @param e The array.
+     * @param pad_width Number of values padded to the edges of each axis:
+     * `{{before_1, after_1}, ..., {before_N, after_N}}`.
+     * @param mode The type of algorithm to use. [default: `xt::pad_mode::constant`].
+     * @param constant_value The value to set the padded values for each axis
+     * (used in `xt::pad_mode::constant`).
+     * @return The padded array.
+     */
+    template <class E, class S = typename std::decay_t<E>::size_type, class V = typename std::decay_t<E>::value_type>
+    inline auto
+    pad(E&& e,
+        const std::vector<std::vector<S>>& pad_width,
+        pad_mode mode = pad_mode::constant,
+        V constant_value = 0)
+    {
+        XTENSOR_ASSERT(detail::check_pad_width(pad_width, e.shape()));
+
+        using size_type = typename std::decay_t<E>::size_type;
+        using return_type = temporary_type_t<E>;
+
+        // place the original array in the center
+
+        auto new_shape = e.shape();
+        xt::xstrided_slice_vector sv;
+        sv.reserve(e.shape().size());
+        for (size_type axis = 0; axis < e.shape().size(); ++axis)
+        {
+            size_type nb = static_cast<size_type>(pad_width[axis][0]);
+            size_type ne = static_cast<size_type>(pad_width[axis][1]);
+            size_type ns = nb + e.shape(axis) + ne;
+            new_shape[axis] = ns;
+            sv.push_back(xt::range(nb, nb + e.shape(axis)));
+        }
+
+        if (mode == pad_mode::constant)
+        {
+            return_type out(new_shape, constant_value);
+            xt::strided_view(out, sv) = e;
+            return out;
+        }
+
+        return_type out(new_shape);
+        xt::strided_view(out, sv) = e;
+
+        // construct padded regions based on original image
+
+        xt::xstrided_slice_vector svs(e.shape().size(), xt::all());
+        xt::xstrided_slice_vector svt(e.shape().size(), xt::all());
+
+        for (size_type axis = 0; axis < e.shape().size(); ++axis)
+        {
+            size_type nb = static_cast<size_type>(pad_width[axis][0]);
+            size_type ne = static_cast<size_type>(pad_width[axis][1]);
+
+            if (nb > static_cast<size_type>(0))
+            {
+                svt[axis] = xt::range(0, nb);
+
+                if (mode == pad_mode::wrap || mode == pad_mode::periodic)
+                {
+                    XTENSOR_ASSERT(nb <= e.shape(axis));
+                    svs[axis] = xt::range(e.shape(axis), nb + e.shape(axis));
+                    xt::strided_view(out, svt) = xt::strided_view(out, svs);
+                }
+                else if (mode == pad_mode::symmetric)
+                {
+                    XTENSOR_ASSERT(nb <= e.shape(axis));
+                    svs[axis] = xt::range(2 * nb - 1, nb - 1, -1);
+                    xt::strided_view(out, svt) = xt::strided_view(out, svs);
+                }
+                else if (mode == pad_mode::reflect)
+                {
+                    XTENSOR_ASSERT(nb <= e.shape(axis) - 1);
+                    svs[axis] = xt::range(2 * nb, nb, -1);
+                    xt::strided_view(out, svt) = xt::strided_view(out, svs);
+                }
+                else if (mode == pad_mode::edge)
+                {
+                    svs[axis] = xt::range(nb, nb + 1);
+                    xt::strided_view(out, svt) = xt::broadcast(
+                        xt::strided_view(out, svs),
+                        xt::strided_view(out, svt).shape()
+                    );
+                }
+            }
+
+            if (ne > static_cast<size_type>(0))
+            {
+                svt[axis] = xt::range(out.shape(axis) - ne, out.shape(axis));
+
+                if (mode == pad_mode::wrap || mode == pad_mode::periodic)
+                {
+                    XTENSOR_ASSERT(ne <= e.shape(axis));
+                    svs[axis] = xt::range(nb, nb + ne);
+                    xt::strided_view(out, svt) = xt::strided_view(out, svs);
+                }
+                else if (mode == pad_mode::symmetric)
+                {
+                    XTENSOR_ASSERT(ne <= e.shape(axis));
+                    if (ne == nb + e.shape(axis))
+                    {
+                        svs[axis] = xt::range(nb + e.shape(axis) - 1, _, -1);
+                    }
+                    else
+                    {
+                        svs[axis] = xt::range(nb + e.shape(axis) - 1, nb + e.shape(axis) - ne - 1, -1);
+                    }
+                    xt::strided_view(out, svt) = xt::strided_view(out, svs);
+                }
+                else if (mode == pad_mode::reflect)
+                {
+                    XTENSOR_ASSERT(ne <= e.shape(axis) - 1);
+                    if (ne == nb + e.shape(axis) - 1)
+                    {
+                        svs[axis] = xt::range(nb + e.shape(axis) - 2, _, -1);
+                    }
+                    else
+                    {
+                        svs[axis] = xt::range(nb + e.shape(axis) - 2, nb + e.shape(axis) - ne - 2, -1);
+                    }
+                    xt::strided_view(out, svt) = xt::strided_view(out, svs);
+                }
+                else if (mode == pad_mode::edge)
+                {
+                    svs[axis] = xt::range(out.shape(axis) - ne - 1, out.shape(axis) - ne);
+                    xt::strided_view(out, svt) = xt::broadcast(
+                        xt::strided_view(out, svs),
+                        xt::strided_view(out, svt).shape()
+                    );
+                }
+            }
+
+            svs[axis] = xt::all();
+            svt[axis] = xt::all();
+        }
+
+        return out;
+    }
+
+    /**
+     * @brief Pad an array.
+     *
+     * @param e The array.
+     * @param pad_width Number of values padded to the edges of each axis:
+     * `{before, after}`.
+     * @param mode The type of algorithm to use. [default: `xt::pad_mode::constant`].
+     * @param constant_value The value to set the padded values for each axis
+     * (used in `xt::pad_mode::constant`).
+     * @return The padded array.
+     */
+    template <class E, class S = typename std::decay_t<E>::size_type, class V = typename std::decay_t<E>::value_type>
+    inline auto
+    pad(E&& e, const std::vector<S>& pad_width, pad_mode mode = pad_mode::constant, V constant_value = 0)
+    {
+        std::vector<std::vector<S>> pw(e.shape().size(), pad_width);
+
+        return pad(e, pw, mode, constant_value);
+    }
+
+    /**
+     * @brief Pad an array.
+     *
+     * @param e The array.
+     * @param pad_width Number of values padded to the edges of each axis.
+     * @param mode The type of algorithm to use. [default: `xt::pad_mode::constant`].
+     * @param constant_value The value to set the padded values for each axis
+     * (used in `xt::pad_mode::constant`).
+     * @return The padded array.
+     */
+    template <class E, class S = typename std::decay_t<E>::size_type, class V = typename std::decay_t<E>::value_type>
+    inline auto pad(E&& e, S pad_width, pad_mode mode = pad_mode::constant, V constant_value = 0)
+    {
+        std::vector<std::vector<S>> pw(e.shape().size(), {pad_width, pad_width});
+
+        return pad(e, pw, mode, constant_value);
+    }
+
+    namespace detail
+    {
+
+        template <class E, class S>
+        inline auto tile(E&& e, const S& reps)
+        {
+            using size_type = typename std::decay_t<E>::size_type;
+
+            using return_type = temporary_type_t<E>;
+
+            XTENSOR_ASSERT(e.shape().size() == reps.size());
+
+            using new_shape_type = typename return_type::shape_type;
+            auto new_shape = xtl::make_sequence<new_shape_type>(e.shape().size());
+
+            xt::xstrided_slice_vector sv(reps.size());
+
+            for (size_type axis = 0; axis < reps.size(); ++axis)
+            {
+                new_shape[axis] = e.shape(axis) * reps[axis];
+                sv[axis] = xt::range(0, e.shape(axis));
+            }
+            return_type out(new_shape);
+
+            xt::strided_view(out, sv) = e;
+
+            xt::xstrided_slice_vector svs(e.shape().size(), xt::all());
+            xt::xstrided_slice_vector svt(e.shape().size(), xt::all());
+
+            for (size_type axis = 0; axis < e.shape().size(); ++axis)
+            {
+                for (size_type i = 1; i < static_cast<size_type>(reps[axis]); ++i)
+                {
+                    svs[axis] = xt::range(0, e.shape(axis));
+                    svt[axis] = xt::range(i * e.shape(axis), (i + 1) * e.shape(axis));
+                    xt::strided_view(out, svt) = xt::strided_view(out, svs);
+                    svs[axis] = xt::all();
+                    svt[axis] = xt::all();
+                }
+            }
+
+            return out;
+        }
+    }
+
+    /**
+     * @brief Tile an array.
+     *
+     * @param e The array.
+     * @param reps The number of repetitions of A along each axis.
+     * @return The tiled array.
+     */
+
+    template <class E, class S = typename std::decay_t<E>::size_type>
+    inline auto tile(E&& e, std::initializer_list<S> reps)
+    {
+        return detail::tile(std::forward<E>(e), std::vector<S>{reps});
+    }
+
+    template <class E, class C, XTL_REQUIRES(std::negation<xtl::is_integral<C>>)>
+    inline auto tile(E&& e, const C& reps)
+    {
+        return detail::tile(std::forward<E>(e), reps);
+    }
+
+    /**
+     * @brief Tile an array.
+     *
+     * @param e The array.
+     * @param reps The number of repetitions of A along the first axis.
+     * @return The tiled array.
+     */
+    template <class E, class S = typename std::decay_t<E>::size_type, XTL_REQUIRES(xtl::is_integral<S>)>
+    inline auto tile(E&& e, S reps)
+    {
+        std::vector<S> tw(e.shape().size(), static_cast<S>(1));
+        tw[0] = reps;
+        return detail::tile(std::forward<E>(e), tw);
+    }
+}
+
+#endif
diff --git a/include/xtensor/misc/xset_operation.hpp b/include/xtensor/misc/xset_operation.hpp
new file mode 100644
index 000000000..94c64cd62
--- /dev/null
+++ b/include/xtensor/misc/xset_operation.hpp
@@ -0,0 +1,220 @@
+/***************************************************************************
+ * 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_XSET_OPERATION_HPP
+#define XTENSOR_XSET_OPERATION_HPP
+
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+
+#include <xtl/xsequence.hpp>
+
+#include "../containers/xscalar.hpp"
+#include "../core/xfunction.hpp"
+#include "../core/xmath.hpp"
+#include "../core/xstrides.hpp"
+#include "../utils/xutils.hpp"
+#include "../views/xstrided_view.hpp"
+
+namespace xt
+{
+    /**
+     * @defgroup searchsorted Searchsorted helpers
+     * @brief Helpers for locating insertion indices in sorted arrays.
+     */
+
+
+    namespace detail
+    {
+
+        template <bool lvalue>
+        struct lambda_isin
+        {
+            template <class E>
+            static auto make(E&& e)
+            {
+                return [&e](const auto& t)
+                {
+                    return std::find(e.begin(), e.end(), t) != e.end();
+                };
+            }
+        };
+
+        template <>
+        struct lambda_isin<false>
+        {
+            template <class E>
+            static auto make(E&& e)
+            {
+                return [e](const auto& t)
+                {
+                    return std::find(e.begin(), e.end(), t) != e.end();
+                };
+            }
+        };
+
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief isin
+     *
+     * Returns a boolean array of the same shape as ``element`` that is ``true`` where an element of
+     * ``element`` is in ``test_elements`` and ``False`` otherwise.
+     * @param element an \ref xexpression
+     * @param test_elements an array
+     * @return a boolean array
+     */
+    template <class E, class T>
+    inline auto isin(E&& element, std::initializer_list<T> test_elements) noexcept
+    {
+        auto lambda = [test_elements](const auto& t)
+        {
+            return std::find(test_elements.begin(), test_elements.end(), t) != test_elements.end();
+        };
+        return make_lambda_xfunction(std::move(lambda), std::forward<E>(element));
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief isin
+     *
+     * Returns a boolean array of the same shape as ``element`` that is ``true`` where an element of
+     * ``element`` is in ``test_elements`` and ``False`` otherwise.
+     * @param element an \ref xexpression
+     * @param test_elements an array
+     * @return a boolean array
+     */
+    template <class E, class F>
+    inline auto isin(E&& element, F&& test_elements) noexcept
+        requires(iterable_expression<F>)
+    {
+        auto lambda = detail::lambda_isin<std::is_lvalue_reference<F>::value>::make(std::forward<F>(test_elements
+        ));
+        return make_lambda_xfunction(std::move(lambda), std::forward<E>(element));
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief isin
+     *
+     * Returns a boolean array of the same shape as ``element`` that is ``true`` where an element of
+     * ``element`` is in ``test_elements`` and ``False`` otherwise.
+     * @param element an \ref xexpression
+     * @param test_elements_begin iterator to the beginning of an array
+     * @param test_elements_end iterator to the end of an array
+     * @return a boolean array
+     */
+    template <class E, std::forward_iterator I>
+    inline auto isin(E&& element, I&& test_elements_begin, I&& test_elements_end) noexcept
+    {
+        auto lambda = [&test_elements_begin, &test_elements_end](const auto& t)
+        {
+            return std::find(test_elements_begin, test_elements_end, t) != test_elements_end;
+        };
+        return make_lambda_xfunction(std::move(lambda), std::forward<E>(element));
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief in1d
+     *
+     * Returns a boolean array of the same shape as ``element`` that is ``true`` where an element of
+     * ``element`` is in ``test_elements`` and ``False`` otherwise.
+     * @param element an \ref xexpression
+     * @param test_elements an array
+     * @return a boolean array
+     */
+    template <class E, class T>
+    inline auto in1d(E&& element, std::initializer_list<T> test_elements) noexcept
+    {
+        XTENSOR_ASSERT(element.dimension() == 1ul);
+        return isin(std::forward<E>(element), std::forward<std::initializer_list<T>>(test_elements));
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief in1d
+     *
+     * Returns a boolean array of the same shape as ``element`` that is ``true`` where an element of
+     * ``element`` is in ``test_elements`` and ``False`` otherwise.
+     * @param element an \ref xexpression
+     * @param test_elements an array
+     * @return a boolean array
+     */
+    template <class E, class F>
+    inline auto in1d(E&& element, F&& test_elements) noexcept
+        requires(iterable_expression<F>)
+    {
+        XTENSOR_ASSERT(element.dimension() == 1ul);
+        XTENSOR_ASSERT(test_elements.dimension() == 1ul);
+        return isin(std::forward<E>(element), std::forward<F>(test_elements));
+    }
+
+    /**
+     * @ingroup logical_operators
+     * @brief in1d
+     *
+     * Returns a boolean array of the same shape as ``element`` that is ``true`` where an element of
+     * ``element`` is in ``test_elements`` and ``False`` otherwise.
+     * @param element an \ref xexpression
+     * @param test_elements_begin iterator to the beginning of an array
+     * @param test_elements_end iterator to the end of an array
+     * @return a boolean array
+     */
+    template <class E, std::forward_iterator I>
+    inline auto in1d(E&& element, I&& test_elements_begin, I&& test_elements_end) noexcept
+    {
+        XTENSOR_ASSERT(element.dimension() == 1ul);
+        return isin(
+            std::forward<E>(element),
+            std::forward<I>(test_elements_begin),
+            std::forward<I>(test_elements_end)
+        );
+    }
+
+    /**
+     * @ingroup searchsorted
+     * @brief Find indices where elements should be inserted to maintain order.
+     *
+     * @param a Input array: sorted (array_like).
+     * @param v Values to insert into a (array_like).
+     * @param right If ``false``, the index of the first suitable location found is given.
+     * @return Array of insertion points with the same shape as v.
+     */
+    template <class E1, class E2>
+    inline auto searchsorted(E1&& a, E2&& v, bool right = true)
+    {
+        XTENSOR_ASSERT(std::is_sorted(a.cbegin(), a.cend()));
+
+        auto out = xt::empty<size_t>(v.shape());
+
+        if (right)
+        {
+            for (size_t i = 0; i < v.size(); ++i)
+            {
+                out(i) = static_cast<std::size_t>(std::lower_bound(a.cbegin(), a.cend(), v(i)) - a.cbegin());
+            }
+        }
+        else
+        {
+            for (size_t i = 0; i < v.size(); ++i)
+            {
+                out(i) = static_cast<std::size_t>(std::upper_bound(a.cbegin(), a.cend(), v(i)) - a.cbegin());
+            }
+        }
+
+
+        return out;
+    }
+
+}
+
+#endif
diff --git a/include/xtensor/misc/xsort.hpp b/include/xtensor/misc/xsort.hpp
new file mode 100644
index 000000000..196ec45cd
--- /dev/null
+++ b/include/xtensor/misc/xsort.hpp
@@ -0,0 +1,1348 @@
+/***************************************************************************
+ * 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_SORT_HPP
+#define XTENSOR_SORT_HPP
+
+#include <algorithm>
+#include <cmath>
+#include <iterator>
+#include <utility>
+
+#include <xtl/xcompare.hpp>
+
+#include "../containers/xadapt.hpp"
+#include "../containers/xarray.hpp"
+#include "../containers/xtensor.hpp"
+#include "../core/xeval.hpp"
+#include "../core/xmath.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../misc/xmanipulation.hpp"
+#include "../views/xindex_view.hpp"
+#include "../views/xslice.hpp"  // for xnone
+#include "../views/xview.hpp"
+
+namespace xt
+{
+    /**
+     * @defgroup xt_xsort Sorting functions.
+     *
+     * Because sorting functions need to access the tensor data repeatedly, they evaluate their
+     * input and may allocate temporaries.
+     */
+
+    namespace detail
+    {
+        template <class T>
+        std::ptrdiff_t adjust_secondary_stride(std::ptrdiff_t stride, T shape)
+        {
+            return stride != 0 ? stride : static_cast<std::ptrdiff_t>(shape);
+        }
+
+        template <class E>
+        inline std::ptrdiff_t get_secondary_stride(const E& ev)
+        {
+            if (ev.layout() == layout_type::row_major)
+            {
+                return adjust_secondary_stride(ev.strides()[ev.dimension() - 2], *(ev.shape().end() - 1));
+            }
+
+            return adjust_secondary_stride(ev.strides()[1], *(ev.shape().begin()));
+        }
+
+        template <class E>
+        inline std::size_t leading_axis_n_iters(const E& ev)
+        {
+            if (ev.layout() == layout_type::row_major)
+            {
+                return std::accumulate(
+                    ev.shape().begin(),
+                    ev.shape().end() - 1,
+                    std::size_t(1),
+                    std::multiplies<>()
+                );
+            }
+            return std::accumulate(ev.shape().begin() + 1, ev.shape().end(), std::size_t(1), std::multiplies<>());
+        }
+
+        template <class E, class F>
+        inline void call_over_leading_axis(E& ev, F&& fct)
+        {
+            XTENSOR_ASSERT(ev.dimension() >= 2);
+
+            const std::size_t n_iters = leading_axis_n_iters(ev);
+            const std::ptrdiff_t secondary_stride = get_secondary_stride(ev);
+
+            const auto begin = ev.data();
+            const auto end = begin + n_iters * secondary_stride;
+            for (auto iter = begin; iter != end; iter += secondary_stride)
+            {
+                fct(iter, iter + secondary_stride);
+            }
+        }
+
+        template <class E1, class E2, class F>
+        inline void call_over_leading_axis(E1& e1, E2& e2, F&& fct)
+        {
+            XTENSOR_ASSERT(e1.dimension() >= 2);
+            XTENSOR_ASSERT(e1.dimension() == e2.dimension());
+
+            const std::size_t n_iters = leading_axis_n_iters(e1);
+            const std::ptrdiff_t secondary_stride1 = get_secondary_stride(e1);
+            const std::ptrdiff_t secondary_stride2 = get_secondary_stride(e2);
+            XTENSOR_ASSERT(secondary_stride1 == secondary_stride2);
+
+            const auto begin1 = e1.data();
+            const auto end1 = begin1 + n_iters * secondary_stride1;
+            const auto begin2 = e2.data();
+            const auto end2 = begin2 + n_iters * secondary_stride2;
+            auto iter1 = begin1;
+            auto iter2 = begin2;
+            for (; (iter1 != end1) && (iter2 != end2); iter1 += secondary_stride1, iter2 += secondary_stride2)
+            {
+                fct(iter1, iter1 + secondary_stride1, iter2, iter2 + secondary_stride2);
+            }
+        }
+
+        template <class E>
+        inline std::size_t leading_axis(const E& e)
+        {
+            if (e.layout() == layout_type::row_major)
+            {
+                return e.dimension() - 1;
+            }
+            else if (e.layout() == layout_type::column_major)
+            {
+                return 0;
+            }
+            XTENSOR_THROW(std::runtime_error, "Layout not supported.");
+        }
+
+        // get permutations to transpose and reverse-transpose array
+        inline std::pair<dynamic_shape<std::size_t>, dynamic_shape<std::size_t>>
+        get_permutations(std::size_t dim, std::size_t ax, layout_type layout)
+        {
+            dynamic_shape<std::size_t> permutation(dim);
+            std::iota(permutation.begin(), permutation.end(), std::size_t(0));
+            permutation.erase(permutation.begin() + std::ptrdiff_t(ax));
+
+            if (layout == layout_type::row_major)
+            {
+                permutation.push_back(ax);
+            }
+            else
+            {
+                permutation.insert(permutation.begin(), ax);
+            }
+
+            // TODO find a more clever way to get reverse permutation?
+            dynamic_shape<std::size_t> reverse_permutation;
+            for (std::size_t i = 0; i < dim; ++i)
+            {
+                auto it = std::find(permutation.begin(), permutation.end(), i);
+                reverse_permutation.push_back(std::size_t(std::distance(permutation.begin(), it)));
+            }
+
+            return std::make_pair(std::move(permutation), std::move(reverse_permutation));
+        }
+
+        template <class R, class E, class F>
+        inline R map_axis(const E& e, std::ptrdiff_t axis, F&& lambda)
+        {
+            if (e.dimension() == 1)
+            {
+                R res = e;
+                lambda(res.begin(), res.end());
+                return res;
+            }
+
+            const std::size_t ax = normalize_axis(e.dimension(), axis);
+            if (ax == detail::leading_axis(e))
+            {
+                R res = e;
+                detail::call_over_leading_axis(res, std::forward<F>(lambda));
+                return res;
+            }
+
+            dynamic_shape<std::size_t> permutation, reverse_permutation;
+            std::tie(permutation, reverse_permutation) = get_permutations(e.dimension(), ax, e.layout());
+            R res = transpose(e, permutation);
+            detail::call_over_leading_axis(res, std::forward<F>(lambda));
+            res = transpose(res, reverse_permutation);
+            return res;
+        }
+
+        template <class VT>
+        struct flatten_sort_result_type_impl
+        {
+            using type = VT;
+        };
+
+        template <class VT, std::size_t N, layout_type L>
+        struct flatten_sort_result_type_impl<xtensor<VT, N, L>>
+        {
+            using type = xtensor<VT, 1, L>;
+        };
+
+        template <class VT, class S, layout_type L>
+        struct flatten_sort_result_type_impl<xtensor_fixed<VT, S, L>>
+        {
+            using type = xtensor_fixed<VT, xshape<fixed_compute_size<S>::value>, L>;
+        };
+
+        template <class VT>
+        struct flatten_sort_result_type : flatten_sort_result_type_impl<common_tensor_type_t<VT>>
+        {
+        };
+
+        template <class VT>
+        using flatten_sort_result_type_t = typename flatten_sort_result_type<VT>::type;
+
+        template <class E, class R = flatten_sort_result_type_t<E>>
+        inline auto flat_sort_impl(const xexpression<E>& e)
+        {
+            const auto& de = e.derived_cast();
+            R ev;
+            ev.resize({static_cast<typename R::shape_type::value_type>(de.size())});
+
+            std::copy(de.cbegin(), de.cend(), ev.begin());
+            std::sort(ev.begin(), ev.end());
+
+            return ev;
+        }
+    }
+
+    template <class E>
+    inline auto sort(const xexpression<E>& e, placeholders::xtuph /*t*/)
+    {
+        return detail::flat_sort_impl(e);
+    }
+
+    namespace detail
+    {
+        template <class T>
+        struct sort_eval_type
+        {
+            using type = typename T::temporary_type;
+        };
+
+        template <class T, std::size_t... I, layout_type L>
+        struct sort_eval_type<xtensor_fixed<T, fixed_shape<I...>, L>>
+        {
+            using type = xtensor<T, sizeof...(I), L>;
+        };
+    }
+
+    /**
+     * Sort xexpression (optionally along axis)
+     * The sort is performed using the ``std::sort`` functions.
+     * A copy of the xexpression is created and returned.
+     *
+     * @ingroup xt_xsort
+     * @param e xexpression to sort
+     * @param axis axis along which sort is performed
+     *
+     * @return sorted array (copy)
+     */
+    template <class E>
+    inline auto sort(const xexpression<E>& e, std::ptrdiff_t axis = -1)
+    {
+        using eval_type = typename detail::sort_eval_type<E>::type;
+
+        return detail::map_axis<eval_type>(
+            e.derived_cast(),
+            axis,
+            [](auto begin, auto end)
+            {
+                std::sort(begin, end);
+            }
+        );
+    }
+
+    /*****************************
+     * Implementation of argsort *
+     *****************************/
+
+    /**
+     * Sorting method.
+     * Predefined methods for performing indirect sorting.
+     * @see argsort(const xexpression<E>&, std::ptrdiff_t, sorting_method)
+     */
+    enum class sorting_method
+    {
+        /**
+         *  Faster method but with no guarantee on preservation of order of equal elements
+         *  https://en.cppreference.com/w/cpp/algorithm/sort.
+         */
+        quick,
+        /**
+         *  Slower method but with guarantee on preservation of order of equal elements
+         *  https://en.cppreference.com/w/cpp/algorithm/stable_sort.
+         */
+        stable,
+    };
+
+    namespace detail
+    {
+        template <class ConstRandomIt, class RandomIt, class Compare, class Method>
+        inline void argsort_iter(
+            ConstRandomIt data_begin,
+            ConstRandomIt data_end,
+            RandomIt idx_begin,
+            RandomIt idx_end,
+            Compare comp,
+            Method method
+        )
+        {
+            XTENSOR_ASSERT(std::distance(data_begin, data_end) >= 0);
+            XTENSOR_ASSERT(std::distance(idx_begin, idx_end) == std::distance(data_begin, data_end));
+            (void) idx_end;  // TODO(C++17) [[maybe_unused]] only used in assertion.
+
+            std::iota(idx_begin, idx_end, 0);
+            switch (method)
+            {
+                case (sorting_method::quick):
+                {
+                    std::sort(
+                        idx_begin,
+                        idx_end,
+                        [&](const auto i, const auto j)
+                        {
+                            return comp(*(data_begin + i), *(data_begin + j));
+                        }
+                    );
+                }
+                case (sorting_method::stable):
+                {
+                    std::stable_sort(
+                        idx_begin,
+                        idx_end,
+                        [&](const auto i, const auto j)
+                        {
+                            return comp(*(data_begin + i), *(data_begin + j));
+                        }
+                    );
+                }
+            }
+        }
+
+        template <class ConstRandomIt, class RandomIt, class Method>
+        inline void
+        argsort_iter(ConstRandomIt data_begin, ConstRandomIt data_end, RandomIt idx_begin, RandomIt idx_end, Method method)
+        {
+            return argsort_iter(
+                std::move(data_begin),
+                std::move(data_end),
+                std::move(idx_begin),
+                std::move(idx_end),
+                [](const auto& x, const auto& y) -> bool
+                {
+                    return x < y;
+                },
+                method
+            );
+        }
+
+        template <class VT, class T>
+        struct rebind_value_type
+        {
+            using type = xarray<VT, xt::layout_type::dynamic>;
+        };
+
+        template <class VT, class EC, layout_type L>
+        struct rebind_value_type<VT, xarray<EC, L>>
+        {
+            using type = xarray<VT, L>;
+        };
+
+        template <class VT, class EC, std::size_t N, layout_type L>
+        struct rebind_value_type<VT, xtensor<EC, N, L>>
+        {
+            using type = xtensor<VT, N, L>;
+        };
+
+        template <class VT, class ET, class S, layout_type L>
+        struct rebind_value_type<VT, xtensor_fixed<ET, S, L>>
+        {
+            using type = xtensor_fixed<VT, S, L>;
+        };
+
+        template <class VT, class T>
+        struct flatten_rebind_value_type
+        {
+            using type = typename rebind_value_type<VT, T>::type;
+        };
+
+        template <class VT, class EC, std::size_t N, layout_type L>
+        struct flatten_rebind_value_type<VT, xtensor<EC, N, L>>
+        {
+            using type = xtensor<VT, 1, L>;
+        };
+
+        template <class VT, class ET, class S, layout_type L>
+        struct flatten_rebind_value_type<VT, xtensor_fixed<ET, S, L>>
+        {
+            using type = xtensor_fixed<VT, xshape<fixed_compute_size<S>::value>, L>;
+        };
+
+        template <class T>
+        struct argsort_result_type
+        {
+            using type = typename rebind_value_type<typename T::temporary_type::size_type, typename T::temporary_type>::type;
+        };
+
+        template <class T>
+        struct linear_argsort_result_type
+        {
+            using type = typename flatten_rebind_value_type<
+                typename T::temporary_type::size_type,
+                typename T::temporary_type>::type;
+        };
+
+        template <class E, class R = typename detail::linear_argsort_result_type<E>::type, class Method>
+        inline auto flatten_argsort_impl(const xexpression<E>& e, Method method)
+        {
+            const auto& de = e.derived_cast();
+
+            auto cit = de.template begin<layout_type::row_major>();
+            using const_iterator = decltype(cit);
+            auto ad = xiterator_adaptor<const_iterator, const_iterator>(cit, cit, de.size());
+
+            using result_type = R;
+            result_type result;
+            result.resize({de.size()});
+
+            detail::argsort_iter(de.cbegin(), de.cend(), result.begin(), result.end(), method);
+
+            return result;
+        }
+    }
+
+    template <class E>
+    inline auto
+    argsort(const xexpression<E>& e, placeholders::xtuph /*t*/, sorting_method method = sorting_method::quick)
+    {
+        return detail::flatten_argsort_impl(e, method);
+    }
+
+    /**
+     * Argsort xexpression (optionally along axis)
+     * Performs an indirect sort along the given axis. Returns an xarray
+     * of indices of the same shape as e that index data along the given axis in
+     * sorted order.
+     *
+     * @ingroup xt_xsort
+     * @param e xexpression to argsort
+     * @param axis axis along which argsort is performed
+     * @param method sorting algorithm to use
+     *
+     * @return argsorted index array
+     *
+     * @see xt::sorting_method
+     */
+    template <class E>
+    inline auto
+    argsort(const xexpression<E>& e, std::ptrdiff_t axis = -1, sorting_method method = sorting_method::quick)
+    {
+        using eval_type = typename detail::sort_eval_type<E>::type;
+        using result_type = typename detail::argsort_result_type<eval_type>::type;
+
+        const auto& de = e.derived_cast();
+
+        std::size_t ax = normalize_axis(de.dimension(), axis);
+
+        if (de.dimension() == 1)
+        {
+            return detail::flatten_argsort_impl<E, result_type>(e, method);
+        }
+
+        const auto argsort = [&method](auto res_begin, auto res_end, auto ev_begin, auto ev_end)
+        {
+            detail::argsort_iter(ev_begin, ev_end, res_begin, res_end, method);
+        };
+
+        if (ax == detail::leading_axis(de))
+        {
+            result_type res = result_type::from_shape(de.shape());
+            detail::call_over_leading_axis(res, de, argsort);
+            return res;
+        }
+
+        dynamic_shape<std::size_t> permutation, reverse_permutation;
+        std::tie(permutation, reverse_permutation) = detail::get_permutations(de.dimension(), ax, de.layout());
+        eval_type ev = transpose(de, permutation);
+        result_type res = result_type::from_shape(ev.shape());
+        detail::call_over_leading_axis(res, ev, argsort);
+        res = transpose(res, reverse_permutation);
+        return res;
+    }
+
+    /************************************************
+     * Implementation of partition and argpartition *
+     ************************************************/
+
+    namespace detail
+    {
+        /**
+         * Partition a given random iterator.
+         *
+         * @param data_begin Start of the data to partition.
+         * @param data_end Past end of the data to partition.
+         * @param kth_start Start of the indices to partition.
+         *        Indices must be sorted in decreasing order.
+         * @param kth_end Past end of the indices to partition.
+         *        Indices must be sorted in decreasing order.
+         * @param comp Comparison function for `x < y`.
+         */
+        template <class RandomIt, class Iter, class Compare>
+        inline void
+        partition_iter(RandomIt data_begin, RandomIt data_end, Iter kth_begin, Iter kth_end, Compare comp)
+        {
+            XTENSOR_ASSERT(std::distance(data_begin, data_end) >= 0);
+            XTENSOR_ASSERT(std::distance(kth_begin, kth_end) >= 0);
+
+            using idx_type = typename std::iterator_traits<Iter>::value_type;
+
+            idx_type k_last = static_cast<idx_type>(std::distance(data_begin, data_end));
+            for (; kth_begin != kth_end; ++kth_begin)
+            {
+                std::nth_element(data_begin, data_begin + *kth_begin, data_begin + k_last, std::move(comp));
+                k_last = *kth_begin;
+            }
+        }
+
+        template <class RandomIt, class Iter>
+        inline void partition_iter(RandomIt data_begin, RandomIt data_end, Iter kth_begin, Iter kth_end)
+        {
+            return partition_iter(
+                std::move(data_begin),
+                std::move(data_end),
+                std::move(kth_begin),
+                std::move(kth_end),
+                [](const auto& x, const auto& y) -> bool
+                {
+                    return x < y;
+                }
+            );
+        }
+    }
+
+    /**
+     * Partially sort xexpression
+     *
+     * Partition shuffles the xexpression in a way so that the kth element
+     * in the returned xexpression is in the place it would appear in a sorted
+     * array and all elements smaller than this entry are placed (unsorted) before.
+     *
+     * The optional third parameter can either be an axis or ``xnone()`` in which case
+     * the xexpression will be flattened.
+     *
+     * This function uses ``std::nth_element`` internally.
+     *
+     * @code{cpp}
+     * xt::xarray<float> a = {1, 10, -10, 123};
+     * std::cout << xt::partition(a, 0) << std::endl; // {-10, 1, 123, 10} the correct entry at index 0
+     * std::cout << xt::partition(a, 3) << std::endl; // {1, 10, -10, 123} the correct entry at index 3
+     * std::cout << xt::partition(a, {0, 3}) << std::endl; // {-10, 1, 10, 123} the correct entries at index 0
+     * and 3 \endcode
+     *
+     * @ingroup xt_xsort
+     * @param e input xexpression
+     * @param kth_container a container of ``indices`` that should contain the correctly sorted value
+     * @param ax placeholder indicating that the input is flattened before sorting
+     * sorting
+     *
+     * @return partially sorted xcontainer
+     */
+    template <class E, xtl::non_integral_concept C, class R = detail::flatten_sort_result_type_t<E>>
+    inline R partition(const xexpression<E>& e, C kth_container, placeholders::xtuph /*ax*/)
+    {
+        const auto& de = e.derived_cast();
+
+        R ev = R::from_shape({de.size()});
+        std::sort(kth_container.begin(), kth_container.end());
+
+        std::copy(de.linear_cbegin(), de.linear_cend(), ev.linear_begin());  // flatten
+
+        detail::partition_iter(ev.linear_begin(), ev.linear_end(), kth_container.rbegin(), kth_container.rend());
+
+        return ev;
+    }
+
+    template <class E, class I, std::size_t N, class R = detail::flatten_sort_result_type_t<E>>
+    inline R partition(const xexpression<E>& e, const I (&kth_container)[N], placeholders::xtuph tag)
+    {
+        return partition(
+            e,
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(kth_container)>(kth_container),
+            tag
+        );
+    }
+
+    template <class E, class R = detail::flatten_sort_result_type_t<E>>
+    inline R partition(const xexpression<E>& e, std::size_t kth, placeholders::xtuph tag)
+    {
+        return partition(e, std::array<std::size_t, 1>({kth}), tag);
+    }
+
+    template <class E, xtl::non_integral_concept C>
+    inline auto partition(const xexpression<E>& e, C kth_container, std::ptrdiff_t axis = -1)
+    {
+        using eval_type = typename detail::sort_eval_type<E>::type;
+
+        std::sort(kth_container.begin(), kth_container.end());
+
+        return detail::map_axis<eval_type>(
+            e.derived_cast(),
+            axis,
+            [&kth_container](auto begin, auto end)
+            {
+                detail::partition_iter(begin, end, kth_container.rbegin(), kth_container.rend());
+            }
+        );
+    }
+
+    template <class E, class T, std::size_t N>
+    inline auto partition(const xexpression<E>& e, const T (&kth_container)[N], std::ptrdiff_t axis = -1)
+    {
+        return partition(
+            e,
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(kth_container)>(kth_container),
+            axis
+        );
+    }
+
+    template <class E>
+    inline auto partition(const xexpression<E>& e, std::size_t kth, std::ptrdiff_t axis = -1)
+    {
+        return partition(e, std::array<std::size_t, 1>({kth}), axis);
+    }
+
+    /**
+     * Partially sort arguments
+     *
+     * Argpartition shuffles the indices to a xexpression in a way so that the index for the
+     * kth element in the returned xexpression is in the place it would appear in a sorted
+     * array and all elements smaller than this entry are placed (unsorted) before.
+     *
+     * The optional third parameter can either be an axis or ``xnone()`` in which case
+     * the xexpression will be flattened.
+     *
+     * This function uses ``std::nth_element`` internally.
+     *
+     * @code{cpp}
+     * xt::xarray<float> a = {1, 10, -10, 123};
+     * std::cout << xt::argpartition(a, 0) << std::endl; // {2, 0, 3, 1} the correct entry at index 0
+     * std::cout << xt::argpartition(a, 3) << std::endl; // {0, 1, 2, 3} the correct entry at index 3
+     * std::cout << xt::argpartition(a, {0, 3}) << std::endl; // {2, 0, 1, 3} the correct entries at index 0
+     * and 3 \endcode
+     *
+     * @ingroup xt_xsort
+     * @param e input xexpression
+     * @param kth_container a container of ``indices`` that should contain the correctly sorted value
+     * @param axis placeholder indicating that the input is flattened before sorting
+     * sorting
+     *
+     * @return xcontainer with indices of partial sort of input
+     */
+    template <
+        class E,
+        xtl::non_integral_concept C,
+        class R = typename detail::linear_argsort_result_type<typename detail::sort_eval_type<E>::type>::type>
+    inline R argpartition(const xexpression<E>& e, C kth_container, placeholders::xtuph)
+    {
+        using eval_type = typename detail::sort_eval_type<E>::type;
+        using result_type = typename detail::linear_argsort_result_type<eval_type>::type;
+
+        const auto& de = e.derived_cast();
+
+        result_type res = result_type::from_shape({de.size()});
+
+        std::sort(kth_container.begin(), kth_container.end());
+
+        std::iota(res.linear_begin(), res.linear_end(), 0);
+
+        detail::partition_iter(
+            res.linear_begin(),
+            res.linear_end(),
+            kth_container.rbegin(),
+            kth_container.rend(),
+            [&de](std::size_t a, std::size_t b)
+            {
+                return de[a] < de[b];
+            }
+        );
+
+        return res;
+    }
+
+    template <class E, class I, std::size_t N>
+    inline auto argpartition(const xexpression<E>& e, const I (&kth_container)[N], placeholders::xtuph tag)
+    {
+        return argpartition(
+            e,
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(kth_container)>(kth_container),
+            tag
+        );
+    }
+
+    template <class E>
+    inline auto argpartition(const xexpression<E>& e, std::size_t kth, placeholders::xtuph tag)
+    {
+        return argpartition(e, std::array<std::size_t, 1>({kth}), tag);
+    }
+
+    template <class E, xtl::non_integral_concept C>
+    inline auto argpartition(const xexpression<E>& e, C kth_container, std::ptrdiff_t axis = -1)
+    {
+        using eval_type = typename detail::sort_eval_type<E>::type;
+        using result_type = typename detail::argsort_result_type<eval_type>::type;
+
+        const auto& de = e.derived_cast();
+
+        if (de.dimension() == 1)
+        {
+            return argpartition<E, C, result_type>(e, std::forward<C>(kth_container), xnone());
+        }
+
+        std::sort(kth_container.begin(), kth_container.end());
+        const auto argpartition_w_kth =
+            [&kth_container](auto res_begin, auto res_end, auto ev_begin, auto /*ev_end*/)
+        {
+            std::iota(res_begin, res_end, 0);
+            detail::partition_iter(
+                res_begin,
+                res_end,
+                kth_container.rbegin(),
+                kth_container.rend(),
+                [&ev_begin](auto const& i, auto const& j)
+                {
+                    return *(ev_begin + i) < *(ev_begin + j);
+                }
+            );
+        };
+
+        const std::size_t ax = normalize_axis(de.dimension(), axis);
+        if (ax == detail::leading_axis(de))
+        {
+            result_type res = result_type::from_shape(de.shape());
+            detail::call_over_leading_axis(res, de, argpartition_w_kth);
+            return res;
+        }
+
+        dynamic_shape<std::size_t> permutation, reverse_permutation;
+        std::tie(permutation, reverse_permutation) = detail::get_permutations(de.dimension(), ax, de.layout());
+        eval_type ev = transpose(de, permutation);
+        result_type res = result_type::from_shape(ev.shape());
+        detail::call_over_leading_axis(res, ev, argpartition_w_kth);
+        res = transpose(res, reverse_permutation);
+        return res;
+    }
+
+    template <class E, class I, std::size_t N>
+    inline auto argpartition(const xexpression<E>& e, const I (&kth_container)[N], std::ptrdiff_t axis = -1)
+    {
+        return argpartition(
+            e,
+            xtl::forward_sequence<std::array<std::size_t, N>, decltype(kth_container)>(kth_container),
+            axis
+        );
+    }
+
+    template <class E>
+    inline auto argpartition(const xexpression<E>& e, std::size_t kth, std::ptrdiff_t axis = -1)
+    {
+        return argpartition(e, std::array<std::size_t, 1>({kth}), axis);
+    }
+
+    /******************
+     *  xt::quantile  *
+     ******************/
+
+    namespace detail
+    {
+        template <class S, class I, class K, class O>
+        inline void select_indices_impl(
+            const S& shape,
+            const I& indices,
+            std::size_t axis,
+            std::size_t current_dim,
+            const K& current_index,
+            O& out
+        )
+        {
+            using id_t = typename K::value_type;
+            if ((current_dim < shape.size() - 1) && (current_dim == axis))
+            {
+                for (auto i : indices)
+                {
+                    auto idx = current_index;
+                    idx[current_dim] = i;
+                    select_indices_impl(shape, indices, axis, current_dim + 1, idx, out);
+                }
+            }
+            else if ((current_dim < shape.size() - 1) && (current_dim != axis))
+            {
+                for (id_t i = 0; xtl::cmp_less(i, shape[current_dim]); ++i)
+                {
+                    auto idx = current_index;
+                    idx[current_dim] = i;
+                    select_indices_impl(shape, indices, axis, current_dim + 1, idx, out);
+                }
+            }
+            else if ((current_dim == shape.size() - 1) && (current_dim == axis))
+            {
+                for (auto i : indices)
+                {
+                    auto idx = current_index;
+                    idx[current_dim] = i;
+                    out.push_back(std::move(idx));
+                }
+            }
+            else if ((current_dim == shape.size() - 1) && (current_dim != axis))
+            {
+                for (id_t i = 0; xtl::cmp_less(i, shape[current_dim]); ++i)
+                {
+                    auto idx = current_index;
+                    idx[current_dim] = i;
+                    out.push_back(std::move(idx));
+                }
+            }
+        }
+
+        template <class S, class I>
+        inline auto select_indices(const S& shape, const I& indices, std::size_t axis)
+        {
+            using index_type = get_strides_t<S>;
+            auto out = std::vector<index_type>();
+            select_indices_impl(shape, indices, axis, 0, xtl::make_sequence<index_type>(shape.size()), out);
+            return out;
+        }
+
+        // TODO remove when fancy index views are implemented
+        // Poor man's indexing along a single axis as in NumPy a[:, [1, 3, 4]]
+        template <class E, class I>
+        inline auto fancy_indexing(E&& e, const I& indices, std::ptrdiff_t axis)
+        {
+            const std::size_t ax = normalize_axis(e.dimension(), axis);
+            using shape_t = get_strides_t<typename std::decay_t<E>::shape_type>;
+            auto shape = xtl::forward_sequence<shape_t, decltype(e.shape())>(e.shape());
+            shape[ax] = indices.size();
+            return reshape_view(
+                index_view(std::forward<E>(e), select_indices(e.shape(), indices, ax)),
+                std::move(shape)
+            );
+        }
+
+        template <class T, class I, class P>
+        inline auto quantile_kth_gamma(std::size_t n, const P& probas, T alpha, T beta)
+        {
+            const auto m = alpha + probas * (T(1) - alpha - beta);
+            // Evaluting since reused a lot
+            const auto p_n_m = eval(probas * static_cast<T>(n) + m - 1);
+            // Previous (virtual) index, may be out of bounds
+            const auto j = floor(p_n_m);
+            const auto j_jp1 = concatenate(xtuple(j, j + 1));
+            // Both interpolation indices, k and k+1
+            const auto k_kp1 = xt::cast<std::size_t>(clip(j_jp1, T(0), T(n - 1)));
+            // Both interpolation coefficients, 1-gamma and gamma
+            const auto omg_g = concatenate(xtuple(T(1) - (p_n_m - j), p_n_m - j));
+            return std::make_pair(eval(k_kp1), eval(omg_g));
+        }
+
+        // TODO should implement unsqueeze rather
+        template <class S>
+        inline auto unsqueeze_shape(const S& shape, std::size_t axis)
+        {
+            XTENSOR_ASSERT(axis <= shape.size());
+            auto new_shape = xtl::forward_sequence<xt::svector<std::size_t>, decltype(shape)>(shape);
+            new_shape.insert(new_shape.begin() + axis, 1);
+            return new_shape;
+        }
+    }
+
+    /**
+     * Compute quantiles over the given axis.
+     *
+     * In a sorted array represneting a distribution of numbers, the quantile of a probability ``p``
+     * is the the cut value ``q`` such that a fraction ``p`` of the distribution is lesser or equal
+     * to ``q``.
+     * When the cutpoint falls between two elemnts of the sample distribution, a interpolation is
+     * computed using the @p alpha and @p beta coefficients, as descripted in
+     * (Hyndman and Fan, 1996).
+     *
+     * The algorithm partially sorts entries in a copy along the @p axis axis.
+     *
+     * @ingroup xt_xsort
+     * @param e Expression containing the distribution over which the quantiles are computed.
+     * @param probas An list of probability associated with each desired quantiles.
+     *        All elements must be in the range ``[0, 1]``.
+     * @param axis The dimension in which to compute the quantiles, *i.e* the axis representing the
+     *        distribution.
+     * @param alpha Interpolation parameter. Must be in the range ``[0, 1]]``.
+     * @param beta Interpolation parameter. Must be in the range ``[0, 1]]``.
+     * @tparam T The type in which the quantile are computed.
+     * @return An expression with as many dimensions as the input @p e.
+     *         The first axis correspond to the quantiles.
+     *         The other axes are the axes that remain after the reduction of @p e.
+     * @see (Hyndman and Fan, 1996) R. J. Hyndman and Y. Fan,
+     *      "Sample quantiles in statistical packages", The American Statistician,
+     *      50(4), pp. 361-365, 1996
+     * @see https://en.wikipedia.org/wiki/Quantile
+     */
+    template <class T = double, class E, class P>
+    inline auto quantile(E&& e, const P& probas, std::ptrdiff_t axis, T alpha, T beta)
+    {
+        XTENSOR_ASSERT(all(0. <= probas));
+        XTENSOR_ASSERT(all(probas <= 1.));
+        XTENSOR_ASSERT(0. <= alpha);
+        XTENSOR_ASSERT(alpha <= 1.);
+        XTENSOR_ASSERT(0. <= beta);
+        XTENSOR_ASSERT(beta <= 1.);
+
+        using tmp_shape_t = get_strides_t<typename std::decay_t<E>::shape_type>;
+        using id_t = typename tmp_shape_t::value_type;
+
+        const std::size_t ax = normalize_axis(e.dimension(), axis);
+        const std::size_t n = e.shape()[ax];
+        auto kth_gamma = detail::quantile_kth_gamma<T, id_t, P>(n, probas, alpha, beta);
+
+        // Select relevant values for computing interpolating quantiles
+        auto e_partition = xt::partition(std::forward<E>(e), kth_gamma.first, ax);
+        auto e_kth = detail::fancy_indexing(std::move(e_partition), std::move(kth_gamma.first), ax);
+
+        // Reshape interpolation coefficients
+        auto gm1_g_shape = xtl::make_sequence<tmp_shape_t>(e.dimension(), 1);
+        gm1_g_shape[ax] = kth_gamma.second.size();
+        auto gm1_g_reshaped = reshape_view(std::move(kth_gamma.second), std::move(gm1_g_shape));
+
+        // Compute interpolation
+        // TODO(C++20) use (and create) xt::lerp in C++
+        auto e_kth_g = std::move(e_kth) * std::move(gm1_g_reshaped);
+        // Reshape pairwise interpolate for suming along new axis
+        auto e_kth_g_shape = detail::unsqueeze_shape(e_kth_g.shape(), ax);
+        e_kth_g_shape[ax] = 2;
+        e_kth_g_shape[ax + 1] /= 2;
+        auto quantiles = xt::sum(reshape_view(std::move(e_kth_g), std::move(e_kth_g_shape)), ax);
+        // Cannot do a transpose on a non-strided expression so we have to eval
+        return moveaxis(eval(std::move(quantiles)), ax, 0);
+    }
+
+    // Static proba array overload
+    template <class T = double, class E, std::size_t N>
+    inline auto quantile(E&& e, const T (&probas)[N], std::ptrdiff_t axis, T alpha, T beta)
+    {
+        return quantile(std::forward<E>(e), adapt(probas, {N}), axis, alpha, beta);
+    }
+
+    /**
+     * Compute quantiles of the whole expression.
+     *
+     * The quantiles are computed over the whole expression, as if flatten in a one-dimensional
+     * expression.
+     *
+     * @ingroup xt_xsort
+     * @see xt::quantile(E&& e, P const& probas, std::ptrdiff_t axis, T alpha, T beta)
+     */
+    template <class T = double, class E, class P>
+    inline auto quantile(E&& e, const P& probas, T alpha, T beta)
+    {
+        return quantile(xt::ravel(std::forward<E>(e)), probas, 0, alpha, beta);
+    }
+
+    // Static proba array overload
+    template <class T = double, class E, std::size_t N>
+    inline auto quantile(E&& e, const T (&probas)[N], T alpha, T beta)
+    {
+        return quantile(std::forward<E>(e), adapt(probas, {N}), alpha, beta);
+    }
+
+    /**
+     * Quantile interpolation method.
+     *
+     * Predefined methods for interpolating quantiles, as defined in (Hyndman and Fan, 1996).
+     *
+     * @ingroup xt_xsort
+     * @see (Hyndman and Fan, 1996) R. J. Hyndman and Y. Fan,
+     *      "Sample quantiles in statistical packages", The American Statistician,
+     *      50(4), pp. 361-365, 1996
+     * @see xt::quantile(E&& e, P const& probas, std::ptrdiff_t axis, xt::quantile_method method)
+     */
+    enum class quantile_method
+    {
+        /** Method 4 of (Hyndman and Fan, 1996) with ``alpha=0`` and ``beta=1``. */
+        interpolated_inverted_cdf = 4,
+        /** Method 5 of (Hyndman and Fan, 1996) with ``alpha=1/2`` and ``beta=1/2``. */
+        hazen,
+        /** Method 6 of (Hyndman and Fan, 1996) with ``alpha=0`` and ``beta=0``. */
+        weibull,
+        /** Method 7 of (Hyndman and Fan, 1996) with ``alpha=1`` and ``beta=1``. */
+        linear,
+        /** Method 8 of (Hyndman and Fan, 1996) with ``alpha=1/3`` and ``beta=1/3``. */
+        median_unbiased,
+        /** Method 9 of (Hyndman and Fan, 1996) with ``alpha=3/8`` and ``beta=3/8``. */
+        normal_unbiased,
+    };
+
+    /**
+     * Compute quantiles over the given axis.
+     *
+     * The function takes the name of a predefined method to compute to interpolate between values.
+     *
+     * @ingroup xt_xsort
+     * @see xt::quantile_method
+     * @see xt::quantile(E&& e, P const& probas, std::ptrdiff_t axis, T alpha, T beta)
+     */
+    template <class T = double, class E, class P>
+    inline auto
+    quantile(E&& e, const P& probas, std::ptrdiff_t axis, quantile_method method = quantile_method::linear)
+    {
+        T alpha = 0.;
+        T beta = 0.;
+        switch (method)
+        {
+            case (quantile_method::interpolated_inverted_cdf):
+            {
+                alpha = 0.;
+                beta = 1.;
+                break;
+            }
+            case (quantile_method::hazen):
+            {
+                alpha = 0.5;
+                beta = 0.5;
+                break;
+            }
+            case (quantile_method::weibull):
+            {
+                alpha = 0.;
+                beta = 0.;
+                break;
+            }
+            case (quantile_method::linear):
+            {
+                alpha = 1.;
+                beta = 1.;
+                break;
+            }
+            case (quantile_method::median_unbiased):
+            {
+                alpha = 1. / 3.;
+                beta = 1. / 3.;
+                break;
+            }
+            case (quantile_method::normal_unbiased):
+            {
+                alpha = 3. / 8.;
+                beta = 3. / 8.;
+                break;
+            }
+        }
+        return quantile(std::forward<E>(e), probas, axis, alpha, beta);
+    }
+
+    // Static proba array overload
+    template <class T = double, class E, std::size_t N>
+    inline auto
+    quantile(E&& e, const T (&probas)[N], std::ptrdiff_t axis, quantile_method method = quantile_method::linear)
+    {
+        return quantile(std::forward<E>(e), adapt(probas, {N}), axis, method);
+    }
+
+    /**
+     * Compute quantiles of the whole expression.
+     *
+     * The quantiles are computed over the whole expression, as if flatten in a one-dimensional
+     * expression.
+     * The function takes the name of a predefined method to compute to interpolate between values.
+     *
+     * @ingroup xt_xsort
+     * @see xt::quantile_method
+     * @see xt::quantile(E&& e, P const& probas, std::ptrdiff_t axis, xt::quantile_method method)
+     */
+    template <class T = double, class E, class P>
+    inline auto quantile(E&& e, const P& probas, quantile_method method = quantile_method::linear)
+    {
+        return quantile(xt::ravel(std::forward<E>(e)), probas, 0, method);
+    }
+
+    // Static proba array overload
+    template <class T = double, class E, std::size_t N>
+    inline auto quantile(E&& e, const T (&probas)[N], quantile_method method = quantile_method::linear)
+    {
+        return quantile(std::forward<E>(e), adapt(probas, {N}), method);
+    }
+
+    /****************
+     *  xt::median  *
+     ****************/
+
+    template <class E>
+    inline typename std::decay_t<E>::value_type median(E&& e)
+    {
+        using value_type = typename std::decay_t<E>::value_type;
+        auto sz = e.size();
+        if (sz % 2 == 0)
+        {
+            std::size_t szh = sz / 2;  // integer floor div
+            std::array<std::size_t, 2> kth = {szh - 1, szh};
+            auto values = xt::partition(xt::flatten(e), kth);
+            return (values[kth[0]] + values[kth[1]]) / value_type(2);
+        }
+        else
+        {
+            std::array<std::size_t, 1> kth = {(sz - 1) / 2};
+            auto values = xt::partition(xt::flatten(e), kth);
+            return values[kth[0]];
+        }
+    }
+
+    /**
+     * Find the median along the specified axis
+     *
+     * Given a vector V of length N, the median of V is the middle value of a
+     * sorted copy of V, V_sorted - i e., V_sorted[(N-1)/2], when N is odd,
+     * and the average of the two middle values of V_sorted when N is even.
+     *
+     * @ingroup xt_xsort
+     * @param axis axis along which the medians are computed.
+     *             If not set, computes the median along a flattened version of the input.
+     * @param e input xexpression
+     * @return median value
+     */
+    template <class E>
+    inline auto median(E&& e, std::ptrdiff_t axis)
+    {
+        std::size_t ax = normalize_axis(e.dimension(), axis);
+        std::size_t sz = e.shape()[ax];
+        xstrided_slice_vector sv(e.dimension(), xt::all());
+
+        if (sz % 2 == 0)
+        {
+            std::size_t szh = sz / 2;  // integer floor div
+            std::array<std::size_t, 2> kth = {szh - 1, szh};
+            auto values = xt::partition(std::forward<E>(e), kth, static_cast<ptrdiff_t>(ax));
+            sv[ax] = xt::range(szh - 1, szh + 1);
+            return xt::mean(xt::strided_view(std::move(values), std::move(sv)), {ax});
+        }
+        else
+        {
+            std::size_t szh = (sz - 1) / 2;
+            std::array<std::size_t, 1> kth = {(sz - 1) / 2};
+            auto values = xt::partition(std::forward<E>(e), kth, static_cast<ptrdiff_t>(ax));
+            sv[ax] = xt::range(szh, szh + 1);
+            return xt::mean(xt::strided_view(std::move(values), std::move(sv)), {ax});
+        }
+    }
+
+    namespace detail
+    {
+        template <class T>
+        struct argfunc_result_type
+        {
+            using type = xarray<std::size_t>;
+        };
+
+        template <class T, std::size_t N>
+        struct argfunc_result_type<xtensor<T, N>>
+        {
+            using type = xtensor<std::size_t, N - 1>;
+        };
+
+        template <layout_type L, class E, class F>
+        inline typename argfunc_result_type<E>::type arg_func_impl(const E& e, std::size_t axis, F&& cmp)
+        {
+            using eval_type = typename detail::sort_eval_type<E>::type;
+            using value_type = typename E::value_type;
+            using result_type = typename argfunc_result_type<E>::type;
+            using result_shape_type = typename result_type::shape_type;
+
+            if (e.dimension() == 1)
+            {
+                auto begin = e.template begin<L>();
+                auto end = e.template end<L>();
+                // todo C++17 : constexpr
+                if (std::is_same<F, std::less<value_type>>::value)
+                {
+                    std::size_t i = static_cast<std::size_t>(std::distance(begin, std::min_element(begin, end)));
+                    return xtensor<size_t, 0>{i};
+                }
+                else
+                {
+                    std::size_t i = static_cast<std::size_t>(std::distance(begin, std::max_element(begin, end)));
+                    return xtensor<size_t, 0>{i};
+                }
+            }
+
+            result_shape_type alt_shape;
+            xt::resize_container(alt_shape, e.dimension() - 1);
+
+            // Excluding copy, copy all of shape except for axis
+            std::copy(e.shape().cbegin(), e.shape().cbegin() + std::ptrdiff_t(axis), alt_shape.begin());
+            std::copy(
+                e.shape().cbegin() + std::ptrdiff_t(axis) + 1,
+                e.shape().cend(),
+                alt_shape.begin() + std::ptrdiff_t(axis)
+            );
+
+            result_type result = result_type::from_shape(std::move(alt_shape));
+            auto result_iter = result.template begin<L>();
+
+            auto arg_func_lambda = [&result_iter, &cmp](auto begin, auto end)
+            {
+                std::size_t idx = 0;
+                value_type val = *begin;
+                ++begin;
+                for (std::size_t i = 1; begin != end; ++begin, ++i)
+                {
+                    if (cmp(*begin, val))
+                    {
+                        val = *begin;
+                        idx = i;
+                    }
+                }
+                *result_iter = idx;
+                ++result_iter;
+            };
+
+            if (axis != detail::leading_axis(e))
+            {
+                dynamic_shape<std::size_t> permutation, reverse_permutation;
+                std::tie(
+                    permutation,
+                    reverse_permutation
+                ) = detail::get_permutations(e.dimension(), axis, e.layout());
+
+                // note: creating copy
+                eval_type input = transpose(e, permutation);
+                detail::call_over_leading_axis(input, arg_func_lambda);
+                return result;
+            }
+            else
+            {
+                auto&& input = eval(e);
+                detail::call_over_leading_axis(input, arg_func_lambda);
+                return result;
+            }
+        }
+    }
+
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E>
+    inline auto argmin(const xexpression<E>& e)
+    {
+        using value_type = typename E::value_type;
+        auto&& ed = eval(e.derived_cast());
+        auto begin = ed.template begin<L>();
+        auto end = ed.template end<L>();
+        std::size_t i = static_cast<std::size_t>(std::distance(begin, std::min_element(begin, end)));
+        return xtensor<size_t, 0>{i};
+    }
+
+    /**
+     * Find position of minimal value in xexpression.
+     * By default, the returned index is into the flattened array.
+     * If `axis` is specified, the indices are along the specified axis.
+     *
+     * @param e input xexpression
+     * @param axis select axis (optional)
+     *
+     * @return returns xarray with positions of minimal value
+     */
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E>
+    inline auto argmin(const xexpression<E>& e, std::ptrdiff_t axis)
+    {
+        using value_type = typename E::value_type;
+        auto&& ed = eval(e.derived_cast());
+        std::size_t ax = normalize_axis(ed.dimension(), axis);
+        return detail::arg_func_impl<L>(ed, ax, std::less<value_type>());
+    }
+
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E>
+    inline auto argmax(const xexpression<E>& e)
+    {
+        using value_type = typename E::value_type;
+        auto&& ed = eval(e.derived_cast());
+        auto begin = ed.template begin<L>();
+        auto end = ed.template end<L>();
+        std::size_t i = static_cast<std::size_t>(std::distance(begin, std::max_element(begin, end)));
+        return xtensor<size_t, 0>{i};
+    }
+
+    /**
+     * Find position of maximal value in xexpression
+     * By default, the returned index is into the flattened array.
+     * If `axis` is specified, the indices are along the specified axis.
+     *
+     * @ingroup xt_xsort
+     * @param e input xexpression
+     * @param axis select axis (optional)
+     *
+     * @return returns xarray with positions of maximal value
+     */
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E>
+    inline auto argmax(const xexpression<E>& e, std::ptrdiff_t axis)
+    {
+        using value_type = typename E::value_type;
+        auto&& ed = eval(e.derived_cast());
+        std::size_t ax = normalize_axis(ed.dimension(), axis);
+        return detail::arg_func_impl<L>(ed, ax, std::greater<value_type>());
+    }
+
+    /**
+     * Find unique elements of a xexpression. This returns a flattened xtensor with
+     * sorted, unique elements from the original expression.
+     *
+     * @ingroup xt_xsort
+     * @param e input xexpression (will be flattened)
+     */
+    template <class E>
+    inline auto unique(const xexpression<E>& e)
+    {
+        auto sorted = sort(e, xnone());
+        auto end = std::unique(sorted.begin(), sorted.end());
+        std::size_t sz = static_cast<std::size_t>(std::distance(sorted.begin(), end));
+        // TODO check if we can shrink the vector without reallocation
+        using value_type = typename E::value_type;
+        auto result = xtensor<value_type, 1>::from_shape({sz});
+        std::copy(sorted.begin(), end, result.begin());
+        return result;
+    }
+
+    /**
+     * Find the set difference of two xexpressions. This returns a flattened xtensor with
+     * the sorted, unique values in ar1 that are not in ar2.
+     *
+     * @ingroup xt_xsort
+     * @param ar1 input xexpression (will be flattened)
+     * @param ar2 input xexpression
+     */
+    template <class E1, class E2>
+    inline auto setdiff1d(const xexpression<E1>& ar1, const xexpression<E2>& ar2)
+    {
+        using value_type = typename E1::value_type;
+
+        auto unique1 = unique(ar1);
+        auto unique2 = unique(ar2);
+
+        auto tmp = xtensor<value_type, 1>::from_shape({unique1.size()});
+
+        auto end = std::set_difference(unique1.begin(), unique1.end(), unique2.begin(), unique2.end(), tmp.begin());
+
+        std::size_t sz = static_cast<std::size_t>(std::distance(tmp.begin(), end));
+
+        auto result = xtensor<value_type, 1>::from_shape({sz});
+
+        std::copy(tmp.begin(), end, result.begin());
+
+        return result;
+    }
+}
+
+#endif
diff --git a/include/xtensor/misc/xtl_concepts.hpp b/include/xtensor/misc/xtl_concepts.hpp
new file mode 100644
index 000000000..22ef7b212
--- /dev/null
+++ b/include/xtensor/misc/xtl_concepts.hpp
@@ -0,0 +1,31 @@
+/***************************************************************************
+ * 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_CONCEPTS_HPP
+#define XTENSOR_CONCEPTS_HPP
+
+#include <xtl/xcomplex.hpp>
+#include <xtl/xtype_traits.hpp>
+
+namespace xtl
+{
+    template <typename T>
+    concept integral_concept = xtl::is_integral<T>::value;
+
+    template <typename T>
+    concept non_integral_concept = !xtl::is_integral<T>::value;
+
+    template <typename T>
+    concept complex_concept = xtl::is_complex<typename std::decay<T>::type::value_type>::value;
+
+    template <typename T>
+    concept pointer_concept = std::is_pointer<T>::value;
+}
+
+#endif  // XTENSOR_CONCEPTS_HPP
diff --git a/include/xtensor/xoptional.hpp b/include/xtensor/optional/xoptional.hpp
similarity index 69%
rename from include/xtensor/xoptional.hpp
rename to include/xtensor/optional/xoptional.hpp
index 228e7e257..6c690b0d6 100644
--- a/include/xtensor/xoptional.hpp
+++ b/include/xtensor/optional/xoptional.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_OPTIONAL_HPP
 #define XTENSOR_OPTIONAL_HPP
@@ -15,17 +16,18 @@
 #include <xtl/xoptional.hpp>
 #include <xtl/xoptional_sequence.hpp>
 
-#include "xarray.hpp"
-#include "xbroadcast.hpp"
-#include "xdynamic_view.hpp"
-#include "xfunctor_view.hpp"
-#include "xgenerator.hpp"
-#include "xindex_view.hpp"
-#include "xreducer.hpp"
-#include "xscalar.hpp"
-#include "xstrided_view.hpp"
-#include "xtensor.hpp"
-#include "xview.hpp"
+#include "../containers/xarray.hpp"
+#include "../containers/xscalar.hpp"
+#include "../containers/xtensor.hpp"
+#include "../generators/xgenerator.hpp"
+#include "../reducers/xreducer.hpp"
+#include "../views/xbroadcast.hpp"
+#include "../views/xdynamic_view.hpp"
+#include "../views/xfunctor_view.hpp"
+#include "../views/xindex_view.hpp"
+#include "../views/xrepeat.hpp"
+#include "../views/xstrided_view.hpp"
+#include "../views/xview.hpp"
 
 namespace xt
 {
@@ -78,13 +80,13 @@ namespace xt
             using flag_expression = decltype(ones<bool>(std::declval<T>().shape()));
 
             template <class U>
-            static inline U&& value(U&& arg)
+            inline static U&& value(U&& arg)
             {
                 return std::forward<U>(arg);
             }
 
             template <class U>
-            static inline flag_expression has_value(U&& arg)
+            inline static flag_expression has_value(U&& arg)
             {
                 return ones<bool>(arg.shape());
             }
@@ -97,13 +99,13 @@ namespace xt
             using flag_expression = xscalar<bool>;
 
             template <class U>
-            static inline U&& value(U&& arg)
+            inline static U&& value(U&& arg)
             {
                 return std::forward<U>(arg);
             }
 
             template <class U>
-            static inline flag_expression has_value(U&&)
+            inline static flag_expression has_value(U&&)
             {
                 return xscalar<bool>(true);
             }
@@ -115,21 +117,21 @@ namespace xt
             static constexpr bool is_const = std::is_const<std::remove_reference_t<T>>::value;
             using decay_type = std::decay_t<T>;
 
-            using value_expression = std::conditional_t<is_const,
-                                                        typename decay_type::const_value_expression,
-                                                        typename decay_type::value_expression>;
-            using flag_expression = std::conditional_t<is_const,
-                                                       typename decay_type::const_flag_expression,
-                                                       typename decay_type::flag_expression>;
+            using value_expression = std::conditional_t<
+                is_const,
+                typename decay_type::const_value_expression,
+                typename decay_type::value_expression>;
+            using flag_expression = std::
+                conditional_t<is_const, typename decay_type::const_flag_expression, typename decay_type::flag_expression>;
 
             template <class U>
-            static inline value_expression value(U&& arg)
+            inline static value_expression value(U&& arg)
             {
                 return arg.value();
             }
 
             template <class U>
-            static inline flag_expression has_value(U&& arg)
+            inline static flag_expression has_value(U&& arg)
             {
                 return arg.has_value();
             }
@@ -164,25 +166,84 @@ namespace xt
          ********************/
 
         template <class T = bool>
-        struct optional_bitwise
+        class optional_bitwise
         {
+        public:
+
             using return_type = T;
             using first_argument_type = T;
             using second_argument_type = T;
             using result_type = T;
             using simd_value_type = bool;
             using simd_result_type = bool;
-            template <class T1, class T2>
-            constexpr result_type operator()(const T1& arg1, const T2& arg2) const
+
+            template <class... Args>
+            constexpr result_type operator()(const Args&... args) const
+            {
+                return apply_impl(args...);
+            }
+
+            template <class B, class... Args>
+            constexpr B simd_apply(const B& b, const Args&... args) const
+            {
+                return simd_apply_impl(b, args...);
+            }
+
+        private:
+
+            constexpr result_type apply_impl() const
+            {
+                return true;
+            }
+
+            template <class U, class... Args>
+            constexpr result_type apply_impl(const U& t, const Args&... args) const
+            {
+                return t & apply_impl(args...);
+            }
+
+            template <class B>
+            constexpr B simd_apply_impl(const B& b) const
+            {
+                return b;
+            }
+
+            template <class B1, class B2, class... Args>
+            constexpr B1 simd_apply_impl(const B1& b1, const B2& b2, const Args&... args) const
             {
-                return (arg1 & arg2);
+                return b1 & simd_apply_impl(b2, args...);
             }
-            constexpr simd_result_type simd_apply(const simd_value_type& arg1,
-                                                  const simd_value_type& arg2) const
+        };
+
+        /*********************************
+         * optional const_value rebinder *
+         *********************************/
+
+        template <class T, class B>
+        struct const_value_rebinder<xtl::xoptional<T, B>, T>
+        {
+            static const_value<T> run(const const_value<xtl::xoptional<T, B>>& src)
             {
-                return (arg1 & arg2);
+                return const_value<T>(src.m_value.value());
             }
         };
+
+        /**************************
+         * xreducer types helpers *
+         **************************/
+
+        template <class T, class B>
+        struct xreducer_size_type<xtl::xoptional<T, B>>
+        {
+            using type = xtl::xoptional<std::size_t, bool>;
+        };
+
+        template <class T, class B>
+        struct xreducer_temporary_type<xtl::xoptional<T, B>>
+        {
+            using type = xtl::xoptional<std::decay_t<T>, bool>;
+            ;
+        };
     }
 
     /**********************
@@ -192,11 +253,11 @@ namespace xt
     template <class T, class B>
     auto sign(const xtl::xoptional<T, B>& e);
 
-    template <class E, XTENSOR_REQUIRE<is_xexpression<E>::value>>
+    /*template <class E, XTL_REQUIRES(is_xexpression<E>)>
     detail::value_expression_t<E> value(E&&);
 
-    template <class E, XTENSOR_REQUIRE<is_xexpression<E>::value>>
-    detail::flag_expression_t<E> has_value(E&&);
+    template <class E, XTL_REQUIRES(is_xexpression<E>)>
+    detail::flag_expression_t<E> has_value(E&&);*/
 
     template <>
     class xexpression_assigner_base<xoptional_expression_tag>
@@ -213,7 +274,7 @@ namespace xt
 
     namespace extension
     {
-       template <class CT>
+        template <class CT>
         struct xscalar_optional_traits
         {
             using closure_type = CT;
@@ -227,18 +288,12 @@ namespace xt
             using const_raw_value_closure = std::add_const_t<raw_value_closure>;
             using const_raw_flag_closure = std::add_const_t<raw_flag_closure>;
 
-            using value_closure = std::conditional_t<is_ref,
-                                                     std::add_lvalue_reference_t<raw_value_closure>,
-                                                     raw_value_closure>;
-            using flag_closure = std::conditional_t<is_ref,
-                                                    std::add_lvalue_reference_t<raw_flag_closure>,
-                                                    raw_flag_closure>;
-            using const_value_closure = std::conditional_t<is_ref,
-                                                           std::add_lvalue_reference_t<const_raw_value_closure>,
-                                                           raw_value_closure>;
-            using const_flag_closure = std::conditional_t<is_ref,
-                                                          std::add_lvalue_reference_t<const_raw_flag_closure>,
-                                                          raw_flag_closure>;
+            using value_closure = std::conditional_t<is_ref, std::add_lvalue_reference_t<raw_value_closure>, raw_value_closure>;
+            using flag_closure = std::conditional_t<is_ref, std::add_lvalue_reference_t<raw_flag_closure>, raw_flag_closure>;
+            using const_value_closure = std::
+                conditional_t<is_ref, std::add_lvalue_reference_t<const_raw_value_closure>, raw_value_closure>;
+            using const_flag_closure = std::
+                conditional_t<is_ref, std::add_lvalue_reference_t<const_raw_flag_closure>, raw_flag_closure>;
 
             using value_expression = xscalar<std::conditional_t<is_const, const_value_closure, value_closure>>;
             using flag_expression = xscalar<std::conditional_t<is_const, const_flag_closure, flag_closure>>;
@@ -273,7 +328,7 @@ namespace xt
     }
 
     /*************************************
-     * xcontainer extention for optional *
+     * xcontainer extension for optional *
      *************************************/
 
     namespace extension
@@ -307,19 +362,44 @@ namespace xt
         template <class EC, layout_type L, class SC>
         struct xarray_optional_traits
         {
-            using value_container = typename EC::base_container_type;
-            using flag_container = typename EC::flag_container_type;
+            using value_container = typename std::remove_reference_t<EC>::base_container_type;
+            using flag_container = typename std::remove_reference_t<EC>::flag_container_type;
             using value_expression = xarray_adaptor<value_container&, L, SC>;
             using flag_expression = xarray_adaptor<flag_container&, L, SC>;
             using const_value_expression = xarray_adaptor<const value_container&, L, SC>;
             using const_flag_expression = xarray_adaptor<const flag_container&, L, SC>;
+        };
+
+        template <class EC, layout_type L, class SC>
+        struct xarray_container_optional_traits : xarray_optional_traits<EC, L, SC>
+        {
             using derived_type = xarray_container<EC, L, SC, xoptional_expression_tag>;
         };
 
         template <class EC, layout_type L, class SC>
         struct xarray_container_base<EC, L, SC, xoptional_expression_tag>
         {
-            using traits = xarray_optional_traits<EC, L, SC>;
+            using traits = xarray_container_optional_traits<EC, L, SC>;
+            using type = xcontainer_optional_base<traits>;
+        };
+    }
+
+    /*****************************************
+     * xarray_adaptor extension for optional *
+     *****************************************/
+
+    namespace extension
+    {
+        template <class EC, layout_type L, class SC>
+        struct xarray_adaptor_optional_traits : xarray_optional_traits<EC, L, SC>
+        {
+            using derived_type = xarray_adaptor<EC, L, SC, xoptional_expression_tag>;
+        };
+
+        template <class EC, layout_type L, class SC>
+        struct xarray_adaptor_base<EC, L, SC, xoptional_expression_tag>
+        {
+            using traits = xarray_adaptor_optional_traits<EC, L, SC>;
             using type = xcontainer_optional_base<traits>;
         };
     }
@@ -333,19 +413,64 @@ namespace xt
         template <class EC, std::size_t N, layout_type L>
         struct xtensor_optional_traits
         {
-            using value_container = typename EC::base_container_type;
-            using flag_container = typename EC::flag_container_type;
+            using value_container = typename std::remove_reference_t<EC>::base_container_type;
+            using flag_container = typename std::remove_reference_t<EC>::flag_container_type;
             using value_expression = xtensor_adaptor<value_container&, N, L>;
             using flag_expression = xtensor_adaptor<flag_container&, N, L>;
             using const_value_expression = xtensor_adaptor<const value_container&, N, L>;
             using const_flag_expression = xtensor_adaptor<const flag_container&, N, L>;
+        };
+
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_container_optional_traits : xtensor_optional_traits<EC, N, L>
+        {
             using derived_type = xtensor_container<EC, N, L, xoptional_expression_tag>;
         };
 
         template <class EC, std::size_t N, layout_type L>
         struct xtensor_container_base<EC, N, L, xoptional_expression_tag>
         {
-            using traits = xtensor_optional_traits<EC, N, L>;
+            using traits = xtensor_container_optional_traits<EC, N, L>;
+            using type = xcontainer_optional_base<traits>;
+        };
+    }
+
+    /******************************************
+     * xtensor_adaptor extension for optional *
+     ******************************************/
+
+    namespace extension
+    {
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_adaptor_optional_traits : xtensor_optional_traits<EC, N, L>
+        {
+            using derived_type = xtensor_adaptor<EC, N, L, xoptional_expression_tag>;
+        };
+
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_adaptor_base<EC, N, L, xoptional_expression_tag>
+        {
+            using traits = xtensor_adaptor_optional_traits<EC, N, L>;
+            using type = xcontainer_optional_base<traits>;
+        };
+    }
+
+    /***************************************
+     * xtensor_view extension for optional *
+     ***************************************/
+
+    namespace extension
+    {
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_view_optional_traits : xtensor_optional_traits<EC, N, L>
+        {
+            using derived_type = xtensor_view<EC, N, L, xoptional_expression_tag>;
+        };
+
+        template <class EC, std::size_t N, layout_type L>
+        struct xtensor_view_base<EC, N, L, xoptional_expression_tag>
+        {
+            using traits = xtensor_view_optional_traits<EC, N, L>;
             using type = xcontainer_optional_base<traits>;
         };
     }
@@ -364,7 +489,7 @@ namespace xt
             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;
@@ -372,7 +497,7 @@ namespace xt
 
             const_value_expression value() const;
             const_flag_expression has_value() const;
-            
+
         private:
 
             template <std::size_t... I>
@@ -405,10 +530,10 @@ namespace xt
             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, xt::detail::flat_storage_type_t<uvt>>;
-            using flag_expression = xdynamic_view<uft, S, L, xt::detail::flat_storage_type_t<uft>>;
-            using const_value_expression = xdynamic_view<ucvt, S, L, xt::detail::flat_storage_type_t<ucvt>>;
-            using const_flag_expression = xdynamic_view<ucft, S, L, xt::detail::flat_storage_type_t<ucft>>;
+            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>>;
 
             value_expression value();
             const_value_expression value() const;
@@ -528,15 +653,23 @@ namespace xt
 
     namespace extension
     {
-        template <class F, class CT, class X>
-        class xreducer_optional : public xoptional_empty_base<xreducer<F, CT, X>>
+        template <class F, class CT, class X, class O>
+        class xreducer_optional : public xoptional_empty_base<xreducer<F, CT, X, O>>
         {
         public:
 
             using expression_tag = xoptional_expression_tag;
-            using value_expression = xreducer<F, xt::detail::value_expression_t<CT>, X>;
-            using flag_reducer = xreducer_functors<xt::detail::optional_bitwise<bool>>;
-            using flag_expression = xreducer<flag_reducer, xt::detail::flag_expression_t<CT>, X>;
+            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;
 
@@ -544,10 +677,38 @@ namespace xt
             const_flag_expression has_value() const;
         };
 
-        template <class F, class CT, class X>
-        struct xreducer_base_impl<xoptional_expression_tag, F, CT, X>
+        template <class F, class CT, class X, class O>
+        struct xreducer_base_impl<xoptional_expression_tag, F, CT, X, O>
         {
-            using type = xreducer_optional<F, CT, X>;
+            using type = xreducer_optional<F, CT, X, O>;
+        };
+    }
+
+    /**********************************************
+     * xrepeat extension for optional expressions *
+     **********************************************/
+
+    namespace extension
+    {
+        template <class CT, class X>
+        class xrepeat_optional : public xoptional_empty_base<xrepeat<CT, X>>
+        {
+        public:
+
+            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;
+
+            const_value_expression value() const;
+            const_flag_expression has_value() const;
+        };
+
+        template <class CT, class X>
+        struct xrepeat_base_impl<xoptional_expression_tag, CT, X>
+        {
+            using type = xrepeat_optional<CT, X>;
         };
     }
 
@@ -567,10 +728,10 @@ namespace xt
             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, xt::detail::flat_storage_type_t<uvt>>;
-            using flag_expression = xstrided_view<uft, S, L, xt::detail::flat_storage_type_t<uft>>;
-            using const_value_expression = xstrided_view<ucvt, S, L, xt::detail::flat_storage_type_t<ucvt>>;
-            using const_flag_expression = xstrided_view<ucft, S, L, xt::detail::flat_storage_type_t<ucft>>;
+            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>>;
 
             value_expression value();
             const_value_expression value() const;
@@ -816,18 +977,26 @@ namespace xt
 
         template <class F, class... CT>
         template <std::size_t... I>
-        inline auto xfunction_optional_base<F, CT...>::value_impl(std::index_sequence<I...>) const -> const_value_expression
+        inline auto xfunction_optional_base<F, CT...>::value_impl(std::index_sequence<I...>) const
+            -> const_value_expression
         {
-            return value_expression(value_functor(),
-                xt::detail::split_optional_expression<CT>::value(std::get<I>(this->derived_cast().arguments()))...);
+            return value_expression(
+                value_functor(),
+                xt::detail::split_optional_expression<CT>::value(std::get<I>(this->derived_cast().arguments()))...
+            );
         }
 
         template <class F, class... CT>
         template <std::size_t... I>
-        inline auto xfunction_optional_base<F, CT...>::has_value_impl(std::index_sequence<I...>) const -> const_flag_expression
-        {
-            return flag_expression(flag_functor(),
-                xt::detail::split_optional_expression<CT>::has_value(std::get<I>(this->derived_cast().arguments()))...);
+        inline auto xfunction_optional_base<F, CT...>::has_value_impl(std::index_sequence<I...>) const
+            -> const_flag_expression
+        {
+            return flag_expression(
+                flag_functor(),
+                xt::detail::split_optional_expression<CT>::has_value(
+                    std::get<I>(this->derived_cast().arguments())
+                )...
+            );
         }
     }
 
@@ -844,19 +1013,19 @@ namespace xt
         }
 
         template <class CT, class S, layout_type L, class FST>
-        inline auto xdynamic_view_optional<CT, S, L, FST>::value() const -> const_value_expression 
+        inline auto xdynamic_view_optional<CT, S, L, FST>::value() const -> const_value_expression
         {
             return this->derived_cast().build_view(this->derived_cast().expression().value());
         }
 
         template <class CT, class S, layout_type L, class FST>
-        inline auto xdynamic_view_optional<CT, S, L, FST>::has_value() -> flag_expression 
+        inline auto xdynamic_view_optional<CT, S, L, FST>::has_value() -> flag_expression
         {
             return this->derived_cast().build_view(this->derived_cast().expression().has_value());
         }
 
         template <class CT, class S, layout_type L, class FST>
-        inline auto xdynamic_view_optional<CT, S, L, FST>::has_value() const -> const_flag_expression 
+        inline auto xdynamic_view_optional<CT, S, L, FST>::has_value() const -> const_flag_expression
         {
             return this->derived_cast().build_view(this->derived_cast().expression().has_value());
         }
@@ -949,16 +1118,35 @@ namespace xt
 
     namespace extension
     {
-        template <class F, class CT, class X>
-        inline auto xreducer_optional<F, CT, X>::value() const -> const_value_expression
-        {
-            return this->derived_cast().build_reducer(this->derived_cast().expression().value());
+        template <class F, class CT, class X, class O>
+        inline auto xreducer_optional<F, CT, X, O>::value() const -> const_value_expression
+        {
+            auto func = this->derived_cast().functors();
+            auto opts = this->derived_cast().options().template rebind<rebound_result_type>(
+                this->derived_cast().options().initial_value.value(),
+                this->derived_cast().options()
+            );
+
+            return this->derived_cast().build_reducer(
+                this->derived_cast().expression().value(),
+                func.template rebind<rebound_result_type>(),
+                std::move(opts)
+            );
         }
 
-        template <class F, class CT, class X>
-        inline auto xreducer_optional<F, CT, X>::has_value() const -> const_flag_expression
+        template <class F, class CT, class X, class O>
+        inline auto xreducer_optional<F, CT, X, O>::has_value() const -> const_flag_expression
         {
-            return this->derived_cast().build_reducer(this->derived_cast().expression().has_value(), flag_reducer());
+            auto opts = this->derived_cast().options().rebind(
+                this->derived_cast().options().initial_value.has_value(),
+                this->derived_cast().options()
+            );
+
+            return this->derived_cast().build_reducer(
+                this->derived_cast().expression().has_value(),
+                make_xreducer_functor(xt::detail::optional_bitwise<bool>(), xt::const_value<bool>(true)),
+                std::move(opts)
+            );
         }
     }
 
@@ -975,19 +1163,19 @@ namespace xt
         }
 
         template <class CT, class S, layout_type L, class FST>
-        inline auto xstrided_view_optional<CT, S, L, FST>::value() const -> const_value_expression 
+        inline auto xstrided_view_optional<CT, S, L, FST>::value() const -> const_value_expression
         {
             return this->derived_cast().build_view(this->derived_cast().expression().value());
         }
 
         template <class CT, class S, layout_type L, class FST>
-        inline auto xstrided_view_optional<CT, S, L, FST>::has_value() -> flag_expression 
+        inline auto xstrided_view_optional<CT, S, L, FST>::has_value() -> flag_expression
         {
             return this->derived_cast().build_view(this->derived_cast().expression().has_value());
         }
 
         template <class CT, class S, layout_type L, class FST>
-        inline auto xstrided_view_optional<CT, S, L, FST>::has_value() const -> const_flag_expression 
+        inline auto xstrided_view_optional<CT, S, L, FST>::has_value() const -> const_flag_expression
         {
             return this->derived_cast().build_view(this->derived_cast().expression().has_value());
         }
@@ -1034,14 +1222,16 @@ namespace xt
         inline auto xgenerator_optional<F, R, S>::value() const -> const_value_expression
         {
             return this->derived_cast().template build_generator<value_closure>(
-                    detail::value_functor<F>::get(this->derived_cast().functor()));
+                detail::value_functor<F>::get(this->derived_cast().functor())
+            );
         }
 
         template <class F, class R, class S>
         inline auto xgenerator_optional<F, R, S>::has_value() const -> const_flag_expression
         {
             return this->derived_cast().template build_generator<flag_closure>(
-                    detail::flag_functor<F>::get(this->derived_cast().functor()));
+                detail::flag_functor<F>::get(this->derived_cast().functor())
+            );
         }
     }
 
@@ -1056,7 +1246,7 @@ namespace xt
         {
             static constexpr auto run(const xtl::xoptional<T, B>& x)
             {
-                return sign(x); // use overload declared above
+                return sign(x);  // use overload declared above
             }
         };
     }
@@ -1072,28 +1262,92 @@ namespace xt
      * value() and has_value() implementation *
      ******************************************/
 
-    template <class E, class>
+    template <class E, XTL_REQUIRES(is_xexpression<E>)>
     inline auto value(E&& e) -> detail::value_expression_t<E>
     {
         return detail::split_optional_expression<E>::value(std::forward<E>(e));
     }
 
-    template <class E, class>
+    template <class E, XTL_REQUIRES(is_xexpression<E>)>
     inline auto has_value(E&& e) -> detail::flag_expression_t<E>
     {
         return detail::split_optional_expression<E>::has_value(std::forward<E>(e));
     }
 
-    template <class E1, class E2>
-    inline void xexpression_assigner_base<xoptional_expression_tag>::assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
+    namespace detail
     {
-        E1& de1 = e1.derived_cast();
-        const E2& de2 = e2.derived_cast();
+        template <class T1, class T2>
+        struct assign_data_impl
+        {
+            template <class E1, class E2>
+            static void run(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
+            {
+                E1& de1 = e1.derived_cast();
+                const E2& de2 = e2.derived_cast();
 
-        decltype(auto) bde1 = xt::value(de1);
-        decltype(auto) hde1 = xt::has_value(de1);
-        xexpression_assigner_base<xtensor_expression_tag>::assign_data(bde1, xt::value(de2), trivial);
-        xexpression_assigner_base<xtensor_expression_tag>::assign_data(hde1, xt::has_value(de2), trivial);
+                decltype(auto) bde1 = xt::value(de1);
+                decltype(auto) hde1 = xt::has_value(de1);
+                xexpression_assigner_base<xtensor_expression_tag>::assign_data(bde1, xt::value(de2), trivial);
+                xexpression_assigner_base<xtensor_expression_tag>::assign_data(hde1, xt::has_value(de2), trivial);
+            }
+        };
+
+        template <class T>
+        struct xarray_assigner
+        {
+            template <class E1, class E2>
+            static void assign(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
+            {
+                E1& de1 = e1.derived_cast();
+                const E2& de2 = e2.derived_cast();
+                xarray<bool> mask = xt::full_like(de2, true);
+
+                decltype(auto) bde1 = xt::value(de1);
+                decltype(auto) hde1 = xt::has_value(de1);
+                xexpression_assigner_base<xtensor_expression_tag>::assign_data(bde1, e2, trivial);
+                xexpression_assigner_base<xtensor_expression_tag>::assign_data(hde1, mask, trivial);
+            }
+        };
+
+        template <class T>
+        struct xarray_assigner<xtl::xoptional<T>>
+        {
+            template <class E1, class E2>
+            static void assign(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
+            {
+                xexpression_assigner_base<xtensor_expression_tag>::assign_data(e1, e2, trivial);
+            }
+        };
+
+        template <>
+        struct assign_data_impl<xoptional_expression_tag, xtensor_expression_tag>
+        {
+            template <class E1, class E2>
+            static void run(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
+            {
+                xarray_assigner<typename E2::value_type>::assign(e1, e2, trivial);
+            }
+        };
+
+        template <>
+        struct assign_data_impl<xtensor_expression_tag, xoptional_expression_tag>
+        {
+            template <class E1, class E2>
+            static void run(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
+            {
+                xexpression_assigner_base<xtensor_expression_tag>::assign_data(e1, e2, trivial);
+            }
+        };
+    }
+
+    template <class E1, class E2>
+    inline void xexpression_assigner_base<xoptional_expression_tag>::assign_data(
+        xexpression<E1>& e1,
+        const xexpression<E2>& e2,
+        bool trivial
+    )
+    {
+        detail::assign_data_impl<typename E1::expression_tag, typename E2::expression_tag>::run(e1, e2, trivial);
     }
 }
 
diff --git a/include/xtensor/xoptional_assembly.hpp b/include/xtensor/optional/xoptional_assembly.hpp
similarity index 77%
rename from include/xtensor/xoptional_assembly.hpp
rename to include/xtensor/optional/xoptional_assembly.hpp
index 0ad92e529..062a1f9fa 100644
--- a/include/xtensor/xoptional_assembly.hpp
+++ b/include/xtensor/optional/xoptional_assembly.hpp
@@ -1,18 +1,18 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 XOPTIONAL_ASSEMBLY_HPP
 #define XOPTIONAL_ASSEMBLY_HPP
 
-#include "xconcepts.hpp"
-#include "xoptional.hpp"
-#include "xoptional_assembly_base.hpp"
-#include "xsemantic.hpp"
+#include "../core/xsemantic.hpp"
+#include "../optional/xoptional.hpp"
+#include "../optional/xoptional_assembly_base.hpp"
 
 namespace xt
 {
@@ -85,14 +85,18 @@ namespace xt
 
         xoptional_assembly();
         explicit xoptional_assembly(const shape_type& shape, layout_type l = base_type::static_layout);
-        explicit xoptional_assembly(const shape_type& shape, const value_type& value, layout_type l = base_type::static_layout);
+        explicit xoptional_assembly(
+            const shape_type& shape,
+            const value_type& value,
+            layout_type l = base_type::static_layout
+        );
         explicit xoptional_assembly(const shape_type& shape, const strides_type& strides);
         explicit xoptional_assembly(const shape_type& shape, const strides_type& strides, const value_type& value);
 
         xoptional_assembly(const VE& ve);
         xoptional_assembly(VE&& ve);
 
-        template <class OVE, class OFE, XTENSOR_REQUIRE<is_xexpression<OVE>::value && is_xexpression<OFE>::value>>
+        template <class OVE, class OFE, typename = std::enable_if_t<is_xexpression<OVE>::value && is_xexpression<OFE>::value>>
         xoptional_assembly(OVE&& ove, OFE&& ofe);
 
         xoptional_assembly(const value_type& value);
@@ -148,13 +152,15 @@ namespace xt
     struct xcontainer_inner_types<xoptional_assembly_adaptor<VEC, FEC>>
     {
         using raw_value_expression = std::remove_reference_t<VEC>;
-        using value_storage_type = std::conditional_t<std::is_const<raw_value_expression>::value,
-                                                      const typename raw_value_expression::storage_type&,
-                                                      typename raw_value_expression::storage_type&>;
+        using value_storage_type = std::conditional_t<
+            std::is_const<raw_value_expression>::value,
+            const typename raw_value_expression::storage_type&,
+            typename raw_value_expression::storage_type&>;
         using raw_flag_expression = std::remove_reference_t<FEC>;
-        using flag_storage_type = std::conditional_t<std::is_const<raw_flag_expression>::value,
-                                                     const typename raw_flag_expression::storage_type&,
-                                                     typename raw_flag_expression::storage_type&>;
+        using flag_storage_type = std::conditional_t<
+            std::is_const<raw_flag_expression>::value,
+            const typename raw_flag_expression::storage_type&,
+            typename raw_flag_expression::storage_type&>;
         using storage_type = xoptional_assembly_storage<value_storage_type, flag_storage_type>;
         using temporary_type = xoptional_assembly<raw_value_expression, raw_flag_expression>;
     };
@@ -271,7 +277,9 @@ namespace xt
      */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly()
-        : m_value(), m_has_value(), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value()
+        , m_has_value()
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -283,7 +291,9 @@ namespace xt
      */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(const shape_type& shape, layout_type l)
-        : m_value(shape, l), m_has_value(shape, l), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value(shape, l)
+        , m_has_value(shape, l)
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -295,8 +305,14 @@ namespace xt
      * @param l the layout_type of the xoptional_assembly
      */
     template <class VE, class FE>
-    inline xoptional_assembly<VE, FE>::xoptional_assembly(const shape_type& shape, const value_type& value, layout_type l)
-        : m_value(shape, value.value(), l), m_has_value(shape, value.has_value(), l), m_storage(m_value.storage(), m_has_value.storage())
+    inline xoptional_assembly<VE, FE>::xoptional_assembly(
+        const shape_type& shape,
+        const value_type& value,
+        layout_type l
+    )
+        : m_value(shape, value.value(), l)
+        , m_has_value(shape, value.has_value(), l)
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -307,7 +323,9 @@ namespace xt
      */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(const shape_type& shape, const strides_type& strides)
-        : m_value(shape, strides), m_has_value(shape, strides), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value(shape, strides)
+        , m_has_value(shape, strides)
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -319,8 +337,14 @@ namespace xt
      * @param value the value of the elements
      */
     template <class VE, class FE>
-    inline xoptional_assembly<VE, FE>::xoptional_assembly(const shape_type& shape, const strides_type& strides, const value_type& value)
-        : m_value(shape, strides, value.value()), m_has_value(shape, strides, value.has_value()), m_storage(m_value.storage(), m_has_value.storage())
+    inline xoptional_assembly<VE, FE>::xoptional_assembly(
+        const shape_type& shape,
+        const strides_type& strides,
+        const value_type& value
+    )
+        : m_value(shape, strides, value.value())
+        , m_has_value(shape, strides, value.has_value())
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -331,7 +355,9 @@ namespace xt
      */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(const value_type& value)
-        : m_value(value.value()), m_has_value(value.has_value()), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value(value.value())
+        , m_has_value(value.has_value())
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -342,7 +368,9 @@ namespace xt
      */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(const VE& ve)
-        : m_value(ve), m_has_value(ve.shape(), true, ve.layout()), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value(ve)
+        , m_has_value(ve.shape(), true, ve.layout())
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -355,7 +383,9 @@ namespace xt
      */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(VE&& ve)
-        : m_value(std::move(ve)), m_has_value(ve.shape(), true, ve.layout()), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value(std::move(ve))
+        , m_has_value(ve.shape(), true, ve.layout())
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -368,84 +398,108 @@ namespace xt
     template <class VE, class FE>
     template <class OVE, class OFE, typename>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(OVE&& ove, OFE&& ofe)
-        : m_value(std::forward<OVE>(ove)), m_has_value(std::forward<OFE>(ofe)), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value(std::forward<OVE>(ove))
+        , m_has_value(std::forward<OFE>(ofe))
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
+
     //@}
 
     /**
-    * @name Constructors from initializer list
-    */
+     * @name Constructors from initializer list
+     */
     //@{
     /**
-    * Allocates a one-dimensional xoptional_assembly.
-    * @param t the elements of the xoptional_assembly
-    */
+     * Allocates a one-dimensional xoptional_assembly.
+     * @param t the elements of the xoptional_assembly
+     */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(nested_initializer_list_t<value_type, 1> t)
-        : base_type(), m_value(), m_has_value(), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , m_value()
+        , m_has_value()
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
         base_type::resize(xt::shape<shape_type>(t));
-        bool condition = VE::static_layout == layout_type::row_major && FE::static_layout == layout_type::row_major;
-        condition ? detail::nested_optional_copy(this->storage_begin(), t)
+        bool condition = VE::static_layout == layout_type::row_major
+                         && FE::static_layout == layout_type::row_major;
+        condition ? detail::nested_optional_copy(this->linear_begin(), t)
                   : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     /**
-    * Allocates a two-dimensional xoptional_assembly.
-    * @param t the elements of the xoptional_assembly
-    */
+     * Allocates a two-dimensional xoptional_assembly.
+     * @param t the elements of the xoptional_assembly
+     */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(nested_initializer_list_t<value_type, 2> t)
-        : base_type(), m_value(), m_has_value(), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , m_value()
+        , m_has_value()
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
         base_type::resize(xt::shape<shape_type>(t));
-        bool condition = VE::static_layout == layout_type::row_major && FE::static_layout == layout_type::row_major;
-        condition ? detail::nested_optional_copy(this->storage_begin(), t)
+        bool condition = VE::static_layout == layout_type::row_major
+                         && FE::static_layout == layout_type::row_major;
+        condition ? detail::nested_optional_copy(this->linear_begin(), t)
                   : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     /**
-    * Allocates a three-dimensional xoptional_assembly.
-    * @param t the elements of the xoptional_assembly
-    */
+     * Allocates a three-dimensional xoptional_assembly.
+     * @param t the elements of the xoptional_assembly
+     */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(nested_initializer_list_t<value_type, 3> t)
-        : base_type(), m_value(), m_has_value(), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , m_value()
+        , m_has_value()
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
         base_type::resize(xt::shape<shape_type>(t));
-        bool condition = VE::static_layout == layout_type::row_major && FE::static_layout == layout_type::row_major;
-        condition ? detail::nested_optional_copy(this->storage_begin(), t)
+        bool condition = VE::static_layout == layout_type::row_major
+                         && FE::static_layout == layout_type::row_major;
+        condition ? detail::nested_optional_copy(this->linear_begin(), t)
                   : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     /**
-    * Allocates a four-dimensional xoptional_assembly.
-    * @param t the elements of the xoptional_assembly
-    */
+     * Allocates a four-dimensional xoptional_assembly.
+     * @param t the elements of the xoptional_assembly
+     */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(nested_initializer_list_t<value_type, 4> t)
-        : base_type(), m_value(), m_has_value(), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , m_value()
+        , m_has_value()
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
         base_type::resize(xt::shape<shape_type>(t));
-        bool condition = VE::static_layout == layout_type::row_major && FE::static_layout == layout_type::row_major;
-        condition ? detail::nested_optional_copy(this->storage_begin(), t)
+        bool condition = VE::static_layout == layout_type::row_major
+                         && FE::static_layout == layout_type::row_major;
+        condition ? detail::nested_optional_copy(this->linear_begin(), t)
                   : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     /**
-    * Allocates a five-dimensional xoptional_assembly.
-    * @param t the elements of the xoptional_assembly
-    */
+     * Allocates a five-dimensional xoptional_assembly.
+     * @param t the elements of the xoptional_assembly
+     */
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(nested_initializer_list_t<value_type, 5> t)
-        : base_type(), m_value(), m_has_value(), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , m_value()
+        , m_has_value()
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
         base_type::resize(xt::shape<shape_type>(t));
-        bool condition = VE::static_layout == layout_type::row_major && FE::static_layout == layout_type::row_major;
-        condition ? detail::nested_optional_copy(this->storage_begin(), t)
+        bool condition = VE::static_layout == layout_type::row_major
+                         && FE::static_layout == layout_type::row_major;
+        condition ? detail::nested_optional_copy(this->linear_begin(), t)
                   : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
+
     //@}
 
     /**
@@ -456,19 +510,27 @@ namespace xt
     template <class S>
     inline xoptional_assembly<VE, FE> xoptional_assembly<VE, FE>::from_shape(S&& s)
     {
-        shape_type shape = xtl::forward_sequence<shape_type>(s);
+        shape_type shape = xtl::forward_sequence<shape_type, S>(s);
         return self_type(shape);
     }
 
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(const self_type& rhs)
-        : base_type(), semantic_base(), m_value(rhs.m_value), m_has_value(rhs.m_has_value), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , semantic_base()
+        , m_value(rhs.m_value)
+        , m_has_value(rhs.m_has_value)
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
     template <class VE, class FE>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(self_type&& rhs)
-        : base_type(), semantic_base(), m_value(rhs.m_value), m_has_value(rhs.m_has_value), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , semantic_base()
+        , m_value(rhs.m_value)
+        , m_has_value(rhs.m_has_value)
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -500,7 +562,10 @@ namespace xt
     template <class VE, class FE>
     template <class E>
     inline xoptional_assembly<VE, FE>::xoptional_assembly(const xexpression<E>& e)
-        : base_type(), m_value(), m_has_value(), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , m_value()
+        , m_has_value()
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
         semantic_base::assign(e);
     }
@@ -514,6 +579,7 @@ namespace xt
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     template <class VE, class FE>
@@ -569,14 +635,21 @@ namespace xt
     template <class VEC, class FEC>
     template <class OVE, class OFE>
     inline xoptional_assembly_adaptor<VEC, FEC>::xoptional_assembly_adaptor(OVE&& ve, OFE&& fe)
-        : m_value(std::forward<OVE>(ve)), m_has_value(std::forward<OFE>(fe)), m_storage(m_value.storage(), m_has_value.storage())
+        : m_value(std::forward<OVE>(ve))
+        , m_has_value(std::forward<OFE>(fe))
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
+
     //@}
 
     template <class VEC, class FEC>
     inline xoptional_assembly_adaptor<VEC, FEC>::xoptional_assembly_adaptor(const self_type& rhs)
-        : base_type(), semantic_base(), m_value(rhs.m_value), m_has_value(rhs.m_has_value), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , semantic_base()
+        , m_value(rhs.m_value)
+        , m_has_value(rhs.m_has_value)
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -591,7 +664,11 @@ namespace xt
 
     template <class VEC, class FEC>
     inline xoptional_assembly_adaptor<VEC, FEC>::xoptional_assembly_adaptor(self_type&& rhs)
-        : base_type(), semantic_base(), m_value(rhs.m_value), m_has_value(rhs.m_has_value), m_storage(m_value.storage(), m_has_value.storage())
+        : base_type()
+        , semantic_base()
+        , m_value(rhs.m_value)
+        , m_has_value(rhs.m_has_value)
+        , m_storage(m_value.storage(), m_has_value.storage())
     {
     }
 
@@ -625,6 +702,7 @@ namespace xt
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     template <class VEC, class FEC>
diff --git a/include/xtensor/xoptional_assembly_base.hpp b/include/xtensor/optional/xoptional_assembly_base.hpp
similarity index 73%
rename from include/xtensor/xoptional_assembly_base.hpp
rename to include/xtensor/optional/xoptional_assembly_base.hpp
index 70b54542f..5df618f0b 100644
--- a/include/xtensor/xoptional_assembly_base.hpp
+++ b/include/xtensor/optional/xoptional_assembly_base.hpp
@@ -1,25 +1,24 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 XOPTIONAL_ASSEMBLY_BASE_HPP
 #define XOPTIONAL_ASSEMBLY_BASE_HPP
 
-#include "xiterable.hpp"
-#include "xtensor_forward.hpp"
-#include "xoptional_assembly_storage.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../optional/xoptional_assembly_storage.hpp"
 
 namespace xt
 {
     template <class D, bool is_const>
     class xoptional_assembly_stepper;
 
-#define DL XTENSOR_DEFAULT_LAYOUT
-
     /***************************
      * xoptional_assembly_base *
      ***************************/
@@ -64,7 +63,8 @@ namespace xt
         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 = xsimd::simd_type<value_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;
@@ -105,10 +105,10 @@ namespace xt
         template <class S, layout_type L>
         using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>;
 
-        using storage_iterator = typename storage_type::iterator;
-        using const_storage_iterator = typename storage_type::const_iterator;
-        using reverse_storage_iterator = typename storage_type::reverse_iterator;
-        using const_reverse_storage_iterator = typename storage_type::const_reverse_iterator;
+        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;
@@ -117,8 +117,8 @@ namespace xt
 
         size_type size() const noexcept;
         constexpr size_type dimension() const noexcept;
-
         const inner_shape_type& shape() const noexcept;
+        size_type shape(size_type index) const;
         const inner_strides_type& strides() const noexcept;
         const inner_backstrides_type& backstrides() const noexcept;
 
@@ -130,9 +130,13 @@ namespace xt
         void resize(const S& shape, const strides_type& strides);
 
         template <class S = shape_type>
-        void reshape(const S& shape, layout_type layout = static_layout);
+        auto& reshape(const S& shape, layout_type layout = static_layout) &;
+
+        template <class T>
+        auto& reshape(std::initializer_list<T> shape, layout_type layout = static_layout) &;
 
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
 
         template <class T>
         void fill(const T& value);
@@ -167,11 +171,29 @@ namespace xt
         const_reference operator[](std::initializer_list<I> index) const;
         const_reference operator[](size_type i) const;
 
+        template <class... Args>
+        reference periodic(Args... args);
+
+        template <class... Args>
+        const_reference periodic(Args... args) const;
+
+        reference front();
+        const_reference front() const;
+
+        reference back();
+        const_reference back() const;
+
+        reference flat(size_type args);
+        const_reference flat(size_type args) const;
+
         template <class It>
         reference element(It first, It last);
         template <class It>
         const_reference element(It first, It last) const;
 
+        template <class... Args>
+        bool in_bounds(Args... args) const;
+
         storage_type& storage() noexcept;
         const storage_type& storage() const noexcept;
 
@@ -186,29 +208,29 @@ namespace xt
         bool has_linear_assign(const S& strides) const noexcept;
 
         using iterable_base::begin;
-        using iterable_base::end;
         using iterable_base::cbegin;
         using iterable_base::cend;
-        using iterable_base::rbegin;
-        using iterable_base::rend;
         using iterable_base::crbegin;
         using iterable_base::crend;
+        using iterable_base::end;
+        using iterable_base::rbegin;
+        using iterable_base::rend;
 
-        storage_iterator storage_begin() noexcept;
-        storage_iterator storage_end() noexcept;
+        linear_iterator linear_begin() noexcept;
+        linear_iterator linear_end() noexcept;
 
-        const_storage_iterator storage_begin() const noexcept;
-        const_storage_iterator storage_end() const noexcept;
-        const_storage_iterator storage_cbegin() const noexcept;
-        const_storage_iterator storage_cend() const 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_storage_iterator storage_rbegin() noexcept;
-        reverse_storage_iterator storage_rend() noexcept;
+        reverse_linear_iterator linear_rbegin() noexcept;
+        reverse_linear_iterator linear_rend() noexcept;
 
-        const_reverse_storage_iterator storage_rbegin() const noexcept;
-        const_reverse_storage_iterator storage_rend() const noexcept;
-        const_reverse_storage_iterator storage_crbegin() const noexcept;
-        const_reverse_storage_iterator storage_crend() 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;
 
         template <class S>
         stepper stepper_begin(const S& shape) noexcept;
@@ -246,8 +268,6 @@ namespace xt
         friend class xconst_iterable<D>;
     };
 
-#undef DL
-
     /******************************
      * xoptional_assembly_stepper *
      ******************************/
@@ -260,22 +280,17 @@ namespace xt
         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 = std::conditional_t<is_const,
-                                             typename assembly_type::const_reference,
-                                             typename assembly_type::reference>;
-        using pointer = std::conditional_t<is_const,
-                                           typename assembly_type::const_pointer,
-                                           typename assembly_type::pointer>;
+        using reference = std::
+            conditional_t<is_const, typename assembly_type::const_reference, typename assembly_type::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 = std::conditional_t<is_const,
-                                                 typename raw_value_expression::const_stepper,
-                                                 typename raw_value_expression::stepper>;
-        using flag_stepper = std::conditional_t<is_const,
-                                                typename raw_flag_expression::const_stepper,
-                                                typename raw_flag_expression::stepper>;
+        using value_stepper = std::
+            conditional_t<is_const, typename raw_value_expression::const_stepper, typename raw_value_expression::stepper>;
+        using flag_stepper = std::
+            conditional_t<is_const, typename raw_flag_expression::const_stepper, typename raw_flag_expression::stepper>;
 
         xoptional_assembly_stepper(value_stepper vs, flag_stepper fs) noexcept;
 
@@ -319,7 +334,7 @@ namespace xt
      * Returns the number of dimensions of the optional assembly.
      */
     template <class D>
-    inline auto constexpr xoptional_assembly_base<D>::dimension() const noexcept -> size_type
+    inline constexpr auto xoptional_assembly_base<D>::dimension() const noexcept -> size_type
     {
         return value().dimension();
     }
@@ -333,6 +348,15 @@ namespace xt
         return value().shape();
     }
 
+    /**
+     * Returns the i-th dimension of the expression.
+     */
+    template <class D>
+    inline auto xoptional_assembly_base<D>::shape(size_type i) const -> size_type
+    {
+        return value().shape(i);
+    }
+
     /**
      * Returns the strides of the optional assembly.
      */
@@ -350,6 +374,7 @@ namespace xt
     {
         return value().backstrides();
     }
+
     //@}
 
     /**
@@ -398,10 +423,20 @@ namespace xt
      */
     template <class D>
     template <class S>
-    inline void xoptional_assembly_base<D>::reshape(const S& shape, layout_type layout)
+    inline auto& xoptional_assembly_base<D>::reshape(const S& shape, layout_type layout) &
     {
         value().reshape(shape, layout);
         has_value().reshape(shape, layout);
+        return *this;
+    }
+
+    template <class D>
+    template <class T>
+    inline auto& xoptional_assembly_base<D>::reshape(std::initializer_list<T> shape, layout_type layout) &
+    {
+        value().reshape(shape, layout);
+        has_value().reshape(shape, layout);
+        return *this;
     }
 
     /**
@@ -414,6 +449,12 @@ namespace xt
         return value().layout();
     }
 
+    template <class D>
+    inline bool xoptional_assembly_base<D>::is_contiguous() const noexcept
+    {
+        return value().is_contiguous();
+    }
+
     /**
      * Fills the data with the given value.
      * @param value the value to fill the data with.
@@ -422,7 +463,7 @@ namespace xt
     template <class T>
     inline void xoptional_assembly_base<D>::fill(const T& value)
     {
-        std::fill(this->storage_begin(), this->storage_end(), value);
+        std::fill(this->linear_begin(), this->linear_end(), value);
     }
 
     /**
@@ -495,16 +536,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>
@@ -521,16 +562,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class D>
     template <class... Args>
@@ -547,16 +588,14 @@ namespace xt
      */
     template <class D>
     template <class S>
-    inline auto xoptional_assembly_base<D>::operator[](const S& index)
-        -> disable_integral_t<S, reference>
+    inline auto xoptional_assembly_base<D>::operator[](const S& index) -> disable_integral_t<S, reference>
     {
         return reference(value()[index], has_value()[index]);
     }
 
     template <class D>
     template <class I>
-    inline auto xoptional_assembly_base<D>::operator[](std::initializer_list<I> index)
-        -> reference
+    inline auto xoptional_assembly_base<D>::operator[](std::initializer_list<I> index) -> reference
     {
         return reference(value()[index], has_value()[index]);
     }
@@ -583,8 +622,7 @@ namespace xt
 
     template <class D>
     template <class I>
-    inline auto xoptional_assembly_base<D>::operator[](std::initializer_list<I> index) const
-        -> const_reference
+    inline auto xoptional_assembly_base<D>::operator[](std::initializer_list<I> index) const -> const_reference
     {
         return const_reference(value()[index], has_value()[index]);
     }
@@ -595,6 +633,92 @@ namespace xt
         return const_reference(value()[i], has_value()[i]);
     }
 
+    /**
+     * 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).
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xoptional_assembly_base<D>::periodic(Args... args) -> reference
+    {
+        return reference(value().periodic(args...), has_value().periodic(args...));
+    }
+
+    /**
+     * 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).
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xoptional_assembly_base<D>::periodic(Args... args) const -> const_reference
+    {
+        return const_reference(value().periodic(args...), has_value().periodic(args...));
+    }
+
+    /**
+     * Returns a reference to the first element of the optional assembly.
+     */
+    template <class D>
+    inline auto xoptional_assembly_base<D>::front() -> reference
+    {
+        return reference(value().front(), has_value().front());
+    }
+
+    /**
+     * Returns a constant reference to the first element of the optional assembly.
+     */
+    template <class D>
+    inline auto xoptional_assembly_base<D>::front() const -> const_reference
+    {
+        return const_reference(value().front(), has_value().front());
+    }
+
+    /**
+     * Returns a reference to the last element of the optional assembly.
+     */
+    template <class D>
+    inline auto xoptional_assembly_base<D>::back() -> reference
+    {
+        return reference(value().back(), has_value().back());
+    }
+
+    /**
+     * Returns a constant reference to the last element of the optional assembly.
+     */
+    template <class D>
+    inline auto xoptional_assembly_base<D>::back() const -> const_reference
+    {
+        return const_reference(value().back(), has_value().back());
+    }
+
+    /**
+     * Returns a reference to the element at the specified position
+     * of the underlying storage in the optional assembly.
+     * @param i index to underlying flat storage.
+     */
+    template <class D>
+    inline auto xoptional_assembly_base<D>::flat(size_type i) -> reference
+    {
+        return reference(value().flat(i), has_value().flat(i));
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position
+     * of the underlying storage in the optional assembly.
+     * @param i index to underlying flat storage.
+     */
+    template <class D>
+    inline auto xoptional_assembly_base<D>::flat(size_type i) const -> const_reference
+    {
+        return const_reference(value().flat(i), has_value().flat(i));
+    }
+
     /**
      * Returns a reference to the element at the specified position in the optional assembly.
      * @param first iterator starting the sequence of indices
@@ -622,6 +746,19 @@ namespace xt
     {
         return const_reference(value().element(first, last), has_value().element(first, last));
     }
+
+    /**
+     * Returns ``true`` only if the the specified position is a valid entry in the expression.
+     * @param args a list of indices specifying the position in the expression.
+     * @return bool
+     */
+    template <class D>
+    template <class... Args>
+    inline bool xoptional_assembly_base<D>::in_bounds(Args... args) const
+    {
+        return value().in_bounds(args...) && has_value().in_bounds(args...);
+    }
+
     //@}
 
     template <class D>
@@ -683,82 +820,79 @@ namespace xt
     {
         return value().has_linear_assign(strides) && has_value().has_linear_assign(strides);
     }
+
     //@}
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_begin() noexcept -> storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_begin() noexcept -> linear_iterator
     {
-        return storage_iterator(value().storage_begin(),
-                                has_value().storage_begin());
+        return linear_iterator(value().linear_begin(), has_value().linear_begin());
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_end() noexcept -> storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_end() noexcept -> linear_iterator
     {
-        return storage_iterator(value().storage_end(),
-                                has_value().storage_end());
+        return linear_iterator(value().linear_end(), has_value().linear_end());
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_begin() const noexcept -> const_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_begin() const noexcept -> const_linear_iterator
     {
-        return storage_cbegin();
+        return linear_cbegin();
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_end() const noexcept -> const_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_end() const noexcept -> const_linear_iterator
     {
-        return storage_cend();
+        return linear_cend();
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_cbegin() const noexcept -> const_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_cbegin() const noexcept -> const_linear_iterator
     {
-        return const_storage_iterator(value().storage_cbegin(),
-                                      has_value().storage_cbegin());
+        return const_linear_iterator(value().linear_cbegin(), has_value().linear_cbegin());
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_cend() const noexcept -> const_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_cend() const noexcept -> const_linear_iterator
     {
-        return const_storage_iterator(value().storage_cend(),
-                                      has_value().storage_cend());
+        return const_linear_iterator(value().linear_cend(), has_value().linear_cend());
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_rbegin() noexcept -> reverse_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_rbegin() noexcept -> reverse_linear_iterator
     {
-        return reverse_storage_iterator(storage_end());
+        return reverse_linear_iterator(linear_end());
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_rend() noexcept -> reverse_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_rend() noexcept -> reverse_linear_iterator
     {
-        return reverse_storage_iterator(storage_begin());
+        return reverse_linear_iterator(linear_begin());
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_rbegin() const noexcept -> const_reverse_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_rbegin() const noexcept -> const_reverse_linear_iterator
     {
-        return storage_crbegin();
+        return linear_crbegin();
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_rend() const noexcept -> const_reverse_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_rend() const noexcept -> const_reverse_linear_iterator
     {
-        return storage_crend();
+        return linear_crend();
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_crbegin() const noexcept -> const_reverse_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_crbegin() const noexcept -> const_reverse_linear_iterator
     {
-        return const_reverse_storage_iterator(storage_cend());
+        return const_reverse_linear_iterator(linear_cend());
     }
 
     template <class D>
-    inline auto xoptional_assembly_base<D>::storage_crend() const noexcept -> const_reverse_storage_iterator
+    inline auto xoptional_assembly_base<D>::linear_crend() const noexcept -> const_reverse_linear_iterator
     {
-        return const_reverse_storage_iterator(storage_cbegin());
+        return const_reverse_linear_iterator(linear_cbegin());
     }
 
     template <class D>
@@ -784,7 +918,8 @@ namespace xt
 
     template <class D>
     template <class S>
-    inline auto xoptional_assembly_base<D>::stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
+    inline auto xoptional_assembly_base<D>::stepper_end(const S& shape, layout_type l) const noexcept
+        -> const_stepper
     {
         return const_stepper(value().stepper_end(shape, l), has_value().stepper_end(shape, l));
     }
@@ -843,7 +978,8 @@ namespace xt
 
     template <class D, bool C>
     inline xoptional_assembly_stepper<D, C>::xoptional_assembly_stepper(value_stepper vs, flag_stepper fs) noexcept
-        : m_vs(vs), m_fs(fs)
+        : m_vs(vs)
+        , m_fs(fs)
     {
     }
 
diff --git a/include/xtensor/xoptional_assembly_storage.hpp b/include/xtensor/optional/xoptional_assembly_storage.hpp
similarity index 71%
rename from include/xtensor/xoptional_assembly_storage.hpp
rename to include/xtensor/optional/xoptional_assembly_storage.hpp
index 5239fc166..0ec1c0a44 100644
--- a/include/xtensor/xoptional_assembly_storage.hpp
+++ b/include/xtensor/optional/xoptional_assembly_storage.hpp
@@ -1,25 +1,23 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 XOPTIONAL_ASSEMBLY_STORAGE_HPP
 #define XOPTIONAL_ASSEMBLY_STORAGE_HPP
 
+#include "../core/xsemantic.hpp"
+#include "../optional/xoptional.hpp"
 #include "xtl/xiterator_base.hpp"
 
-#include "xconcepts.hpp"
-#include "xoptional.hpp"
-#include "xsemantic.hpp"
-
 namespace xt
 {
     template <class VE, class FE, bool is_const>
-    class xoptional_assembly_storage_iterator;
+    class xoptional_assembly_linear_iterator;
 
     /******************************
      * xoptional_assembly_storage *
@@ -39,12 +37,10 @@ namespace xt
 
         static constexpr bool is_val_const = std::is_const<value_storage>::value;
         static constexpr bool is_flag_const = std::is_const<flag_storage>::value;
-        using val_reference = std::conditional_t<is_val_const,
-                                                 typename value_storage::const_reference,
-                                                 typename value_storage::reference>;
-        using flag_reference = std::conditional_t<is_flag_const,
-                                                  typename flag_storage::const_reference,
-                                                  typename flag_storage::reference>;
+        using val_reference = std::
+            conditional_t<is_val_const, typename value_storage::const_reference, typename value_storage::reference>;
+        using flag_reference = std::
+            conditional_t<is_flag_const, typename flag_storage::const_reference, typename flag_storage::reference>;
         using reference = xtl::xoptional<val_reference, flag_reference>;
         using const_reference = xtl::xoptional<typename value_storage::const_reference, typename flag_storage::const_reference>;
 
@@ -54,8 +50,8 @@ namespace xt
         using size_type = typename value_storage::size_type;
         using difference_type = typename value_storage::difference_type;
 
-        using iterator = xoptional_assembly_storage_iterator<VE, FE, false>;
-        using const_iterator = xoptional_assembly_storage_iterator<VE, FE, true>;
+        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>;
 
@@ -119,71 +115,82 @@ namespace xt
     };
 
     template <class VE, class FE>
-    bool operator==(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
+    bool
+    operator==(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
 
     template <class VE, class FE>
-    bool operator!=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
+    bool
+    operator!=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
 
     template <class VE, class FE>
-    bool operator<(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
+    bool
+    operator<(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
 
     template <class VE, class FE>
-    bool operator<=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
+    bool
+    operator<=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
 
     template <class VE, class FE>
-    bool operator>(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
+    bool
+    operator>(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
 
     template <class VE, class FE>
-    bool operator>=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
+    bool
+    operator>=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs);
 
     template <class VE, class FE>
     void swap(xoptional_assembly_storage<VE, FE>& lhs, xoptional_assembly_storage<VE, FE>& rhs) noexcept;
 
     /***************************************
-     * xoptional_assembly_storage_iterator *
+     * xoptional_assembly_linear_iterator *
      ***************************************/
 
     template <class VE, class FE, bool is_const>
-    class xoptional_assembly_storage_iterator;
+    class xoptional_assembly_linear_iterator;
 
     template <class VE, class FE, bool is_const>
-    struct xoptional_assembly_storage_iterator_traits
+    struct xoptional_assembly_linear_iterator_traits
     {
-        using iterator_type = xoptional_assembly_storage_iterator<VE, FE, is_const>;
+        using iterator_type = xoptional_assembly_linear_iterator<VE, FE, is_const>;
         using xoptional_assembly_storage_type = xoptional_assembly_storage<VE, FE>;
         using value_type = typename xoptional_assembly_storage_type::value_type;
-        using reference = std::conditional_t<is_const,
-                                             typename xoptional_assembly_storage_type::const_reference,
-                                             typename xoptional_assembly_storage_type::reference>;
+        using reference = std::conditional_t<
+            is_const,
+            typename xoptional_assembly_storage_type::const_reference,
+            typename xoptional_assembly_storage_type::reference>;
         using difference_type = typename xoptional_assembly_storage_type::difference_type;
-        using pointer = std::conditional_t<is_const,
-                                           typename xoptional_assembly_storage_type::const_pointer,
-                                           typename xoptional_assembly_storage_type::pointer>;
+        using pointer = std::conditional_t<
+            is_const,
+            typename xoptional_assembly_storage_type::const_pointer,
+            typename xoptional_assembly_storage_type::pointer>;
     };
 
     template <class VE, class FE, bool is_const>
-    class xoptional_assembly_storage_iterator
-        : public xtl::xrandom_access_iterator_base2<xoptional_assembly_storage_iterator_traits<VE, FE, is_const>>
+    class xoptional_assembly_linear_iterator
+        : public xtl::xrandom_access_iterator_base2<xoptional_assembly_linear_iterator_traits<VE, FE, is_const>>
     {
     public:
 
-        using self_type = xoptional_assembly_storage_iterator<VE, FE, is_const>;
-        using base_type = xtl::xrandom_access_iterator_base2<xoptional_assembly_storage_iterator_traits<VE, FE, is_const>>;
+        using self_type = xoptional_assembly_linear_iterator<VE, FE, is_const>;
+        using base_type = xtl::xrandom_access_iterator_base2<
+            xoptional_assembly_linear_iterator_traits<VE, FE, is_const>>;
 
         using xoptional_assembly_storage_type = xoptional_assembly_storage<VE, FE>;
-        using value_iterator = std::conditional_t<is_const,
-                                                  typename xoptional_assembly_storage_type::value_storage::const_iterator,
-                                                  typename xoptional_assembly_storage_type::value_storage::iterator>;
-        using flag_iterator = std::conditional_t<is_const,
-                                                 typename xoptional_assembly_storage_type::flag_storage::const_iterator,
-                                                 typename xoptional_assembly_storage_type::flag_storage::iterator>;
+        using value_iterator = std::conditional_t<
+            is_const,
+            typename xoptional_assembly_storage_type::value_storage::const_iterator,
+            typename xoptional_assembly_storage_type::value_storage::iterator>;
+        using flag_iterator = std::conditional_t<
+            is_const,
+            typename xoptional_assembly_storage_type::flag_storage::const_iterator,
+            typename xoptional_assembly_storage_type::flag_storage::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;
 
-        xoptional_assembly_storage_iterator(value_iterator value_it, flag_iterator flag_it);
+        xoptional_assembly_linear_iterator(value_iterator value_it, flag_iterator flag_it);
 
         self_type& operator++();
         self_type& operator--();
@@ -212,20 +219,23 @@ namespace xt
     template <class VE, class FE>
     template <class VE1, class FE1>
     inline xoptional_assembly_storage<VE, FE>::xoptional_assembly_storage(const VE1& value_stor, const FE1& flag_stor)
-        : m_value(value_stor), m_has_value(flag_stor)
+        : m_value(value_stor)
+        , m_has_value(flag_stor)
     {
     }
 
     template <class VE, class FE>
     template <class VE1, class FE1>
     inline xoptional_assembly_storage<VE, FE>::xoptional_assembly_storage(VE1& value_stor, FE1& flag_stor)
-        : m_value(value_stor), m_has_value(flag_stor)
+        : m_value(value_stor)
+        , m_has_value(flag_stor)
     {
     }
 
     template <class VE, class FE>
     inline xoptional_assembly_storage<VE, FE>::xoptional_assembly_storage(const self_type& rhs)
-        : m_value(rhs.m_value), m_has_value(rhs.m_has_value)
+        : m_value(rhs.m_value)
+        , m_has_value(rhs.m_has_value)
     {
     }
 
@@ -239,15 +249,16 @@ namespace xt
 
     template <class VE, class FE>
     inline xoptional_assembly_storage<VE, FE>::xoptional_assembly_storage(self_type&& rhs)
-        : m_value(std::move(rhs.m_value)), m_has_value(std::move(rhs.m_has_value))
+        : m_value(std::forward<VE>(rhs.m_value))
+        , m_has_value(std::forward<FE>(rhs.m_has_value))
     {
     }
 
     template <class VE, class FE>
     inline auto xoptional_assembly_storage<VE, FE>::operator=(self_type&& rhs) -> self_type&
     {
-        m_value = std::move(rhs.m_value);
-        m_has_value = std::move(rhs.m_has_value);
+        m_value = std::forward<VE>(rhs.m_value);
+        m_has_value = std::forward<FE>(rhs.m_has_value);
         return *this;
     }
 
@@ -422,13 +433,15 @@ namespace xt
     }
 
     template <class VE, class FE>
-    bool operator==(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
+    bool
+    operator==(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
     {
         return lhs.value() == rhs.value() && lhs.has_value() == rhs.has_value();
     }
 
     template <class VE, class FE>
-    bool operator!=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
+    bool
+    operator!=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
     {
         return !(lhs == rhs);
     }
@@ -440,7 +453,8 @@ namespace xt
     }
 
     template <class VE, class FE>
-    bool operator<=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
+    bool
+    operator<=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
     {
         return lhs.value() <= rhs.value() && lhs.has_value() == rhs.has_value();
     }
@@ -452,7 +466,8 @@ namespace xt
     }
 
     template <class VE, class FE>
-    bool operator>=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
+    bool
+    operator>=(const xoptional_assembly_storage<VE, FE>& lhs, const xoptional_assembly_storage<VE, FE>& rhs)
     {
         return lhs.value() >= rhs.value() && lhs.has_value() == rhs.has_value();
     }
@@ -464,17 +479,21 @@ namespace xt
     }
 
     /******************************************************
-     * xoptional_assembly_storage_iterator implementation *
+     * xoptional_assembly_linear_iterator implementation *
      ******************************************************/
 
     template <class VE, class FE, bool C>
-    inline xoptional_assembly_storage_iterator<VE, FE, C>::xoptional_assembly_storage_iterator(value_iterator value_it, flag_iterator flag_it)
-        : m_value_it(value_it), m_flag_it(flag_it)
+    inline xoptional_assembly_linear_iterator<VE, FE, C>::xoptional_assembly_linear_iterator(
+        value_iterator value_it,
+        flag_iterator flag_it
+    )
+        : m_value_it(value_it)
+        , m_flag_it(flag_it)
     {
     }
 
     template <class VE, class FE, bool C>
-    inline auto xoptional_assembly_storage_iterator<VE, FE, C>::operator++() -> self_type&
+    inline auto xoptional_assembly_linear_iterator<VE, FE, C>::operator++() -> self_type&
     {
         ++m_value_it;
         ++m_flag_it;
@@ -482,7 +501,7 @@ namespace xt
     }
 
     template <class VE, class FE, bool C>
-    inline auto xoptional_assembly_storage_iterator<VE, FE, C>::operator--() -> self_type&
+    inline auto xoptional_assembly_linear_iterator<VE, FE, C>::operator--() -> self_type&
     {
         --m_value_it;
         --m_flag_it;
@@ -490,7 +509,7 @@ namespace xt
     }
 
     template <class VE, class FE, bool C>
-    inline auto xoptional_assembly_storage_iterator<VE, FE, C>::operator+=(difference_type n) -> self_type&
+    inline auto xoptional_assembly_linear_iterator<VE, FE, C>::operator+=(difference_type n) -> self_type&
     {
         m_value_it += n;
         m_flag_it += n;
@@ -498,7 +517,7 @@ namespace xt
     }
 
     template <class VE, class FE, bool C>
-    inline auto xoptional_assembly_storage_iterator<VE, FE, C>::operator-=(difference_type n) -> self_type&
+    inline auto xoptional_assembly_linear_iterator<VE, FE, C>::operator-=(difference_type n) -> self_type&
     {
         m_value_it -= n;
         m_flag_it -= n;
@@ -506,31 +525,32 @@ namespace xt
     }
 
     template <class VE, class FE, bool C>
-    inline auto xoptional_assembly_storage_iterator<VE, FE, C>::operator-(const self_type& rhs) const -> difference_type
+    inline auto xoptional_assembly_linear_iterator<VE, FE, C>::operator-(const self_type& rhs) const
+        -> difference_type
     {
         return m_value_it - rhs.m_value_it;
     }
 
     template <class VE, class FE, bool C>
-    inline auto xoptional_assembly_storage_iterator<VE, FE, C>::operator*() const -> reference
+    inline auto xoptional_assembly_linear_iterator<VE, FE, C>::operator*() const -> reference
     {
         return reference(*m_value_it, *m_flag_it);
     }
 
     template <class VE, class FE, bool C>
-    inline auto xoptional_assembly_storage_iterator<VE, FE, C>::operator->() const -> pointer
+    inline auto xoptional_assembly_linear_iterator<VE, FE, C>::operator->() const -> pointer
     {
         return &(this->operator*());
     }
 
     template <class VE, class FE, bool C>
-    inline bool xoptional_assembly_storage_iterator<VE, FE, C>::operator==(const self_type& rhs) const
+    inline bool xoptional_assembly_linear_iterator<VE, FE, C>::operator==(const self_type& rhs) const
     {
         return m_value_it == rhs.m_value_it;
     }
 
     template <class VE, class FE, bool C>
-    inline bool xoptional_assembly_storage_iterator<VE, FE, C>::operator<(const self_type& rhs) const
+    inline bool xoptional_assembly_linear_iterator<VE, FE, C>::operator<(const self_type& rhs) const
     {
         return m_value_it < rhs.m_value_it;
     }
diff --git a/include/xtensor/xaccumulator.hpp b/include/xtensor/reducers/xaccumulator.hpp
similarity index 52%
rename from include/xtensor/xaccumulator.hpp
rename to include/xtensor/reducers/xaccumulator.hpp
index be85b76c5..50d927e21 100644
--- a/include/xtensor/xaccumulator.hpp
+++ b/include/xtensor/reducers/xaccumulator.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_ACCUMULATOR_HPP
 #define XTENSOR_ACCUMULATOR_HPP
@@ -14,27 +15,37 @@
 #include <numeric>
 #include <type_traits>
 
-#include "xexpression.hpp"
-#include "xstrides.hpp"
-#include "xtensor_forward.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../core/xtensor_forward.hpp"
 
 namespace xt
 {
 
-#define DEFAULT_STRATEGY_ACCUMULATORS evaluation_strategy::immediate
+#define DEFAULT_STRATEGY_ACCUMULATORS evaluation_strategy::immediate_type
+
+    namespace detail
+    {
+        template <class V = void>
+        struct accumulator_identity : xtl::identity
+        {
+            using value_type = V;
+        };
+    }
 
     /**************
      * accumulate *
      **************/
 
-    template <class ACCUMULATE_FUNC, class INIT_FUNC = xtl::identity>
-    struct xaccumulator_functor
-        : public std::tuple<ACCUMULATE_FUNC, INIT_FUNC>
+    template <class ACCUMULATE_FUNC, class INIT_FUNC = detail::accumulator_identity<void>>
+    struct xaccumulator_functor : public std::tuple<ACCUMULATE_FUNC, INIT_FUNC>
     {
         using self_type = xaccumulator_functor<ACCUMULATE_FUNC, INIT_FUNC>;
         using base_type = std::tuple<ACCUMULATE_FUNC, INIT_FUNC>;
         using accumulate_functor_type = ACCUMULATE_FUNC;
         using init_functor_type = INIT_FUNC;
+        using init_value_type = typename init_functor_type::value_type;
 
         xaccumulator_functor()
             : base_type()
@@ -73,13 +84,19 @@ namespace xt
         template <class F, class E, class EVS>
         xarray<typename std::decay_t<E>::value_type> accumulator_impl(F&&, E&&, std::size_t, EVS)
         {
-            static_assert(!std::is_same<evaluation_strategy::lazy, EVS>::value, "Lazy accumulators not yet implemented.");
+            static_assert(
+                !std::is_same<evaluation_strategy::lazy_type, EVS>::value,
+                "Lazy accumulators not yet implemented."
+            );
         }
 
         template <class F, class E, class EVS>
         xarray<typename std::decay_t<E>::value_type> accumulator_impl(F&&, E&&, EVS)
         {
-            static_assert(!std::is_same<evaluation_strategy::lazy, EVS>::value, "Lazy accumulators not yet implemented.");
+            static_assert(
+                !std::is_same<evaluation_strategy::lazy_type, EVS>::value,
+                "Lazy accumulators not yet implemented."
+            );
         }
 
         template <class T, class R>
@@ -149,17 +166,29 @@ namespace xt
             std::size_t outer_loop_size, inner_loop_size, pos = 0;
             std::size_t outer_stride, inner_stride;
 
-            auto set_loop_sizes = [&outer_loop_size, &inner_loop_size](auto first, auto last, std::ptrdiff_t ax) {
-                outer_loop_size = std::accumulate(first, first + ax,
-                                                  std::size_t(1), std::multiplies<std::size_t>());
-                inner_loop_size = std::accumulate(first + ax + 1, last,
-                                                  std::size_t(1), std::multiplies<std::size_t>());
+            auto set_loop_sizes = [&outer_loop_size, &inner_loop_size](auto first, auto last, std::ptrdiff_t ax)
+            {
+                outer_loop_size = std::accumulate(
+                    first,
+                    first + ax,
+                    std::size_t(1),
+                    std::multiplies<std::size_t>()
+                );
+                inner_loop_size = std::accumulate(
+                    first + ax + 1,
+                    last,
+                    std::size_t(1),
+                    std::multiplies<std::size_t>()
+                );
             };
 
             // Note: add check that strides > 0
-            auto set_loop_strides = [&outer_stride, &inner_stride](auto first, auto last, std::ptrdiff_t ax) {
+            auto set_loop_strides = [&outer_stride, &inner_stride](auto first, auto last, std::ptrdiff_t ax)
+            {
                 outer_stride = static_cast<std::size_t>(ax == 0 ? 1 : *std::min_element(first, first + ax));
-                inner_stride = static_cast<std::size_t>((ax == std::distance(first, last) - 1) ? 1 : *std::min_element(first + ax + 1, last));
+                inner_stride = static_cast<std::size_t>(
+                    (ax == std::distance(first, last) - 1) ? 1 : *std::min_element(first + ax + 1, last)
+                );
             };
 
             set_loop_sizes(e.shape().begin(), e.shape().end(), static_cast<std::ptrdiff_t>(axis));
@@ -184,87 +213,118 @@ namespace xt
         }
 
         template <class F, class E>
-        inline auto accumulator_impl(F&& f, E&& e, std::size_t axis, evaluation_strategy::immediate)
+        inline auto accumulator_impl(F&& f, E&& e, std::size_t axis, evaluation_strategy::immediate_type)
         {
-            using accumulate_functor = std::decay_t<decltype(std::get<0>(f))>;
-            using function_return_type = typename accumulate_functor::result_type;
-            using result_type = xaccumulator_return_type_t<std::decay_t<E>, function_return_type>;
+            using init_type = typename F::init_value_type;
+            using accumulate_functor_type = typename F::accumulate_functor_type;
+            using expr_value_type = typename std::decay_t<E>::value_type;
+            // using return_type = std::conditional_t<std::is_same<init_type, void>::value, typename
+            // std::decay_t<E>::value_type, init_type>;
+
+            using return_type = std::decay_t<decltype(std::declval<accumulate_functor_type>()(
+                std::declval<init_type>(),
+                std::declval<expr_value_type>()
+            ))>;
+
+            using result_type = xaccumulator_return_type_t<std::decay_t<E>, return_type>;
 
             if (axis >= e.dimension())
             {
-                throw std::runtime_error("Axis larger than expression dimension in accumulator.");
+                XTENSOR_THROW(std::runtime_error, "Axis larger than expression dimension in accumulator.");
             }
 
-            result_type result = e;  // assign + make a copy, we need it anyways
-
-            std::size_t inner_stride = static_cast<std::size_t>(result.strides()[axis]);
-            std::size_t outer_stride = 1;  // this is either going row- or column-wise (strides.back / strides.front)
-            std::size_t outer_loop_size = 0;
-            std::size_t inner_loop_size = 0;
+            result_type res = e;  // assign + make a copy, we need it anyways
 
-            auto set_loop_sizes = [&outer_loop_size, &inner_loop_size](auto first, auto last, std::ptrdiff_t ax) {
-                outer_loop_size = std::accumulate(first,
-                                                  first + ax,
-                                                  std::size_t(1), std::multiplies<std::size_t>());
+            if (res.shape(axis) != std::size_t(0))
+            {
+                std::size_t inner_stride = static_cast<std::size_t>(res.strides()[axis]);
+                std::size_t outer_stride = 1;  // either row- or column-wise (strides.back / strides.front)
+                std::size_t outer_loop_size = 0;
+                std::size_t inner_loop_size = 0;
+                std::size_t init_size = e.shape()[axis] != std::size_t(1) ? std::size_t(1) : std::size_t(0);
+
+                auto set_loop_sizes =
+                    [&outer_loop_size, &inner_loop_size, init_size](auto first, auto last, std::ptrdiff_t ax)
+                {
+                    outer_loop_size = std::accumulate(first, first + ax, init_size, std::multiplies<std::size_t>());
 
-                inner_loop_size = std::accumulate(first + ax,
-                                                  last,
-                                                  std::size_t(1), std::multiplies<std::size_t>());
-            };
+                    inner_loop_size = std::accumulate(
+                        first + ax,
+                        last,
+                        std::size_t(1),
+                        std::multiplies<std::size_t>()
+                    );
+                };
 
-            if (result_type::static_layout == layout_type::row_major)
-            {
-                set_loop_sizes(result.shape().cbegin(), result.shape().cend(), static_cast<std::ptrdiff_t>(axis));
-            }
-            else
-            {
-                set_loop_sizes(result.shape().cbegin(), result.shape().cend(), static_cast<std::ptrdiff_t>(axis + 1));
-                std::swap(inner_loop_size, outer_loop_size);
-            }
+                if (result_type::static_layout == layout_type::row_major)
+                {
+                    set_loop_sizes(res.shape().cbegin(), res.shape().cend(), static_cast<std::ptrdiff_t>(axis));
+                }
+                else
+                {
+                    set_loop_sizes(res.shape().cbegin(), res.shape().cend(), static_cast<std::ptrdiff_t>(axis + 1));
+                    std::swap(inner_loop_size, outer_loop_size);
+                }
 
-            std::size_t pos = 0;
+                std::size_t pos = 0;
 
-            inner_loop_size = inner_loop_size - inner_stride;
+                inner_loop_size = inner_loop_size - inner_stride;
 
-            // activate the init loop if we have an init function other than identity
-            if (!std::is_same<decltype(std::get<1>(f)), xtl::identity>::value)
-            {
-                accumulator_init_with_f(std::get<1>(f), result, axis);
-            }
+                // activate the init loop if we have an init function other than identity
+                if (!std::is_same<
+                        std::decay_t<typename F::init_functor_type>,
+                        typename detail::accumulator_identity<init_type>>::value)
+                {
+                    accumulator_init_with_f(xt::get<1>(f), res, axis);
+                }
 
-            pos = 0;
-            for (std::size_t i = 0; i < outer_loop_size; ++i)
-            {
-                for (std::size_t j = 0; j < inner_loop_size; ++j)
+                pos = 0;
+                for (std::size_t i = 0; i < outer_loop_size; ++i)
                 {
-                    result.storage()[pos + inner_stride] = std::get<0>(f)(result.storage()[pos],
-                                                                          result.storage()[pos + inner_stride]);
-                    pos += outer_stride;
+                    for (std::size_t j = 0; j < inner_loop_size; ++j)
+                    {
+                        res.storage()[pos + inner_stride] = xt::get<0>(f)(
+                            res.storage()[pos],
+                            res.storage()[pos + inner_stride]
+                        );
+
+                        pos += outer_stride;
+                    }
+                    pos += inner_stride;
                 }
-                pos += inner_stride;
             }
-            return result;
+            return res;
         }
 
         template <class F, class E>
-        inline auto accumulator_impl(F&& f, E&& e, evaluation_strategy::immediate)
+        inline auto accumulator_impl(F&& f, E&& e, evaluation_strategy::immediate_type)
         {
-            using accumulate_functor = std::decay_t<decltype(std::get<0>(f))>;
-            using T = typename accumulate_functor::result_type;
+            using init_type = typename F::init_value_type;
+            using expr_value_type = typename std::decay_t<E>::value_type;
+            using accumulate_functor_type = typename F::accumulate_functor_type;
+            using return_type = std::decay_t<decltype(std::declval<accumulate_functor_type>()(
+                std::declval<init_type>(),
+                std::declval<expr_value_type>()
+            ))>;
+            // using return_type = std::conditional_t<std::is_same<init_type, void>::value, typename
+            // std::decay_t<E>::value_type, init_type>;
+
+            using result_type = xaccumulator_return_type_t<std::decay_t<E>, return_type>;
 
-            using result_type = xaccumulator_linear_return_type_t<std::decay_t<E>, T>;
             std::size_t sz = e.size();
             auto result = result_type::from_shape({sz});
 
-            auto it = e.template begin<XTENSOR_DEFAULT_LAYOUT>();
-
-            result.storage()[0] = std::get<1>(f)(*it);
-            ++it;
-
-            for (std::size_t idx = 0; it != e.template end<XTENSOR_DEFAULT_LAYOUT>(); ++it)
+            if (sz != std::size_t(0))
             {
-                result.storage()[idx + 1] = std::get<0>(f)(result.storage()[idx], *it);
-                ++idx;
+                auto it = e.template begin<XTENSOR_DEFAULT_TRAVERSAL>();
+                result.storage()[0] = xt::get<1>(f)(*it);
+                ++it;
+
+                for (std::size_t idx = 0; it != e.template end<XTENSOR_DEFAULT_TRAVERSAL>(); ++it)
+                {
+                    result.storage()[idx + 1] = xt::get<0>(f)(result.storage()[idx], *it);
+                    ++idx;
+                }
             }
             return result;
         }
@@ -280,12 +340,11 @@ namespace xt
      *
      * @return returns xarray<T> filled with accumulated values
      */
-    template <class F, class E, class EVS = DEFAULT_STRATEGY_ACCUMULATORS,
-              typename std::enable_if_t<!std::is_integral<EVS>::value, int> = 0>
+    template <class F, class E, class EVS = DEFAULT_STRATEGY_ACCUMULATORS, XTL_REQUIRES(is_evaluation_strategy<EVS>)>
     inline auto accumulate(F&& f, E&& e, EVS evaluation_strategy = EVS())
     {
-        // Note we need to check is_integral above in order to prohibit EVS = int, and not taking the std::size_t
-        // overload below!
+        // Note we need to check is_integral above in order to prohibit EVS = int, and not taking the
+        // std::size_t overload below!
         return detail::accumulator_impl(std::forward<F>(f), std::forward<E>(e), evaluation_strategy);
     }
 
diff --git a/include/xtensor/reducers/xblockwise_reducer.hpp b/include/xtensor/reducers/xblockwise_reducer.hpp
new file mode 100644
index 000000000..902b41f08
--- /dev/null
+++ b/include/xtensor/reducers/xblockwise_reducer.hpp
@@ -0,0 +1,533 @@
+#ifndef XTENSOR_XBLOCKWISE_REDUCER_HPP
+#define XTENSOR_XBLOCKWISE_REDUCER_HPP
+
+#include "../core/xmultiindex_iterator.hpp"
+#include "../core/xshape.hpp"
+#include "../reducers/xblockwise_reducer_functors.hpp"
+#include "../reducers/xreducer.hpp"
+#include "xtl/xclosure.hpp"
+#include "xtl/xsequence.hpp"
+
+namespace xt
+{
+
+    template <class CT, class F, class X, class O>
+    class xblockwise_reducer
+    {
+    public:
+
+        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>;
+
+
+        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;
+
+    private:
+
+        using mapping_type = filter_fixed_shape_t<shape_type>;
+        using input_chunked_view_type = xchunked_view<const std::decay_t<CT>&>;
+        using input_const_chunked_iterator_type = typename input_chunked_view_type::const_chunk_iterator;
+        using input_chunk_range_type = std::array<xmultiindex_iterator<input_chunk_index_type>, 2>;
+
+        template <class CI>
+        void assign_to_chunk(CI& result_chunk_iter) const;
+
+        template <class CI>
+        input_chunk_range_type compute_input_chunk_range(CI& result_chunk_iter) const;
+
+        input_const_chunked_iterator_type get_input_chunk_iter(input_chunk_index_type input_chunk_index) const;
+        void init_shapes();
+
+        CT m_e;
+        xchunked_view<const std::decay_t<CT>&> m_e_chunked_view;
+        axes_type m_axes;
+        raw_options_type m_options;
+        functor_type m_functor;
+        shape_type m_result_shape;
+        chunk_shape_type m_result_chunk_shape;
+        mapping_type m_mapping;
+        input_grid_strides m_input_grid_strides;
+    };
+
+    template <class CT, class F, class X, class O>
+    template <class E, class BS, class XX, class OO, class FF>
+    xblockwise_reducer<CT, F, X, O>::xblockwise_reducer(E&& e, BS&& block_shape, XX&& axes, OO&& options, FF&& functor)
+        : m_e(std::forward<E>(e))
+        , m_e_chunked_view(m_e, std::forward<BS>(block_shape))
+        , m_axes(std::forward<XX>(axes))
+        , m_options(std::forward<OO>(options))
+        , m_functor(std::forward<FF>(functor))
+        , m_result_shape()
+        , m_result_chunk_shape()
+        , m_mapping()
+        , m_input_grid_strides()
+    {
+        init_shapes();
+        resize_container(m_input_grid_strides, m_e.dimension());
+        std::size_t stride = 1;
+
+        for (std::size_t i = m_input_grid_strides.size(); i != 0; --i)
+        {
+            m_input_grid_strides[i - 1] = stride;
+            stride *= m_e_chunked_view.grid_shape()[i - 1];
+        }
+    }
+
+    template <class CT, class F, class X, class O>
+    inline auto xblockwise_reducer<CT, F, X, O>::input_shape() const -> const input_shape_type&
+    {
+        return m_e.shape();
+    }
+
+    template <class CT, class F, class X, class O>
+    inline auto xblockwise_reducer<CT, F, X, O>::axes() const -> const axes_type&
+    {
+        return m_axes;
+    }
+
+    template <class CT, class F, class X, class O>
+    inline std::size_t xblockwise_reducer<CT, F, X, O>::dimension() const
+    {
+        return m_result_shape.size();
+    }
+
+    template <class CT, class F, class X, class O>
+    inline auto xblockwise_reducer<CT, F, X, O>::shape() const -> const shape_type&
+    {
+        return m_result_shape;
+    }
+
+    template <class CT, class F, class X, class O>
+    inline auto xblockwise_reducer<CT, F, X, O>::chunk_shape() const -> const chunk_shape_type&
+    {
+        return m_result_chunk_shape;
+    }
+
+    template <class CT, class F, class X, class O>
+    template <class R>
+    inline void xblockwise_reducer<CT, F, X, O>::assign_to(R& result) const
+    {
+        auto result_chunked_view = as_chunked(result, m_result_chunk_shape);
+        for (auto chunk_iter = result_chunked_view.chunk_begin(); chunk_iter != result_chunked_view.chunk_end();
+             ++chunk_iter)
+        {
+            assign_to_chunk(chunk_iter);
+        }
+    }
+
+    template <class CT, class F, class X, class O>
+    auto xblockwise_reducer<CT, F, X, O>::get_input_chunk_iter(input_chunk_index_type input_chunk_index) const
+        -> input_const_chunked_iterator_type
+    {
+        std::size_t chunk_linear_index = 0;
+        for (std::size_t i = 0; i < m_e_chunked_view.dimension(); ++i)
+        {
+            chunk_linear_index += input_chunk_index[i] * m_input_grid_strides[i];
+        }
+        return input_const_chunked_iterator_type(m_e_chunked_view, std::move(input_chunk_index), chunk_linear_index);
+    }
+
+    template <class CT, class F, class X, class O>
+    template <class CI>
+    void xblockwise_reducer<CT, F, X, O>::assign_to_chunk(CI& result_chunk_iter) const
+    {
+        auto result_chunk_view = *result_chunk_iter;
+        auto reduction_variable = m_functor.reduction_variable(result_chunk_view);
+
+        // get the range of input chunks we need to compute the desired ouput chunk
+        auto range = compute_input_chunk_range(result_chunk_iter);
+
+        // iterate over input chunk (indics)
+        auto first = true;
+        // std::for_each(std::get<0>(range), std::get<1>(range), [&](auto && input_chunk_index)
+        auto iter = std::get<0>(range);
+        while (iter != std::get<1>(range))
+        {
+            const auto& input_chunk_index = *iter;
+            // get input chunk iterator from chunk index
+            auto chunked_input_iter = this->get_input_chunk_iter(input_chunk_index);
+            auto input_chunk_view = *chunked_input_iter;
+
+            // compute the per block result
+            auto block_res = m_functor.compute(input_chunk_view, m_axes, m_options);
+
+            // merge
+            m_functor.merge(block_res, first, result_chunk_view, reduction_variable);
+            first = false;
+            ++iter;
+        }
+
+        // finalize (ie smth like normalization)
+        m_functor.finalize(reduction_variable, result_chunk_view, *this);
+    }
+
+    template <class CT, class F, class X, class O>
+    template <class CI>
+    auto xblockwise_reducer<CT, F, X, O>::compute_input_chunk_range(CI& result_chunk_iter) const
+        -> input_chunk_range_type
+    {
+        auto input_chunks_begin = xtl::make_sequence<input_chunk_index_type>(m_e_chunked_view.dimension(), 0);
+        auto input_chunks_end = xtl::make_sequence<input_chunk_index_type>(m_e_chunked_view.dimension());
+
+        XTENSOR_ASSERT(input_chunks_begin.size() == m_e_chunked_view.dimension());
+        XTENSOR_ASSERT(input_chunks_end.size() == m_e_chunked_view.dimension());
+
+        std::copy(
+            m_e_chunked_view.grid_shape().begin(),
+            m_e_chunked_view.grid_shape().end(),
+            input_chunks_end.begin()
+        );
+
+        const auto& chunk_index = result_chunk_iter.chunk_index();
+        for (std::size_t result_ax_index = 0; result_ax_index < m_result_shape.size(); ++result_ax_index)
+        {
+            if (m_result_shape[result_ax_index] != 1)
+            {
+                const auto input_ax_index = m_mapping[result_ax_index];
+                input_chunks_begin[input_ax_index] = chunk_index[result_ax_index];
+                input_chunks_end[input_ax_index] = chunk_index[result_ax_index] + 1;
+            }
+        }
+        return input_chunk_range_type{
+            multiindex_iterator_begin<input_chunk_index_type>(input_chunks_begin, input_chunks_end),
+            multiindex_iterator_end<input_chunk_index_type>(input_chunks_begin, input_chunks_end)
+        };
+    }
+
+    template <class CT, class F, class X, class O>
+    void xblockwise_reducer<CT, F, X, O>::init_shapes()
+    {
+        const auto& shape = m_e.shape();
+        const auto dimension = m_e.dimension();
+        const auto& block_shape = m_e_chunked_view.chunk_shape();
+        if (xtl::mpl::contains<raw_options_type, xt::keep_dims_type>::value)
+        {
+            resize_container(m_result_shape, dimension);
+            resize_container(m_result_chunk_shape, dimension);
+            resize_container(m_mapping, dimension);
+            for (std::size_t i = 0; i < dimension; ++i)
+            {
+                m_mapping[i] = i;
+                if (std::find(m_axes.begin(), m_axes.end(), i) == m_axes.end())
+                {
+                    // i not in m_axes!
+                    m_result_shape[i] = shape[i];
+                    m_result_chunk_shape[i] = block_shape[i];
+                }
+                else
+                {
+                    m_result_shape[i] = 1;
+                    m_result_chunk_shape[i] = 1;
+                }
+            }
+        }
+        else
+        {
+            const auto result_dim = dimension - m_axes.size();
+            resize_container(m_result_shape, result_dim);
+            resize_container(m_result_chunk_shape, result_dim);
+            resize_container(m_mapping, result_dim);
+
+            for (std::size_t i = 0, idx = 0; i < dimension; ++i)
+            {
+                if (std::find(m_axes.begin(), m_axes.end(), i) == m_axes.end())
+                {
+                    // i not in axes!
+                    m_result_shape[idx] = shape[i];
+                    m_result_chunk_shape[idx] = block_shape[i];
+                    m_mapping[idx] = i;
+                    ++idx;
+                }
+            }
+        }
+    }
+
+    template <class E, class CS, class A, class O, class FF>
+    inline auto blockwise_reducer(E&& e, CS&& chunk_shape, A&& axes, O&& raw_options, FF&& functor)
+    {
+        using functor_type = std::decay_t<FF>;
+        using closure_type = xtl::const_closure_type_t<E>;
+        using axes_type = std::decay_t<A>;
+
+        return xblockwise_reducer<closure_type, functor_type, axes_type, O>(
+            std::forward<E>(e),
+            std::forward<CS>(chunk_shape),
+            std::forward<A>(axes),
+            std::forward<O>(raw_options),
+            std::forward<FF>(functor)
+        );
+    }
+
+    namespace blockwise
+    {
+
+#define XTENSOR_BLOCKWISE_REDUCER_FUNC(FNAME, FUNCTOR)                                                        \
+    template <                                                                                                \
+        class T = void,                                                                                       \
+        class E,                                                                                              \
+        class BS,                                                                                             \
+        class X,                                                                                              \
+        class O = DEFAULT_STRATEGY_REDUCERS,                                                                  \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)> \
+    auto FNAME(E&& e, BS&& block_shape, X&& axes, O options = O())                                            \
+    {                                                                                                         \
+        using input_expression_type = std::decay_t<E>;                                                        \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type, T>;                          \
+        return blockwise_reducer(                                                                             \
+            std::forward<E>(e),                                                                               \
+            std::forward<BS>(block_shape),                                                                    \
+            std::forward<X>(axes),                                                                            \
+            std::forward<O>(options),                                                                         \
+            functor_type()                                                                                    \
+        );                                                                                                    \
+    }                                                                                                         \
+    template <                                                                                                \
+        class T = void,                                                                                       \
+        class E,                                                                                              \
+        class BS,                                                                                             \
+        class X,                                                                                              \
+        class O = DEFAULT_STRATEGY_REDUCERS,                                                                  \
+        XTL_REQUIRES(xtl::is_integral<std::decay_t<X>>)>                                                      \
+    auto FNAME(E&& e, BS&& block_shape, X axis, O options = O())                                              \
+    {                                                                                                         \
+        std::array<X, 1> axes{axis};                                                                          \
+        using input_expression_type = std::decay_t<E>;                                                        \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type, T>;                          \
+        return blockwise_reducer(                                                                             \
+            std::forward<E>(e),                                                                               \
+            std::forward<BS>(block_shape),                                                                    \
+            axes,                                                                                             \
+            std::forward<O>(options),                                                                         \
+            functor_type()                                                                                    \
+        );                                                                                                    \
+    }                                                                                                         \
+    template <                                                                                                \
+        class T = void,                                                                                       \
+        class E,                                                                                              \
+        class BS,                                                                                             \
+        class O = DEFAULT_STRATEGY_REDUCERS,                                                                  \
+        XTL_REQUIRES(is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>)>                \
+    auto FNAME(E&& e, BS&& block_shape, O options = O())                                                      \
+    {                                                                                                         \
+        using input_expression_type = std::decay_t<E>;                                                        \
+        using axes_type = filter_fixed_shape_t<typename input_expression_type::shape_type>;                   \
+        axes_type axes = xtl::make_sequence<axes_type>(e.dimension());                                        \
+        XTENSOR_ASSERT(axes.size() == e.dimension());                                                         \
+        std::iota(axes.begin(), axes.end(), 0);                                                               \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type, T>;                          \
+        return blockwise_reducer(                                                                             \
+            std::forward<E>(e),                                                                               \
+            std::forward<BS>(block_shape),                                                                    \
+            std::move(axes),                                                                                  \
+            std::forward<O>(options),                                                                         \
+            functor_type()                                                                                    \
+        );                                                                                                    \
+    }                                                                                                         \
+    template <class T = void, class E, class BS, class I, std::size_t N, class O = DEFAULT_STRATEGY_REDUCERS> \
+    auto FNAME(E&& e, BS&& block_shape, const I(&axes)[N], O options = O())                                   \
+    {                                                                                                         \
+        using input_expression_type = std::decay_t<E>;                                                        \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type, T>;                          \
+        using axes_type = std::array<std::size_t, N>;                                                         \
+        auto ax = xt::forward_normalize<axes_type>(e, axes);                                                  \
+        return blockwise_reducer(                                                                             \
+            std::forward<E>(e),                                                                               \
+            std::forward<BS>(block_shape),                                                                    \
+            std::move(ax),                                                                                    \
+            std::forward<O>(options),                                                                         \
+            functor_type()                                                                                    \
+        );                                                                                                    \
+    }
+        XTENSOR_BLOCKWISE_REDUCER_FUNC(sum, xt::detail::blockwise::sum_functor)
+        XTENSOR_BLOCKWISE_REDUCER_FUNC(prod, xt::detail::blockwise::prod_functor)
+        XTENSOR_BLOCKWISE_REDUCER_FUNC(amin, xt::detail::blockwise::amin_functor)
+        XTENSOR_BLOCKWISE_REDUCER_FUNC(amax, xt::detail::blockwise::amax_functor)
+        XTENSOR_BLOCKWISE_REDUCER_FUNC(mean, xt::detail::blockwise::mean_functor)
+        XTENSOR_BLOCKWISE_REDUCER_FUNC(variance, xt::detail::blockwise::variance_functor)
+        XTENSOR_BLOCKWISE_REDUCER_FUNC(stddev, xt::detail::blockwise::stddev_functor)
+
+#undef XTENSOR_BLOCKWISE_REDUCER_FUNC
+
+
+// norm reducers do *not* allow to to pass a template
+// parameter to specifiy the internal computation type
+#define XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(FNAME, FUNCTOR)                                                                     \
+    template <                                                                                                                  \
+        class E,                                                                                                                \
+        class BS,                                                                                                               \
+        class X,                                                                                                                \
+        class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)>                   \
+    auto FNAME(E&& e, BS&& block_shape, X&& axes, O options = O())                                                              \
+    {                                                                                                                           \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            std::forward<X>(axes),                                                                                              \
+            std::forward<O>(options),                                                                                           \
+            functor_type()                                                                                                      \
+        );                                                                                                                      \
+    }                                                                                                                           \
+    template <class E, class BS, class X, class O = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(xtl::is_integral<std::decay_t<X>>)> \
+    auto FNAME(E&& e, BS&& block_shape, X axis, O options = O())                                                                \
+    {                                                                                                                           \
+        std::array<X, 1> axes{axis};                                                                                            \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            axes,                                                                                                               \
+            std::forward<O>(options),                                                                                           \
+            functor_type()                                                                                                      \
+        );                                                                                                                      \
+    }                                                                                                                           \
+    template <                                                                                                                  \
+        class E,                                                                                                                \
+        class BS,                                                                                                               \
+        class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
+        XTL_REQUIRES(is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>)>                                  \
+    auto FNAME(E&& e, BS&& block_shape, O options = O())                                                                        \
+    {                                                                                                                           \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using axes_type = filter_fixed_shape_t<typename input_expression_type::shape_type>;                                     \
+        axes_type axes = xtl::make_sequence<axes_type>(e.dimension());                                                          \
+        XTENSOR_ASSERT(axes.size() == e.dimension());                                                                           \
+        std::iota(axes.begin(), axes.end(), 0);                                                                                 \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            std::move(axes),                                                                                                    \
+            std::forward<O>(options),                                                                                           \
+            functor_type()                                                                                                      \
+        );                                                                                                                      \
+    }                                                                                                                           \
+    template <class E, class BS, class I, std::size_t N, class O = DEFAULT_STRATEGY_REDUCERS>                                   \
+    auto FNAME(E&& e, BS&& block_shape, const I(&axes)[N], O options = O())                                                     \
+    {                                                                                                                           \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        using axes_type = std::array<std::size_t, N>;                                                                           \
+        auto ax = xt::forward_normalize<axes_type>(e, axes);                                                                    \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            std::move(ax),                                                                                                      \
+            std::forward<O>(options),                                                                                           \
+            functor_type()                                                                                                      \
+        );                                                                                                                      \
+    }
+        XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(norm_l0, xt::detail::blockwise::norm_l0_functor)
+        XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(norm_l1, xt::detail::blockwise::norm_l1_functor)
+        XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(norm_l2, xt::detail::blockwise::norm_l2_functor)
+        XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(norm_sq, xt::detail::blockwise::norm_sq_functor)
+        XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(norm_linf, xt::detail::blockwise::norm_linf_functor)
+
+#undef XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC
+
+
+#define XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(FNAME, FUNCTOR)                                                                     \
+    template <                                                                                                                  \
+        class E,                                                                                                                \
+        class BS,                                                                                                               \
+        class X,                                                                                                                \
+        class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<xtl::is_integral<std::decay_t<X>>>)>                   \
+    auto FNAME(E&& e, BS&& block_shape, double p, X&& axes, O options = O())                                                    \
+    {                                                                                                                           \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            std::forward<X>(axes),                                                                                              \
+            std::forward<O>(options),                                                                                           \
+            functor_type(p)                                                                                                     \
+        );                                                                                                                      \
+    }                                                                                                                           \
+    template <class E, class BS, class X, class O = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(xtl::is_integral<std::decay_t<X>>)> \
+    auto FNAME(E&& e, BS&& block_shape, double p, X axis, O options = O())                                                      \
+    {                                                                                                                           \
+        std::array<X, 1> axes{axis};                                                                                            \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            axes,                                                                                                               \
+            std::forward<O>(options),                                                                                           \
+            functor_type(p)                                                                                                     \
+        );                                                                                                                      \
+    }                                                                                                                           \
+    template <                                                                                                                  \
+        class E,                                                                                                                \
+        class BS,                                                                                                               \
+        class O = DEFAULT_STRATEGY_REDUCERS,                                                                                    \
+        XTL_REQUIRES(is_reducer_options<O>, std::negation<xtl::is_integral<std::decay_t<O>>>)>                                  \
+    auto FNAME(E&& e, BS&& block_shape, double p, O options = O())                                                              \
+    {                                                                                                                           \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using axes_type = filter_fixed_shape_t<typename input_expression_type::shape_type>;                                     \
+        axes_type axes = xtl::make_sequence<axes_type>(e.dimension());                                                          \
+        XTENSOR_ASSERT(axes.size() == e.dimension());                                                                           \
+        std::iota(axes.begin(), axes.end(), 0);                                                                                 \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            std::move(axes),                                                                                                    \
+            std::forward<O>(options),                                                                                           \
+            functor_type(p)                                                                                                     \
+        );                                                                                                                      \
+    }                                                                                                                           \
+    template <class E, class BS, class I, std::size_t N, class O = DEFAULT_STRATEGY_REDUCERS>                                   \
+    auto FNAME(E&& e, BS&& block_shape, double p, const I(&axes)[N], O options = O())                                           \
+    {                                                                                                                           \
+        using input_expression_type = std::decay_t<E>;                                                                          \
+        using functor_type = FUNCTOR<typename input_expression_type::value_type>;                                               \
+        using axes_type = std::array<std::size_t, N>;                                                                           \
+        auto ax = xt::forward_normalize<axes_type>(e, axes);                                                                    \
+        return blockwise_reducer(                                                                                               \
+            std::forward<E>(e),                                                                                                 \
+            std::forward<BS>(block_shape),                                                                                      \
+            std::move(ax),                                                                                                      \
+            std::forward<O>(options),                                                                                           \
+            functor_type(p)                                                                                                     \
+        );                                                                                                                      \
+    }
+
+        XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(norm_lp_to_p, xt::detail::blockwise::norm_lp_to_p_functor);
+        XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC(norm_lp, xt::detail::blockwise::norm_lp_functor);
+
+#undef XTENSOR_BLOCKWISE_NORM_REDUCER_FUNC
+    }
+
+}
+
+#endif
diff --git a/include/xtensor/reducers/xblockwise_reducer_functors.hpp b/include/xtensor/reducers/xblockwise_reducer_functors.hpp
new file mode 100644
index 000000000..d6216b2da
--- /dev/null
+++ b/include/xtensor/reducers/xblockwise_reducer_functors.hpp
@@ -0,0 +1,500 @@
+#ifndef XTENSOR_XBLOCKWISE_REDUCER_FUNCTORS_HPP
+#define XTENSOR_XBLOCKWISE_REDUCER_FUNCTORS_HPP
+
+
+#include <tuple>
+
+#include "../chunk/xchunked_array.hpp"
+#include "../chunk/xchunked_assign.hpp"
+#include "../chunk/xchunked_view.hpp"
+#include "../containers/xarray.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xmath.hpp"
+#include "../generators/xbuilder.hpp"
+#include "../reducers/xnorm.hpp"
+#include "../reducers/xreducer.hpp"
+#include "../utils/xutils.hpp"
+#include "xtl/xclosure.hpp"
+#include "xtl/xsequence.hpp"
+
+namespace xt
+{
+    namespace detail
+    {
+        namespace blockwise
+        {
+
+            struct empty_reduction_variable
+            {
+            };
+
+            struct simple_functor_base
+            {
+                template <class E>
+                auto reduction_variable(const E&) const
+                {
+                    return empty_reduction_variable();
+                }
+
+                template <class MR, class E, class R>
+                void finalize(const MR&, E&, const R&) const
+                {
+                }
+            };
+
+            template <class T_E, class T_I = void>
+            struct sum_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::sum<T_I>(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(input, axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+            };
+
+            template <class T_E, class T_I = void>
+            struct prod_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::sum<T_I>(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::prod<value_type>(input, axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) *= block_result;
+                    }
+                }
+            };
+
+            template <class T_E, class T_I = void>
+            struct amin_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::amin<T_I>(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::amin(input, axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) = xt::minimum(block_result, result);
+                    }
+                }
+            };
+
+            template <class T_E, class T_I = void>
+            struct amax_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::amax<T_I>(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::amax(input, axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) = xt::maximum(block_result, result);
+                    }
+                }
+            };
+
+            template <class T_E, class T_I = void>
+            struct mean_functor
+            {
+                using value_type = typename std::decay_t<decltype(xt::mean<T_I>(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(input, axes, options);
+                }
+
+                template <class E>
+                auto reduction_variable(const E&) const
+                {
+                    return empty_reduction_variable();
+                }
+
+                template <class BR, class E>
+                auto merge(const BR& block_result, bool first, E& result, empty_reduction_variable&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+
+                template <class E, class R>
+                void finalize(const empty_reduction_variable&, E& results, const R& reducer) const
+                {
+                    const auto& axes = reducer.axes();
+                    std::decay_t<decltype(reducer.input_shape()[0])> factor = 1;
+                    for (auto a : axes)
+                    {
+                        factor *= reducer.input_shape()[a];
+                    }
+                    xt::noalias(results) /= static_cast<typename E::value_type>(factor);
+                }
+            };
+
+            template <class T_E, class T_I = void>
+            struct variance_functor
+            {
+                using value_type = typename std::decay_t<decltype(xt::variance<T_I>(std::declval<xarray<T_E>>())
+                )>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    double weight = 1.0;
+                    for (auto a : axes)
+                    {
+                        weight *= static_cast<double>(input.shape()[a]);
+                    }
+
+
+                    return std::make_tuple(
+                        xt::variance<value_type>(input, axes, options),
+                        xt::mean<value_type>(input, axes, options),
+                        weight
+                    );
+                }
+
+                template <class E>
+                auto reduction_variable(const E&) const
+                {
+                    return std::make_tuple(xarray<value_type>(), 0.0);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& variance_a, MR& mr) const
+                {
+                    auto& mean_a = std::get<0>(mr);
+                    auto& n_a = std::get<1>(mr);
+
+                    const auto& variance_b = std::get<0>(block_result);
+                    const auto& mean_b = std::get<1>(block_result);
+                    const auto& n_b = std::get<2>(block_result);
+                    if (first)
+                    {
+                        xt::noalias(variance_a) = variance_b;
+                        xt::noalias(mean_a) = mean_b;
+                        n_a += n_b;
+                    }
+                    else
+                    {
+                        auto new_mean = (n_a * mean_a + n_b * mean_b) / (n_a + n_b);
+                        auto new_variance = (n_a * variance_a + n_b * variance_b
+                                             + n_a * xt::pow(mean_a - new_mean, 2)
+                                             + n_b * xt::pow(mean_b - new_mean, 2))
+                                            / (n_a + n_b);
+                        xt::noalias(variance_a) = new_variance;
+                        xt::noalias(mean_a) = new_mean;
+                        n_a += n_b;
+                    }
+                }
+
+                template <class MR, class E, class R>
+                void finalize(const MR&, E&, const R&) const
+                {
+                }
+            };
+
+            template <class T_E, class T_I = void>
+            struct stddev_functor : public variance_functor<T_E, T_I>
+            {
+                template <class MR, class E, class R>
+                void finalize(const MR&, E& results, const R&) const
+                {
+                    xt::noalias(results) = xt::sqrt(results);
+                }
+            };
+
+            template <class T_E>
+            struct norm_l0_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::norm_l0(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(xt::not_equal(input, xt::zeros<T_E>(input.shape())), axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+            };
+
+            template <class T_E>
+            struct norm_l1_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::norm_l1(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(xt::abs(input), axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+            };
+
+            template <class T_E>
+            struct norm_l2_functor
+            {
+                using value_type = typename std::decay_t<decltype(xt::norm_l2(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(xt::square(input), axes, options);
+                }
+
+                template <class E>
+                auto reduction_variable(const E&) const
+                {
+                    return empty_reduction_variable();
+                }
+
+                template <class BR, class E>
+                auto merge(const BR& block_result, bool first, E& result, empty_reduction_variable&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+
+                template <class E, class R>
+                void finalize(const empty_reduction_variable&, E& results, const R&) const
+                {
+                    xt::noalias(results) = xt::sqrt(results);
+                }
+            };
+
+            template <class T_E>
+            struct norm_sq_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::norm_sq(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(xt::square(input), axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+            };
+
+            template <class T_E>
+            struct norm_linf_functor : public simple_functor_base
+            {
+                using value_type = typename std::decay_t<decltype(xt::norm_linf(std::declval<xarray<T_E>>()))>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::amax<value_type>(xt::abs(input), axes, options);
+                }
+
+                template <class BR, class E, class MR>
+                auto merge(const BR& block_result, bool first, E& result, MR&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) = xt::maximum(block_result, result);
+                    }
+                }
+            };
+
+            template <class T_E>
+            class norm_lp_to_p_functor
+            {
+            public:
+
+                using value_type = typename std::decay_t<
+                    decltype(xt::norm_lp_to_p(std::declval<xarray<T_E>>(), 1.0))>::value_type;
+
+                norm_lp_to_p_functor(double p)
+                    : m_p(p)
+                {
+                }
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(xt::pow(input, m_p), axes, options);
+                }
+
+                template <class E>
+                auto reduction_variable(const E&) const
+                {
+                    return empty_reduction_variable();
+                }
+
+                template <class BR, class E>
+                auto merge(const BR& block_result, bool first, E& result, empty_reduction_variable&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+
+                template <class E, class R>
+                void finalize(const empty_reduction_variable&, E&, const R&) const
+                {
+                }
+
+            private:
+
+                double m_p;
+            };
+
+            template <class T_E>
+            class norm_lp_functor
+            {
+            public:
+
+                norm_lp_functor(double p)
+                    : m_p(p)
+                {
+                }
+
+                using value_type = typename std::decay_t<decltype(xt::norm_lp(std::declval<xarray<T_E>>(), 1.0)
+                )>::value_type;
+
+                template <class E, class A, class O>
+                auto compute(const E& input, const A& axes, const O& options) const
+                {
+                    return xt::sum<value_type>(xt::pow(input, m_p), axes, options);
+                }
+
+                template <class E>
+                auto reduction_variable(const E&) const
+                {
+                    return empty_reduction_variable();
+                }
+
+                template <class BR, class E>
+                auto merge(const BR& block_result, bool first, E& result, empty_reduction_variable&) const
+                {
+                    if (first)
+                    {
+                        xt::noalias(result) = block_result;
+                    }
+                    else
+                    {
+                        xt::noalias(result) += block_result;
+                    }
+                }
+
+                template <class E, class R>
+                void finalize(const empty_reduction_variable&, E& results, const R&) const
+                {
+                    results = xt::pow(results, 1.0 / m_p);
+                }
+
+            private:
+
+                double m_p;
+            };
+
+
+        }
+    }
+}
+
+#endif
diff --git a/include/xtensor/reducers/xnorm.hpp b/include/xtensor/reducers/xnorm.hpp
new file mode 100644
index 000000000..b883573f6
--- /dev/null
+++ b/include/xtensor/reducers/xnorm.hpp
@@ -0,0 +1,661 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
+ * Copyright (c) Ullrich Koethe
+ * 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_NORM_HPP
+#define XTENSOR_NORM_HPP
+
+#include <cmath>
+// std::abs(int) prior to C++ 17
+#include <complex>
+#include <cstdlib>
+
+#include <xtl/xtype_traits.hpp>
+
+#include "../core/xmath.hpp"
+#include "../core/xoperation.hpp"
+#include "../utils/xutils.hpp"
+
+namespace xt
+{
+    /********************************************
+     * type inference for norm and squared norm *
+     ********************************************/
+
+    template <class T>
+    struct norm_type;
+
+    template <class T>
+    struct squared_norm_type;
+
+    namespace traits_detail
+    {
+
+        template <class T, bool scalar = xtl::is_arithmetic<T>::value>
+        struct norm_of_scalar_impl;
+
+        template <class T>
+        struct norm_of_scalar_impl<T, false>
+        {
+            static const bool value = false;
+            using norm_type = void*;
+            using squared_norm_type = void*;
+        };
+
+        template <class T>
+        struct norm_of_scalar_impl<T, true>
+        {
+            static const bool value = true;
+            using norm_type = xtl::promote_type_t<T>;
+            using squared_norm_type = xtl::promote_type_t<T>;
+        };
+
+        template <class T, bool integral = xtl::is_integral<T>::value, bool floating = std::is_floating_point<T>::value>
+        struct norm_of_array_elements_impl;
+
+        template <>
+        struct norm_of_array_elements_impl<void*, false, false>
+        {
+            using norm_type = void*;
+            using squared_norm_type = void*;
+        };
+
+        template <class T>
+        struct norm_of_array_elements_impl<T, false, false>
+        {
+            using norm_type = typename norm_type<T>::type;
+            using squared_norm_type = typename squared_norm_type<T>::type;
+        };
+
+        template <class T>
+        struct norm_of_array_elements_impl<T, true, false>
+        {
+            static_assert(
+                !std::is_same<T, char>::value,
+                "'char' is not a numeric type, use 'signed char' or 'unsigned char'."
+            );
+
+            using norm_type = double;
+            using squared_norm_type = uint64_t;
+        };
+
+        template <class T>
+        struct norm_of_array_elements_impl<T, false, true>
+        {
+            using norm_type = double;
+            using squared_norm_type = double;
+        };
+
+        template <>
+        struct norm_of_array_elements_impl<long double, false, true>
+        {
+            using norm_type = long double;
+            using squared_norm_type = long double;
+        };
+
+        template <class ARRAY>
+        struct norm_of_vector_impl
+        {
+            static void* test(...);
+
+            template <class U>
+            static typename U::value_type test(U*, typename U::value_type* = 0);
+
+            using T = decltype(test(std::declval<ARRAY*>()));
+
+            static const bool value = !std::is_same<T, void*>::value;
+
+            using norm_type = typename norm_of_array_elements_impl<T>::norm_type;
+            using squared_norm_type = typename norm_of_array_elements_impl<T>::squared_norm_type;
+        };
+
+        template <class U>
+        struct norm_type_base
+        {
+            using T = std::decay_t<U>;
+
+            static_assert(
+                !std::is_same<T, char>::value,
+                "'char' is not a numeric type, use 'signed char' or 'unsigned char'."
+            );
+
+            using norm_of_scalar = norm_of_scalar_impl<T>;
+            using norm_of_vector = norm_of_vector_impl<T>;
+
+            static const bool value = norm_of_scalar::value || norm_of_vector::value;
+
+            static_assert(value, "norm_type<T> are undefined for type U.");
+        };
+    }  // namespace traits_detail
+
+    /**
+     * @brief Traits class for the result type of the <tt>norm_l2()</tt> function.
+     *
+     * Member 'type' defines the result of <tt>norm_l2(t)</tt>, where <tt>t</tt>
+     * is of type @tparam T. It implements the following rules designed to
+     * minimize the potential for overflow:
+     *   - @tparam T is an arithmetic type: 'type' is the result type of <tt>abs(t)</tt>.
+     *   - @tparam T is a container of 'long double' elements: 'type' is <tt>long double</tt>.
+     *   - @tparam T is a container of another arithmetic type: 'type' is <tt>double</tt>.
+     *   - @tparam T is a container of some other type: 'type' is the element's norm type,
+     *
+     * Containers are recognized by having an embedded typedef 'value_type'.
+     * To change the behavior for a case not covered here, specialize the
+     * <tt>traits_detail::norm_type_base</tt> template.
+     */
+    template <class T>
+    struct norm_type : traits_detail::norm_type_base<T>
+    {
+        using base_type = traits_detail::norm_type_base<T>;
+
+        using type = typename std::conditional<
+            base_type::norm_of_vector::value,
+            typename base_type::norm_of_vector::norm_type,
+            typename base_type::norm_of_scalar::norm_type>::type;
+    };
+
+    /**
+     * Abbreviation of 'typename norm_type<T>::type'.
+     */
+    template <class T>
+    using norm_type_t = typename norm_type<T>::type;
+
+    /**
+     * @brief Traits class for the result type of the <tt>norm_sq()</tt> function.
+     *
+     * Member 'type' defines the result of <tt>norm_sq(t)</tt>, where <tt>t</tt>
+     * is of type @tparam T. It implements the following rules designed to
+     * minimize the potential for overflow:
+     *   - @tparam T is an arithmetic type: 'type' is the result type of <tt>t*t</tt>.
+     *   - @tparam T is a container of 'long double' elements: 'type' is <tt>long double</tt>.
+     *   - @tparam T is a container of another floating-point type: 'type' is <tt>double</tt>.
+     *   - @tparam T is a container of integer elements: 'type' is <tt>uint64_t</tt>.
+     *   - @tparam T is a container of some other type: 'type' is the element's squared norm type,
+     *
+     *  Containers are recognized by having an embedded typedef 'value_type'.
+     *  To change the behavior for a case not covered here, specialize the
+     *  <tt>traits_detail::norm_type_base</tt> template.
+     */
+    template <class T>
+    struct squared_norm_type : traits_detail::norm_type_base<T>
+    {
+        using base_type = traits_detail::norm_type_base<T>;
+
+        using type = typename std::conditional<
+            base_type::norm_of_vector::value,
+            typename base_type::norm_of_vector::squared_norm_type,
+            typename base_type::norm_of_scalar::squared_norm_type>::type;
+    };
+
+    /**
+     * Abbreviation of 'typename squared_norm_type<T>::type'.
+     */
+    template <class T>
+    using squared_norm_type_t = typename squared_norm_type<T>::type;
+
+    /*************************************
+     * norm functions for built-in types *
+     *************************************/
+
+///@cond DOXYGEN_INCLUDE_SFINAE
+#define XTENSOR_DEFINE_SIGNED_NORMS(T)                                                \
+    inline auto norm_lp(T t, double p) noexcept                                       \
+    {                                                                                 \
+        using rt = decltype(std::abs(t));                                             \
+        return p == 0.0 ? static_cast<rt>(t != 0) : std::abs(t);                      \
+    }                                                                                 \
+    inline auto norm_lp_to_p(T t, double p) noexcept                                  \
+    {                                                                                 \
+        using rt = xtl::real_promote_type_t<T>;                                       \
+        return p == 0.0 ? static_cast<rt>(t != 0)                                     \
+                        : std::pow(static_cast<rt>(std::abs(t)), static_cast<rt>(p)); \
+    }                                                                                 \
+    inline std::size_t norm_l0(T t) noexcept                                          \
+    {                                                                                 \
+        return (t != 0);                                                              \
+    }                                                                                 \
+    inline auto norm_l1(T t) noexcept                                                 \
+    {                                                                                 \
+        return std::abs(t);                                                           \
+    }                                                                                 \
+    inline auto norm_l2(T t) noexcept                                                 \
+    {                                                                                 \
+        return std::abs(t);                                                           \
+    }                                                                                 \
+    inline auto norm_linf(T t) noexcept                                               \
+    {                                                                                 \
+        return std::abs(t);                                                           \
+    }                                                                                 \
+    inline auto norm_sq(T t) noexcept                                                 \
+    {                                                                                 \
+        return t * t;                                                                 \
+    }
+
+    XTENSOR_DEFINE_SIGNED_NORMS(signed char)
+    XTENSOR_DEFINE_SIGNED_NORMS(short)
+    XTENSOR_DEFINE_SIGNED_NORMS(int)
+    XTENSOR_DEFINE_SIGNED_NORMS(long)
+    XTENSOR_DEFINE_SIGNED_NORMS(long long)
+    XTENSOR_DEFINE_SIGNED_NORMS(float)
+    XTENSOR_DEFINE_SIGNED_NORMS(double)
+    XTENSOR_DEFINE_SIGNED_NORMS(long double)
+
+#undef XTENSOR_DEFINE_SIGNED_NORMS
+
+#define XTENSOR_DEFINE_UNSIGNED_NORMS(T)                                                              \
+    inline T norm_lp(T t, double p) noexcept                                                          \
+    {                                                                                                 \
+        return p == 0.0 ? (t != 0) : t;                                                               \
+    }                                                                                                 \
+    inline auto norm_lp_to_p(T t, double p) noexcept                                                  \
+    {                                                                                                 \
+        using rt = xtl::real_promote_type_t<T>;                                                       \
+        return p == 0.0 ? static_cast<rt>(t != 0) : std::pow(static_cast<rt>(t), static_cast<rt>(p)); \
+    }                                                                                                 \
+    inline T norm_l0(T t) noexcept                                                                    \
+    {                                                                                                 \
+        return t != 0 ? 1 : 0;                                                                        \
+    }                                                                                                 \
+    inline T norm_l1(T t) noexcept                                                                    \
+    {                                                                                                 \
+        return t;                                                                                     \
+    }                                                                                                 \
+    inline T norm_l2(T t) noexcept                                                                    \
+    {                                                                                                 \
+        return t;                                                                                     \
+    }                                                                                                 \
+    inline T norm_linf(T t) noexcept                                                                  \
+    {                                                                                                 \
+        return t;                                                                                     \
+    }                                                                                                 \
+    inline auto norm_sq(T t) noexcept                                                                 \
+    {                                                                                                 \
+        return t * t;                                                                                 \
+    }
+
+    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned char)
+    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned short)
+    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned int)
+    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned long)
+    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned long long)
+
+#undef XTENSOR_DEFINE_UNSIGNED_NORMS
+
+    /***********************************
+     * norm functions for std::complex *
+     ***********************************/
+
+    /**
+     * @brief L0 pseudo-norm of a complex number.
+     * Equivalent to <tt>t != 0</tt>.
+     */
+    template <class T>
+    inline uint64_t norm_l0(const std::complex<T>& t) noexcept
+    {
+        return t.real() != 0 || t.imag() != 0;
+    }
+
+    /**
+     * @brief L1 norm of a complex number.
+     */
+    template <class T>
+    inline auto norm_l1(const std::complex<T>& t) noexcept
+    {
+        return std::abs(t.real()) + std::abs(t.imag());
+    }
+
+    /**
+     * @brief L2 norm of a complex number.
+     * Equivalent to <tt>std::abs(t)</tt>.
+     */
+    template <class T>
+    inline auto norm_l2(const std::complex<T>& t) noexcept
+    {
+        return std::abs(t);
+    }
+
+    /**
+     * @brief Squared norm of a complex number.
+     * Equivalent to <tt>std::norm(t)</tt> (yes, the C++ standard really defines
+     * <tt>norm()</tt> to compute the squared norm).
+     */
+    template <class T>
+    inline auto norm_sq(const std::complex<T>& t) noexcept
+    {
+        // Does not use std::norm since it returns a std::complex on OSX
+        return t.real() * t.real() + t.imag() * t.imag();
+    }
+
+    /**
+     * @brief L-infinity norm of a complex number.
+     */
+    template <class T>
+    inline auto norm_linf(const std::complex<T>& t) noexcept
+    {
+        return (std::max)(std::abs(t.real()), std::abs(t.imag()));
+    }
+
+    /**
+     * @brief p-th power of the Lp norm of a complex number.
+     */
+    template <class T>
+    inline auto norm_lp_to_p(const std::complex<T>& t, double p) noexcept
+    {
+        using rt = decltype(std::pow(std::abs(t.real()), static_cast<T>(p)));
+        return p == 0 ? static_cast<rt>(t.real() != 0 || t.imag() != 0)
+                      : std::pow(std::abs(t.real()), static_cast<T>(p))
+                            + std::pow(std::abs(t.imag()), static_cast<T>(p));
+    }
+
+    /**
+     * @brief Lp norm of a complex number.
+     */
+    template <class T>
+    inline auto norm_lp(const std::complex<T>& t, double p) noexcept
+    {
+        return p == 0 ? norm_lp_to_p(t, p) : std::pow(norm_lp_to_p(t, p), 1.0 / p);
+    }
+
+    /***********************************
+     * norm functions for xexpressions *
+     ***********************************/
+
+#define XTENSOR_NORM_FUNCTION_AXES(NAME)                                                             \
+    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>                \
+    inline auto NAME(E&& e, const I(&axes)[N], EVS es = EVS()) noexcept                              \
+    {                                                                                                \
+        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;                        \
+        return NAME(std::forward<E>(e), xtl::forward_sequence<axes_type, decltype(axes)>(axes), es); \
+    }
+
+    namespace detail
+    {
+        template <class T>
+        struct norm_value_type
+        {
+            using type = T;
+        };
+
+        template <class T>
+        struct norm_value_type<std::complex<T>>
+        {
+            using type = T;
+        };
+
+        template <class T>
+        using norm_value_type_t = typename norm_value_type<T>::type;
+    }
+
+#define XTENSOR_EMPTY
+#define XTENSOR_COMMA ,
+#define XTENSOR_NORM_FUNCTION(NAME, RESULT_TYPE, REDUCE_EXPR, REDUCE_OP, MERGE_FUNC)                                       \
+    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)> \
+    inline auto NAME(E&& e, X&& axes, EVS es = EVS()) noexcept                                                             \
+    {                                                                                                                      \
+        using value_type = typename std::decay_t<E>::value_type;                                                           \
+        using result_type = detail::norm_value_type_t<RESULT_TYPE>;                                                        \
+                                                                                                                           \
+        auto reduce_func = [](result_type const& r, value_type const& v)                                                   \
+        {                                                                                                                  \
+            return REDUCE_EXPR(r REDUCE_OP NAME(v));                                                                       \
+        };                                                                                                                 \
+                                                                                                                           \
+        return xt::reduce(                                                                                                 \
+            make_xreducer_functor(std::move(reduce_func), const_value<result_type>(0), MERGE_FUNC<result_type>()),         \
+            std::forward<E>(e),                                                                                            \
+            std::forward<X>(axes),                                                                                         \
+            es                                                                                                             \
+        );                                                                                                                 \
+    }                                                                                                                      \
+                                                                                                                           \
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>                             \
+    inline auto NAME(E&& e, EVS es = EVS()) noexcept                                                                       \
+    {                                                                                                                      \
+        return NAME(std::forward<E>(e), arange(e.dimension()), es);                                                        \
+    }                                                                                                                      \
+    XTENSOR_NORM_FUNCTION_AXES(NAME)
+
+    XTENSOR_NORM_FUNCTION(norm_l0, unsigned long long, XTENSOR_EMPTY, +, std::plus)
+    XTENSOR_NORM_FUNCTION(norm_l1, xtl::big_promote_type_t<value_type>, XTENSOR_EMPTY, +, std::plus)
+    XTENSOR_NORM_FUNCTION(norm_sq, xtl::big_promote_type_t<value_type>, XTENSOR_EMPTY, +, std::plus)
+    XTENSOR_NORM_FUNCTION(
+        norm_linf,
+        decltype(norm_linf(std::declval<value_type>())),
+        (std::max<result_type>),
+        XTENSOR_COMMA,
+        math::maximum
+    )
+
+#undef XTENSOR_EMPTY
+#undef XTENSOR_COMMA
+#undef XTENSOR_NORM_FUNCTION
+#undef XTENSOR_NORM_FUNCTION_AXES
+    /// @endcond
+    /**
+     * @ingroup red_functions
+     * @brief L0 (count) pseudo-norm of an array-like argument over given axes.
+     *
+     * Returns an \ref xreducer for the L0 pseudo-norm of the elements across given \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the norm is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     * When no axes are provided, the norm is calculated over the entire array. In this case,
+     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
+     */
+    template <class E, class X, class EVS, class>
+    auto norm_l0(E&& e, X&& axes, EVS es) noexcept;
+
+    /**
+     * @ingroup red_functions
+     * @brief L1 norm of an array-like argument over given axes.
+     *
+     * Returns an \ref xreducer for the L1 norm of the elements across given \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the norm is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     * When no axes are provided, the norm is calculated over the entire array. In this case,
+     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
+     */
+    template <class E, class X, class EVS, class>
+    auto norm_l1(E&& e, X&& axes, EVS es) noexcept;
+
+    /**
+     * @ingroup red_functions
+     * @brief Squared L2 norm of an array-like argument over given axes.
+     *
+     * Returns an \ref xreducer for the squared L2 norm of the elements across given \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the norm is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     * When no axes are provided, the norm is calculated over the entire array. In this case,
+     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
+     */
+    template <class E, class X, class EVS, class>
+    auto norm_sq(E&& e, X&& axes, EVS es) noexcept;
+
+    /**
+     * @ingroup red_functions
+     * @brief L2 norm of a scalar or array-like argument.
+     * @param e an xexpression
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     *  For scalar types: implemented as <tt>abs(t)</tt><br>
+     *  otherwise: implemented as <tt>sqrt(norm_sq(t))</tt>.
+     */
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>
+    inline auto norm_l2(E&& e, EVS es = EVS()) noexcept
+    {
+        using std::sqrt;
+        return sqrt(norm_sq(std::forward<E>(e), es));
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief L2 norm of an array-like argument over given axes.
+     *
+     * Returns an \ref xreducer for the L2 norm of the elements across given \em axes.
+     * @param e an \ref xexpression
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @param axes the axes along which the norm is computed
+     * @return an \ref xreducer (specifically: <tt>sqrt(norm_sq(e, axes))</tt>) (or xcontainer, depending on
+     * evaluation strategy)
+     */
+    template <
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(is_xexpression<E>, std::negation<is_reducer_options<X>>)>
+    inline auto norm_l2(E&& e, X&& axes, EVS es = EVS()) noexcept
+    {
+        return sqrt(norm_sq(std::forward<E>(e), std::forward<X>(axes), es));
+    }
+
+    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto norm_l2(E&& e, const I (&axes)[N], EVS es = EVS()) noexcept
+    {
+        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
+        return sqrt(norm_sq(std::forward<E>(e), xtl::forward_sequence<axes_type, decltype(axes)>(axes), es));
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Infinity (maximum) norm of an array-like argument over given axes.
+     *
+     * Returns an \ref xreducer for the infinity norm of the elements across given \em axes.
+     * @param e an \ref xexpression
+     * @param axes the axes along which the norm is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     * When no axes are provided, the norm is calculated over the entire array. In this case,
+     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
+     */
+    template <class E, class X, class EVS, class>
+    auto norm_linf(E&& e, X&& axes, EVS es) noexcept;
+
+    /**
+     * @ingroup red_functions
+     * @brief p-th power of the Lp norm of an array-like argument over given axes.
+     *
+     * Returns an \ref xreducer for the p-th power of the Lp norm of the elements across given \em axes.
+     * @param e an \ref xexpression
+     * @param p
+     * @param axes the axes along which the norm is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     * When no axes are provided, the norm is calculated over the entire array. In this case,
+     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
+     */
+    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
+    inline auto norm_lp_to_p(E&& e, double p, X&& axes, EVS es = EVS()) noexcept
+    {
+        using value_type = typename std::decay_t<E>::value_type;
+        using result_type = norm_type_t<std::decay_t<E>>;
+
+        auto reduce_func = [p](const result_type& r, const value_type& v)
+        {
+            return r + norm_lp_to_p(v, p);
+        };
+        return xt::reduce(
+            make_xreducer_functor(std::move(reduce_func), xt::const_value<result_type>(0), std::plus<result_type>()),
+            std::forward<E>(e),
+            std::forward<X>(axes),
+            es
+        );
+    }
+
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>
+    inline auto norm_lp_to_p(E&& e, double p, EVS es = EVS()) noexcept
+    {
+        return norm_lp_to_p(std::forward<E>(e), p, arange(e.dimension()), es);
+    }
+
+    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto norm_lp_to_p(E&& e, double p, const I (&axes)[N], EVS es = EVS()) noexcept
+    {
+        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
+        return norm_lp_to_p(std::forward<E>(e), p, xtl::forward_sequence<axes_type, decltype(axes)>(axes), es);
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Lp norm of an array-like argument over given axes.
+     *
+     * Returns an \ref xreducer for the Lp norm (p != 0) of the elements across given \em axes.
+     * @param e an \ref xexpression
+     * @param p
+     * @param axes the axes along which the norm is computed (optional)
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     * When no axes are provided, the norm is calculated over the entire array. In this case,
+     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
+     */
+    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
+    inline auto norm_lp(E&& e, double p, X&& axes, EVS es = EVS())
+    {
+        XTENSOR_PRECONDITION(p != 0, "norm_lp(): p must be nonzero, use norm_l0() instead.");
+        return pow(norm_lp_to_p(std::forward<E>(e), p, std::forward<X>(axes), es), 1.0 / p);
+    }
+
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>
+    inline auto norm_lp(E&& e, double p, EVS es = EVS())
+    {
+        return norm_lp(std::forward<E>(e), p, arange(e.dimension()), es);
+    }
+
+    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
+    inline auto norm_lp(E&& e, double p, const I (&axes)[N], EVS es = EVS())
+    {
+        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
+        return norm_lp(std::forward<E>(e), p, xtl::forward_sequence<axes_type, decltype(axes)>(axes), es);
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Induced L1 norm of a matrix.
+     *
+     * Returns an \ref xreducer for the induced L1 norm (i.e. the maximum of the L1 norms of e's columns).
+     * @param e a 2D \ref xexpression
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     */
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>
+    inline auto norm_induced_l1(E&& e, EVS es = EVS())
+    {
+        XTENSOR_PRECONDITION(
+            e.dimension() == 2,
+            "norm_induced_l1(): only applicable to matrices (e.dimension() must be 2)."
+        );
+        return norm_linf(norm_l1(std::forward<E>(e), {0}, es), es);
+    }
+
+    /**
+     * @ingroup red_functions
+     * @brief Induced L-infinity norm of a matrix.
+     *
+     * Returns an \ref xreducer for the induced L-infinity norm (i.e. the maximum of the L1 norms of e's
+     * rows).
+     * @param e a 2D \ref xexpression
+     * @param es evaluation strategy to use (lazy (default), or immediate)
+     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
+     */
+    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>
+    inline auto norm_induced_linf(E&& e, EVS es = EVS())
+    {
+        XTENSOR_PRECONDITION(
+            e.dimension() == 2,
+            "norm_induced_linf(): only applicable to matrices (e.dimension() must be 2)."
+        );
+        return norm_linf(norm_l1(std::forward<E>(e), {1}, es), es);
+    }
+
+}  // namespace xt
+
+#endif
diff --git a/include/xtensor/reducers/xreducer.hpp b/include/xtensor/reducers/xreducer.hpp
new file mode 100644
index 000000000..e99522b5e
--- /dev/null
+++ b/include/xtensor/reducers/xreducer.hpp
@@ -0,0 +1,1895 @@
+/***************************************************************************
+ * 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_REDUCER_HPP
+#define XTENSOR_REDUCER_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <xtl/xfunctional.hpp>
+#include <xtl/xsequence.hpp>
+
+#include "../core/xaccessible.hpp"
+#include "../core/xeval.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../generators/xbuilder.hpp"
+#include "../generators/xgenerator.hpp"
+#include "../utils/xutils.hpp"
+
+namespace xt
+{
+    template <template <class...> class A, class... AX, class X, XTL_REQUIRES(is_evaluation_strategy<AX>..., is_evaluation_strategy<X>)>
+    auto operator|(const A<AX...>& args, const A<X>& rhs)
+    {
+        return std::tuple_cat(args, rhs);
+    }
+
+    struct keep_dims_type : xt::detail::option_base
+    {
+    };
+
+    constexpr auto keep_dims = std::tuple<keep_dims_type>{};
+
+    template <class T = double>
+    struct xinitial : xt::detail::option_base
+    {
+        constexpr xinitial(T val)
+            : m_val(val)
+        {
+        }
+
+        constexpr T value() const
+        {
+            return m_val;
+        }
+
+        T m_val;
+    };
+
+    template <class T>
+    constexpr auto initial(T val)
+    {
+        return std::make_tuple(xinitial<T>(val));
+    }
+
+    template <std::ptrdiff_t I, class T, class Tuple>
+    struct tuple_idx_of_impl;
+
+    template <std::ptrdiff_t I, class T>
+    struct tuple_idx_of_impl<I, T, std::tuple<>>
+    {
+        static constexpr std::ptrdiff_t value = -1;
+    };
+
+    template <std::ptrdiff_t I, class T, class... Types>
+    struct tuple_idx_of_impl<I, T, std::tuple<T, Types...>>
+    {
+        static constexpr std::ptrdiff_t value = I;
+    };
+
+    template <std::ptrdiff_t I, class T, class U, class... Types>
+    struct tuple_idx_of_impl<I, T, std::tuple<U, Types...>>
+    {
+        static constexpr std::ptrdiff_t value = tuple_idx_of_impl<I + 1, T, std::tuple<Types...>>::value;
+    };
+
+    template <class S, class... X>
+    struct decay_all;
+
+    template <template <class...> class S, class... X>
+    struct decay_all<S<X...>>
+    {
+        using type = S<std::decay_t<X>...>;
+    };
+
+    template <class T, class Tuple>
+    struct tuple_idx_of
+    {
+        static constexpr std::ptrdiff_t
+            value = tuple_idx_of_impl<0, std::decay_t<T>, typename decay_all<Tuple>::type>::value;
+    };
+
+    template <class R, class T>
+    struct reducer_options
+    {
+        template <class X>
+        struct initial_tester : std::false_type
+        {
+        };
+
+        template <class X>
+        struct initial_tester<xinitial<X>> : std::true_type
+        {
+        };
+
+        // Workaround for Apple because tuple_cat is buggy!
+        template <class X>
+        struct initial_tester<const xinitial<X>> : std::true_type
+        {
+        };
+
+        using d_t = std::decay_t<T>;
+
+        static constexpr std::size_t initial_val_idx = xtl::mpl::find_if<initial_tester, d_t>::value;
+        reducer_options() = default;
+
+        reducer_options(const T& tpl)
+        {
+            if constexpr (initial_val_idx != std::tuple_size<T>::value)
+            {
+                initial_value = std::get < initial_val_idx != std::tuple_size<T>::value ? initial_val_idx
+                                                                                        : 0 > (tpl).value();
+            }
+        }
+
+        using evaluation_strategy = std::conditional_t<
+            tuple_idx_of<xt::evaluation_strategy::immediate_type, d_t>::value != -1,
+            xt::evaluation_strategy::immediate_type,
+            xt::evaluation_strategy::lazy_type>;
+
+        using keep_dims = std::
+            conditional_t<tuple_idx_of<xt::keep_dims_type, d_t>::value != -1, std::true_type, std::false_type>;
+
+        static constexpr bool has_initial_value = initial_val_idx != std::tuple_size<d_t>::value;
+
+        R initial_value;
+
+        template <class NR>
+        using rebind_t = reducer_options<NR, T>;
+
+        template <class NR>
+        auto rebind(NR initial, const reducer_options<R, T>&) const
+        {
+            reducer_options<NR, T> res;
+            res.initial_value = initial;
+            return res;
+        }
+    };
+
+    template <class T>
+    struct is_reducer_options_impl : std::false_type
+    {
+    };
+
+    template <class... X>
+    struct is_reducer_options_impl<std::tuple<X...>> : std::true_type
+    {
+    };
+
+    template <class T>
+    struct is_reducer_options : is_reducer_options_impl<std::decay_t<T>>
+    {
+    };
+
+    /**********
+     * reduce *
+     **********/
+
+#define DEFAULT_STRATEGY_REDUCERS std::tuple<evaluation_strategy::lazy_type>
+
+    template <class ST, class X, class KD = std::false_type>
+    struct xreducer_shape_type;
+
+    template <class S1, class S2>
+    struct fixed_xreducer_shape_type;
+
+    namespace detail
+    {
+        template <class O, class RS, class R, class E, class AX>
+        inline void shape_computation(
+            RS& result_shape,
+            R& result,
+            E& expr,
+            const AX& axes,
+            std::enable_if_t<!detail::is_fixed<RS>::value, int> = 0
+        )
+        {
+            if (typename O::keep_dims())
+            {
+                resize_container(result_shape, expr.dimension());
+                for (std::size_t i = 0; i < expr.dimension(); ++i)
+                {
+                    if (std::find(axes.begin(), axes.end(), i) == axes.end())
+                    {
+                        // i not in axes!
+                        result_shape[i] = expr.shape()[i];
+                    }
+                    else
+                    {
+                        result_shape[i] = 1;
+                    }
+                }
+            }
+            else
+            {
+                resize_container(result_shape, expr.dimension() - axes.size());
+                for (std::size_t i = 0, idx = 0; i < expr.dimension(); ++i)
+                {
+                    if (std::find(axes.begin(), axes.end(), i) == axes.end())
+                    {
+                        // i not in axes!
+                        result_shape[idx] = expr.shape()[i];
+                        ++idx;
+                    }
+                }
+            }
+            result.resize(result_shape, expr.layout());
+        }
+
+        // skip shape computation if already done at compile time
+        template <class O, class RS, class R, class S, class AX>
+        inline void
+        shape_computation(RS&, R&, const S&, const AX&, std::enable_if_t<detail::is_fixed<RS>::value, int> = 0)
+        {
+        }
+    }
+
+    template <class F, class E, class R, XTL_REQUIRES(std::is_convertible<typename E::value_type, typename R::value_type>)>
+    inline void copy_to_reduced(F&, const E& e, R& result)
+    {
+        if (e.layout() == layout_type::row_major)
+        {
+            std::copy(
+                e.template cbegin<layout_type::row_major>(),
+                e.template cend<layout_type::row_major>(),
+                result.data()
+            );
+        }
+        else
+        {
+            std::copy(
+                e.template cbegin<layout_type::column_major>(),
+                e.template cend<layout_type::column_major>(),
+                result.data()
+            );
+        }
+    }
+
+    template <
+        class F,
+        class E,
+        class R,
+        XTL_REQUIRES(std::negation<std::is_convertible<typename E::value_type, typename R::value_type>>)>
+    inline void copy_to_reduced(F& f, const E& e, R& result)
+    {
+        if (e.layout() == layout_type::row_major)
+        {
+            std::transform(
+                e.template cbegin<layout_type::row_major>(),
+                e.template cend<layout_type::row_major>(),
+                result.data(),
+                f
+            );
+        }
+        else
+        {
+            std::transform(
+                e.template cbegin<layout_type::column_major>(),
+                e.template cend<layout_type::column_major>(),
+                result.data(),
+                f
+            );
+        }
+    }
+
+    template <class F, class E, class X, class O>
+    inline auto reduce_immediate(F&& f, E&& e, X&& axes, O&& raw_options)
+    {
+        using reduce_functor_type = typename std::decay_t<F>::reduce_functor_type;
+        using init_functor_type = typename std::decay_t<F>::init_functor_type;
+        using expr_value_type = typename std::decay_t<E>::value_type;
+        using result_type = std::decay_t<decltype(std::declval<reduce_functor_type>()(
+            std::declval<init_functor_type>()(),
+            std::declval<expr_value_type>()
+        ))>;
+
+        using options_t = reducer_options<result_type, std::decay_t<O>>;
+        options_t options(raw_options);
+
+        using shape_type = typename xreducer_shape_type<
+            typename std::decay_t<E>::shape_type,
+            std::decay_t<X>,
+            typename options_t::keep_dims>::type;
+        using result_container_type = typename detail::xtype_for_shape<
+            shape_type>::template type<result_type, std::decay_t<E>::static_layout>;
+        result_container_type result;
+
+        // retrieve functors from triple struct
+        auto reduce_fct = xt::get<0>(f);
+        auto init_fct = xt::get<1>(f);
+        auto merge_fct = xt::get<2>(f);
+
+        if (axes.size() == 0)
+        {
+            result.resize(e.shape(), e.layout());
+            auto cpf = [&reduce_fct, &init_fct](const auto& v)
+            {
+                return reduce_fct(static_cast<result_type>(init_fct()), v);
+            };
+            copy_to_reduced(cpf, e, result);
+            return result;
+        }
+
+        shape_type result_shape{};
+        dynamic_shape<std::size_t>
+            iter_shape = xtl::forward_sequence<dynamic_shape<std::size_t>, decltype(e.shape())>(e.shape());
+        dynamic_shape<std::size_t> iter_strides(e.dimension());
+
+        // std::less is used, because as the standard says (24.4.5):
+        // A sequence is sorted with respect to a comparator comp if for any iterator i pointing to the
+        // sequence and any non-negative integer n such that i + n is a valid iterator pointing to an element
+        // of the sequence, comp(*(i + n), *i) == false. Therefore less is required to detect duplicates.
+        if (!std::is_sorted(axes.cbegin(), axes.cend(), std::less<>()))
+        {
+            XTENSOR_THROW(std::runtime_error, "Reducing axes should be sorted.");
+        }
+        if (std::adjacent_find(axes.cbegin(), axes.cend()) != axes.cend())
+        {
+            XTENSOR_THROW(std::runtime_error, "Reducing axes should not contain duplicates.");
+        }
+        if (axes.size() != 0 && axes[axes.size() - 1] > e.dimension() - 1)
+        {
+            XTENSOR_THROW(
+                std::runtime_error,
+                "Axis " + std::to_string(axes[axes.size() - 1]) + " out of bounds for reduction."
+            );
+        }
+
+        detail::shape_computation<options_t>(result_shape, result, e, axes);
+
+        // Fast track for complete reduction
+        if (e.dimension() == axes.size())
+        {
+            result_type tmp = options_t::has_initial_value ? options.initial_value : init_fct();
+            result.data()[0] = std::accumulate(e.storage().begin(), e.storage().end(), tmp, reduce_fct);
+            return result;
+        }
+
+        std::size_t leading_ax = axes[(e.layout() == layout_type::row_major) ? axes.size() - 1 : 0];
+        auto strides_finder = e.strides().begin() + static_cast<std::ptrdiff_t>(leading_ax);
+        // The computed strides contain "0" where the shape is 1 -- therefore find the next none-zero number
+        std::size_t inner_stride = static_cast<std::size_t>(*strides_finder);
+        auto iter_bound = e.layout() == layout_type::row_major ? e.strides().begin() : (e.strides().end() - 1);
+        while (inner_stride == 0 && strides_finder != iter_bound)
+        {
+            (e.layout() == layout_type::row_major) ? --strides_finder : ++strides_finder;
+            inner_stride = static_cast<std::size_t>(*strides_finder);
+        }
+
+        if (inner_stride == 0)
+        {
+            auto cpf = [&reduce_fct, &init_fct](const auto& v)
+            {
+                return reduce_fct(static_cast<result_type>(init_fct()), v);
+            };
+            copy_to_reduced(cpf, e, result);
+            return result;
+        }
+
+        std::size_t inner_loop_size = static_cast<std::size_t>(inner_stride);
+        std::size_t outer_loop_size = e.shape()[leading_ax];
+
+        // The following code merges reduction axes "at the end" (or the beginning for col_major)
+        // together by increasing the size of the outer loop where appropriate
+        auto merge_loops = [&outer_loop_size, &e](auto it, auto end)
+        {
+            auto last_ax = *it;
+            ++it;
+            for (; it != end; ++it)
+            {
+                // note that we check is_sorted, so this condition is valid
+                if (std::abs(std::ptrdiff_t(*it) - std::ptrdiff_t(last_ax)) == 1)
+                {
+                    last_ax = *it;
+                    outer_loop_size *= e.shape()[last_ax];
+                }
+            }
+            return last_ax;
+        };
+
+        for (std::size_t i = 0, idx = 0; i < e.dimension(); ++i)
+        {
+            if (std::find(axes.begin(), axes.end(), i) == axes.end())
+            {
+                // i not in axes!
+                iter_strides[i] = static_cast<std::size_t>(result.strides(
+                )[typename options_t::keep_dims() ? i : idx]);
+                ++idx;
+            }
+        }
+
+        if (e.layout() == layout_type::row_major)
+        {
+            std::size_t last_ax = merge_loops(axes.rbegin(), axes.rend());
+
+            iter_shape.erase(iter_shape.begin() + std::ptrdiff_t(last_ax), iter_shape.end());
+            iter_strides.erase(iter_strides.begin() + std::ptrdiff_t(last_ax), iter_strides.end());
+        }
+        else if (e.layout() == layout_type::column_major)
+        {
+            // we got column_major here
+            std::size_t last_ax = merge_loops(axes.begin(), axes.end());
+
+            // erasing the front vs the back
+            iter_shape.erase(iter_shape.begin(), iter_shape.begin() + std::ptrdiff_t(last_ax + 1));
+            iter_strides.erase(iter_strides.begin(), iter_strides.begin() + std::ptrdiff_t(last_ax + 1));
+
+            // and reversing, to make it work with the same next_idx function
+            std::reverse(iter_shape.begin(), iter_shape.end());
+            std::reverse(iter_strides.begin(), iter_strides.end());
+        }
+        else
+        {
+            XTENSOR_THROW(std::runtime_error, "Layout not supported in immediate reduction.");
+        }
+
+        xindex temp_idx(iter_shape.size());
+        auto next_idx = [&iter_shape, &iter_strides, &temp_idx]()
+        {
+            std::size_t i = iter_shape.size();
+            for (; i > 0; --i)
+            {
+                if (std::ptrdiff_t(temp_idx[i - 1]) >= std::ptrdiff_t(iter_shape[i - 1]) - 1)
+                {
+                    temp_idx[i - 1] = 0;
+                }
+                else
+                {
+                    temp_idx[i - 1]++;
+                    break;
+                }
+            }
+
+            return std::make_pair(
+                i == 0,
+                std::inner_product(temp_idx.begin(), temp_idx.end(), iter_strides.begin(), std::ptrdiff_t(0))
+            );
+        };
+
+        auto begin = e.data();
+        auto out = result.data();
+        auto out_begin = result.data();
+
+        std::ptrdiff_t next_stride = 0;
+
+        std::pair<bool, std::ptrdiff_t> idx_res(false, 0);
+
+        // Remark: eventually some modifications here to make conditions faster where merge + accumulate is
+        // the same function (e.g. check std::is_same<decltype(merge_fct), decltype(reduce_fct)>::value) ...
+
+        auto merge_border = out;
+        bool merge = false;
+
+        // TODO there could be some performance gain by removing merge checking
+        //      when axes.size() == 1 and even next_idx could be removed for something simpler (next_stride
+        //      always the same) best way to do this would be to create a function that takes (begin, out,
+        //      outer_loop_size, inner_loop_size, next_idx_lambda)
+        // Decide if going about it row-wise or col-wise
+        if (inner_stride == 1)
+        {
+            while (idx_res.first != true)
+            {
+                // for unknown reasons it's much faster to use a temporary variable and
+                // std::accumulate here -- probably some cache behavior
+                result_type tmp = init_fct();
+                tmp = std::accumulate(begin, begin + outer_loop_size, tmp, reduce_fct);
+
+                // use merge function if necessary
+                *out = merge ? merge_fct(*out, tmp) : tmp;
+
+                begin += outer_loop_size;
+
+                idx_res = next_idx();
+                next_stride = idx_res.second;
+                out = out_begin + next_stride;
+
+                if (out > merge_border)
+                {
+                    // looped over once
+                    merge = false;
+                    merge_border = out;
+                }
+                else
+                {
+                    merge = true;
+                }
+            };
+        }
+        else
+        {
+            while (idx_res.first != true)
+            {
+                std::transform(
+                    out,
+                    out + inner_loop_size,
+                    begin,
+                    out,
+                    [merge, &init_fct, &reduce_fct](auto&& v1, auto&& v2)
+                    {
+                        return merge ? reduce_fct(v1, v2) :
+                                     // cast because return type of identity function is not upcasted
+                                   reduce_fct(static_cast<result_type>(init_fct()), v2);
+                    }
+                );
+
+                begin += inner_stride;
+                for (std::size_t i = 1; i < outer_loop_size; ++i)
+                {
+                    std::transform(out, out + inner_loop_size, begin, out, reduce_fct);
+                    begin += inner_stride;
+                }
+
+                idx_res = next_idx();
+                next_stride = idx_res.second;
+                out = out_begin + next_stride;
+
+                if (out > merge_border)
+                {
+                    // looped over once
+                    merge = false;
+                    merge_border = out;
+                }
+                else
+                {
+                    merge = true;
+                }
+            };
+        }
+        if (options_t::has_initial_value)
+        {
+            std::transform(
+                result.data(),
+                result.data() + result.size(),
+                result.data(),
+                [&merge_fct, &options](auto&& v)
+                {
+                    return merge_fct(v, options.initial_value);
+                }
+            );
+        }
+        return result;
+    }
+
+    /*********************
+     * xreducer functors *
+     *********************/
+
+    template <class T>
+    struct const_value
+    {
+        using value_type = T;
+
+        constexpr const_value() = default;
+
+        constexpr const_value(T t)
+            : m_value(t)
+        {
+        }
+
+        constexpr T operator()() const
+        {
+            return m_value;
+        }
+
+        template <class NT>
+        using rebind_t = const_value<NT>;
+
+        template <class NT>
+        const_value<NT> rebind() const;
+
+        T m_value;
+    };
+
+    namespace detail
+    {
+        template <class T, bool B>
+        struct evaluated_value_type
+        {
+            using type = T;
+        };
+
+        template <class T>
+        struct evaluated_value_type<T, true>
+        {
+            using type = typename std::decay_t<decltype(xt::eval(std::declval<T>()))>;
+        };
+
+        template <class T, bool B>
+        using evaluated_value_type_t = typename evaluated_value_type<T, B>::type;
+    }
+
+    template <class REDUCE_FUNC, class INIT_FUNC = const_value<long int>, class MERGE_FUNC = REDUCE_FUNC>
+    struct xreducer_functors : public std::tuple<REDUCE_FUNC, INIT_FUNC, MERGE_FUNC>
+    {
+        using self_type = xreducer_functors<REDUCE_FUNC, INIT_FUNC, MERGE_FUNC>;
+        using base_type = std::tuple<REDUCE_FUNC, INIT_FUNC, MERGE_FUNC>;
+        using reduce_functor_type = REDUCE_FUNC;
+        using init_functor_type = INIT_FUNC;
+        using merge_functor_type = MERGE_FUNC;
+        using init_value_type = typename init_functor_type::value_type;
+
+        xreducer_functors()
+            : base_type()
+        {
+        }
+
+        template <class RF>
+        xreducer_functors(RF&& reduce_func)
+            : base_type(std::forward<RF>(reduce_func), INIT_FUNC(), reduce_func)
+        {
+        }
+
+        template <class RF, class IF>
+        xreducer_functors(RF&& reduce_func, IF&& init_func)
+            : base_type(std::forward<RF>(reduce_func), std::forward<IF>(init_func), reduce_func)
+        {
+        }
+
+        template <class RF, class IF, class MF>
+        xreducer_functors(RF&& reduce_func, IF&& init_func, MF&& merge_func)
+            : base_type(std::forward<RF>(reduce_func), std::forward<IF>(init_func), std::forward<MF>(merge_func))
+        {
+        }
+
+        reduce_functor_type get_reduce() const
+        {
+            return std::get<0>(upcast());
+        }
+
+        init_functor_type get_init() const
+        {
+            return std::get<1>(upcast());
+        }
+
+        merge_functor_type get_merge() const
+        {
+            return std::get<2>(upcast());
+        }
+
+        template <class NT>
+        using rebind_t = xreducer_functors<REDUCE_FUNC, const_value<NT>, MERGE_FUNC>;
+
+        template <class NT>
+        rebind_t<NT> rebind()
+        {
+            return make_xreducer_functor(get_reduce(), get_init().template rebind<NT>(), get_merge());
+        }
+
+    private:
+
+        // Workaround for clang-cl
+        const base_type& upcast() const
+        {
+            return static_cast<const base_type&>(*this);
+        }
+    };
+
+    template <class RF>
+    auto make_xreducer_functor(RF&& reduce_func)
+    {
+        using reducer_type = xreducer_functors<std::remove_reference_t<RF>>;
+        return reducer_type(std::forward<RF>(reduce_func));
+    }
+
+    template <class RF, class IF>
+    auto make_xreducer_functor(RF&& reduce_func, IF&& init_func)
+    {
+        using reducer_type = xreducer_functors<std::remove_reference_t<RF>, std::remove_reference_t<IF>>;
+        return reducer_type(std::forward<RF>(reduce_func), std::forward<IF>(init_func));
+    }
+
+    template <class RF, class IF, class MF>
+    auto make_xreducer_functor(RF&& reduce_func, IF&& init_func, MF&& merge_func)
+    {
+        using reducer_type = xreducer_functors<
+            std::remove_reference_t<RF>,
+            std::remove_reference_t<IF>,
+            std::remove_reference_t<MF>>;
+        return reducer_type(
+            std::forward<RF>(reduce_func),
+            std::forward<IF>(init_func),
+            std::forward<MF>(merge_func)
+        );
+    }
+
+    /**********************
+     * xreducer extension *
+     **********************/
+
+    namespace extension
+    {
+        template <class Tag, class F, class CT, class X, class O>
+        struct xreducer_base_impl;
+
+        template <class F, class CT, class X, class O>
+        struct xreducer_base_impl<xtensor_expression_tag, F, CT, X, O>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class F, class CT, class X, class O>
+        struct xreducer_base : xreducer_base_impl<xexpression_tag_t<CT>, F, CT, X, O>
+        {
+        };
+
+        template <class F, class CT, class X, class O>
+        using xreducer_base_t = typename xreducer_base<F, CT, X, O>::type;
+    }
+
+    /************
+     * xreducer *
+     ************/
+
+    template <class F, class CT, class X, class O>
+    class xreducer;
+
+    template <class F, class CT, class X, class O>
+    class xreducer_stepper;
+
+    template <class F, class CT, class X, class O>
+    struct xiterable_inner_types<xreducer<F, CT, X, O>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using inner_shape_type = typename xreducer_shape_type<
+            typename xexpression_type::shape_type,
+            std::decay_t<X>,
+            typename O::keep_dims>::type;
+        using const_stepper = xreducer_stepper<F, CT, X, O>;
+        using stepper = const_stepper;
+    };
+
+    template <class F, class CT, class X, class O>
+    struct xcontainer_inner_types<xreducer<F, CT, X, O>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using reduce_functor_type = typename std::decay_t<F>::reduce_functor_type;
+        using init_functor_type = typename std::decay_t<F>::init_functor_type;
+        using merge_functor_type = typename std::decay_t<F>::merge_functor_type;
+        using substepper_type = typename xexpression_type::const_stepper;
+        using raw_value_type = std::decay_t<decltype(std::declval<reduce_functor_type>()(
+            std::declval<init_functor_type>()(),
+            *std::declval<substepper_type>()
+        ))>;
+        using value_type = typename detail::evaluated_value_type_t<raw_value_type, is_xexpression<raw_value_type>::value>;
+
+        using reference = value_type;
+        using const_reference = value_type;
+        using size_type = typename xexpression_type::size_type;
+    };
+
+    template <class T>
+    struct select_dim_mapping_type
+    {
+        using type = T;
+    };
+
+    template <std::size_t... I>
+    struct select_dim_mapping_type<fixed_shape<I...>>
+    {
+        using type = std::array<std::size_t, sizeof...(I)>;
+    };
+
+    /**
+     * @class xreducer
+     * @brief Reducing function operating over specified axes.
+     *
+     * The xreducer class implements an \ref xexpression applying
+     * a reducing function to an \ref xexpression over the specified
+     * axes.
+     *
+     * @tparam F a tuple of functors (class \ref xreducer_functors or compatible)
+     * @tparam CT the closure type of the \ref xexpression to reduce
+     * @tparam X the list of axes
+     *
+     * The reducer's result_type is deduced from the result type of function
+     * <tt>F::reduce_functor_type</tt> when called with elements of the expression @tparam CT.
+     *
+     * @sa reduce
+     */
+    template <class F, class CT, class X, class O>
+    class xreducer : public xsharable_expression<xreducer<F, CT, X, O>>,
+                     public xconst_iterable<xreducer<F, CT, X, O>>,
+                     public xaccessible<xreducer<F, CT, X, O>>,
+                     public extension::xreducer_base_t<F, CT, X, O>
+    {
+    public:
+
+        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;
+
+        static constexpr layout_type static_layout = layout_type::dynamic;
+        static constexpr bool contiguous_layout = false;
+
+        template <class Func, class CTA, class AX, class OX>
+        xreducer(Func&& func, CTA&& e, AX&& axes, OX&& options);
+
+        const inner_shape_type& shape() const noexcept;
+        layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+
+        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;
+
+        const xexpression_type& expression() const noexcept;
+
+        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>
+        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, class Func = F, class Opts = O>
+        using rebind_t = xreducer<Func, E, X, Opts>;
+
+        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
+        {
+            return xreducer_functors_type(m_reduce, m_init, m_merge);  // TODO: understand why
+                                                                       // make_xreducer_functor is throwing an
+                                                                       // error
+        }
+
+        const O& options() const
+        {
+            return m_options;
+        }
+
+    private:
+
+        CT m_e;
+        reduce_functor_type m_reduce;
+        init_functor_type m_init;
+        merge_functor_type m_merge;
+        axes_type m_axes;
+        inner_shape_type m_shape;
+        dim_mapping_type m_dim_mapping;
+        O m_options;
+
+        friend class xreducer_stepper<F, CT, X, O>;
+    };
+
+    /*************************
+     * reduce implementation *
+     *************************/
+
+    namespace detail
+    {
+        template <class F, class E, class X, class O>
+        inline auto reduce_impl(F&& f, E&& e, X&& axes, evaluation_strategy::lazy_type, O&& options)
+        {
+            decltype(auto) normalized_axes = normalize_axis(e, std::forward<X>(axes));
+
+            using reduce_functor_type = typename std::decay_t<F>::reduce_functor_type;
+            using init_functor_type = typename std::decay_t<F>::init_functor_type;
+            using value_type = std::decay_t<decltype(std::declval<reduce_functor_type>()(
+                std::declval<init_functor_type>()(),
+                *std::declval<typename std::decay_t<E>::const_stepper>()
+            ))>;
+            using evaluated_value_type = evaluated_value_type_t<value_type, is_xexpression<value_type>::value>;
+
+            using reducer_type = xreducer<
+                F,
+                const_xclosure_t<E>,
+                xtl::const_closure_type_t<decltype(normalized_axes)>,
+                reducer_options<evaluated_value_type, std::decay_t<O>>>;
+            return reducer_type(
+                std::forward<F>(f),
+                std::forward<E>(e),
+                std::forward<decltype(normalized_axes)>(normalized_axes),
+                std::forward<O>(options)
+            );
+        }
+
+        template <class F, class E, class X, class O>
+        inline auto reduce_impl(F&& f, E&& e, X&& axes, evaluation_strategy::immediate_type, O&& options)
+        {
+            decltype(auto) normalized_axes = normalize_axis(e, std::forward<X>(axes));
+            return reduce_immediate(
+                std::forward<F>(f),
+                eval(std::forward<E>(e)),
+                std::forward<decltype(normalized_axes)>(normalized_axes),
+                std::forward<O>(options)
+            );
+        }
+    }
+
+#define DEFAULT_STRATEGY_REDUCERS std::tuple<evaluation_strategy::lazy_type>
+
+    namespace detail
+    {
+        template <class T>
+        struct is_xreducer_functors_impl : std::false_type
+        {
+        };
+
+        template <class RF, class IF, class MF>
+        struct is_xreducer_functors_impl<xreducer_functors<RF, IF, MF>> : std::true_type
+        {
+        };
+
+        template <class T>
+        using is_xreducer_functors = is_xreducer_functors_impl<std::decay_t<T>>;
+    }
+
+    /**
+     * @brief Returns an \ref xexpression applying the specified reducing
+     * function to an expression over the given axes.
+     *
+     * @param f the reducing function to apply.
+     * @param e the \ref xexpression to reduce.
+     * @param axes the list of axes.
+     * @param options evaluation strategy to use (lazy (default), or immediate)
+     *
+     * The returned expression either hold a const reference to \p e or a copy
+     * depending on whether \p e is an lvalue or an rvalue.
+     */
+
+    template <
+        class F,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, detail::is_xreducer_functors<F>)>
+    inline auto reduce(F&& f, E&& e, X&& axes, EVS&& options = EVS())
+    {
+        return detail::reduce_impl(
+            std::forward<F>(f),
+            std::forward<E>(e),
+            std::forward<X>(axes),
+            typename reducer_options<int, EVS>::evaluation_strategy{},
+            std::forward<EVS>(options)
+        );
+    }
+
+    template <
+        class F,
+        class E,
+        class X,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<is_reducer_options<X>>, std::negation<detail::is_xreducer_functors<F>>)>
+    inline auto reduce(F&& f, E&& e, X&& axes, EVS&& options = EVS())
+    {
+        return reduce(
+            make_xreducer_functor(std::forward<F>(f)),
+            std::forward<E>(e),
+            std::forward<X>(axes),
+            std::forward<EVS>(options)
+        );
+    }
+
+    template <
+        class F,
+        class E,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(is_reducer_options<EVS>, detail::is_xreducer_functors<F>)>
+    inline auto reduce(F&& f, E&& e, EVS&& options = EVS())
+    {
+        xindex_type_t<typename std::decay_t<E>::shape_type> ar;
+        resize_container(ar, e.dimension());
+        std::iota(ar.begin(), ar.end(), 0);
+        return detail::reduce_impl(
+            std::forward<F>(f),
+            std::forward<E>(e),
+            std::move(ar),
+            typename reducer_options<int, std::decay_t<EVS>>::evaluation_strategy{},
+            std::forward<EVS>(options)
+        );
+    }
+
+    template <
+        class F,
+        class E,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(is_reducer_options<EVS>, std::negation<detail::is_xreducer_functors<F>>)>
+    inline auto reduce(F&& f, E&& e, EVS&& options = EVS())
+    {
+        return reduce(make_xreducer_functor(std::forward<F>(f)), std::forward<E>(e), std::forward<EVS>(options));
+    }
+
+    template <
+        class F,
+        class E,
+        class I,
+        std::size_t N,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(detail::is_xreducer_functors<F>)>
+    inline auto reduce(F&& f, E&& e, const I (&axes)[N], EVS options = EVS())
+    {
+        using axes_type = std::array<std::size_t, N>;
+        auto ax = xt::forward_normalize<axes_type>(e, axes);
+        return detail::reduce_impl(
+            std::forward<F>(f),
+            std::forward<E>(e),
+            std::move(ax),
+            typename reducer_options<int, EVS>::evaluation_strategy{},
+            options
+        );
+    }
+
+    template <
+        class F,
+        class E,
+        class I,
+        std::size_t N,
+        class EVS = DEFAULT_STRATEGY_REDUCERS,
+        XTL_REQUIRES(std::negation<detail::is_xreducer_functors<F>>)>
+    inline auto reduce(F&& f, E&& e, const I (&axes)[N], EVS options = EVS())
+    {
+        return reduce(make_xreducer_functor(std::forward<F>(f)), std::forward<E>(e), axes, options);
+    }
+
+    /********************
+     * xreducer_stepper *
+     ********************/
+
+    template <class F, class CT, class X, class O>
+    class xreducer_stepper
+    {
+    public:
+
+        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;
+
+        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);
+
+    private:
+
+        reference initial_value() const;
+        reference aggregate(size_type dim) const;
+        reference aggregate_impl(size_type dim, /*keep_dims=*/std::false_type) const;
+        reference aggregate_impl(size_type dim, /*keep_dims=*/std::true_type) const;
+
+        substepper_type get_substepper_begin() const;
+        size_type get_dim(size_type dim) const noexcept;
+        size_type shape(size_type i) const noexcept;
+        size_type axis(size_type i) const noexcept;
+
+        const xreducer_type* m_reducer;
+        size_type m_offset;
+        mutable substepper_type m_stepper;
+    };
+
+    /******************
+     * xreducer utils *
+     ******************/
+
+    namespace detail
+    {
+        template <std::size_t X, std::size_t... I>
+        struct in
+        {
+            static constexpr bool value = std::disjunction<std::integral_constant<bool, X == I>...>::value;
+        };
+
+        template <std::size_t Z, class S1, class S2, class R>
+        struct fixed_xreducer_shape_type_impl;
+
+        template <std::size_t Z, std::size_t... I, std::size_t... J, std::size_t... R>
+        struct fixed_xreducer_shape_type_impl<Z, fixed_shape<I...>, fixed_shape<J...>, fixed_shape<R...>>
+        {
+            using type = std::conditional_t<
+                in<Z, J...>::value,
+                typename fixed_xreducer_shape_type_impl<Z - 1, fixed_shape<I...>, fixed_shape<J...>, fixed_shape<R...>>::type,
+                typename fixed_xreducer_shape_type_impl<
+                    Z - 1,
+                    fixed_shape<I...>,
+                    fixed_shape<J...>,
+                    fixed_shape<detail::at<Z, I...>::value, R...>>::type>;
+        };
+
+        template <std::size_t... I, std::size_t... J, std::size_t... R>
+        struct fixed_xreducer_shape_type_impl<0, fixed_shape<I...>, fixed_shape<J...>, fixed_shape<R...>>
+        {
+            using type = std::
+                conditional_t<in<0, J...>::value, fixed_shape<R...>, fixed_shape<detail::at<0, I...>::value, R...>>;
+        };
+
+        /***************************
+         * helper for return types *
+         ***************************/
+
+        template <class T>
+        struct xreducer_size_type
+        {
+            using type = std::size_t;
+        };
+
+        template <class T>
+        using xreducer_size_type_t = typename xreducer_size_type<T>::type;
+
+        template <class T>
+        struct xreducer_temporary_type
+        {
+            using type = T;
+        };
+
+        template <class T>
+        using xreducer_temporary_type_t = typename xreducer_temporary_type<T>::type;
+
+        /********************************
+         * Default const_value rebinder *
+         ********************************/
+
+        template <class T, class U>
+        struct const_value_rebinder
+        {
+            static const_value<U> run(const const_value<T>& t)
+            {
+                return const_value<U>(t.m_value);
+            }
+        };
+    }
+
+    /*******************************************
+     * Init functor const_value implementation *
+     *******************************************/
+
+    template <class T>
+    template <class NT>
+    const_value<NT> const_value<T>::rebind() const
+    {
+        return detail::const_value_rebinder<T, NT>::run(*this);
+    }
+
+    /*****************************
+     * fixed_xreducer_shape_type *
+     *****************************/
+
+    template <class S1, class S2>
+    struct fixed_xreducer_shape_type;
+
+    template <std::size_t... I, std::size_t... J>
+    struct fixed_xreducer_shape_type<fixed_shape<I...>, fixed_shape<J...>>
+    {
+        using type = typename detail::
+            fixed_xreducer_shape_type_impl<sizeof...(I) - 1, fixed_shape<I...>, fixed_shape<J...>, fixed_shape<>>::type;
+    };
+
+    // meta-function returning the shape type for an xreducer
+    template <class ST, class X, class O>
+    struct xreducer_shape_type
+    {
+        using type = promote_shape_t<ST, std::decay_t<X>>;
+    };
+
+    template <class I1, std::size_t N1, class I2, std::size_t N2>
+    struct xreducer_shape_type<std::array<I1, N1>, std::array<I2, N2>, std::true_type>
+    {
+        using type = std::array<I2, N1>;
+    };
+
+    template <class I1, std::size_t N1, class I2, std::size_t N2>
+    struct xreducer_shape_type<std::array<I1, N1>, std::array<I2, N2>, std::false_type>
+    {
+        using type = std::array<I2, N1 - N2>;
+    };
+
+    template <std::size_t... I, class I2, std::size_t N2>
+    struct xreducer_shape_type<fixed_shape<I...>, std::array<I2, N2>, std::false_type>
+    {
+        using type = std::conditional_t<sizeof...(I) == N2, fixed_shape<>, std::array<I2, sizeof...(I) - N2>>;
+    };
+
+    namespace detail
+    {
+        template <class S1, class S2>
+        struct ixconcat;
+
+        template <class T, T... I1, T... I2>
+        struct ixconcat<std::integer_sequence<T, I1...>, std::integer_sequence<T, I2...>>
+        {
+            using type = std::integer_sequence<T, I1..., I2...>;
+        };
+
+        template <class T, T X, std::size_t N>
+        struct repeat_integer_sequence
+        {
+            using type = typename ixconcat<
+                std::integer_sequence<T, X>,
+                typename repeat_integer_sequence<T, X, N - 1>::type>::type;
+        };
+
+        template <class T, T X>
+        struct repeat_integer_sequence<T, X, 0>
+        {
+            using type = std::integer_sequence<T>;
+        };
+
+        template <class T, T X>
+        struct repeat_integer_sequence<T, X, 2>
+        {
+            using type = std::integer_sequence<T, X, X>;
+        };
+
+        template <class T, T X>
+        struct repeat_integer_sequence<T, X, 1>
+        {
+            using type = std::integer_sequence<T, X>;
+        };
+    }
+
+    template <std::size_t... I, class I2, std::size_t N2>
+    struct xreducer_shape_type<fixed_shape<I...>, std::array<I2, N2>, std::true_type>
+    {
+        template <std::size_t... X>
+        static constexpr auto get_type(std::index_sequence<X...>)
+        {
+            return fixed_shape<X...>{};
+        }
+
+        // if all axes reduced
+        using type = std::conditional_t<
+            sizeof...(I) == N2,
+            decltype(get_type(typename detail::repeat_integer_sequence<std::size_t, std::size_t(1), N2>::type{})),
+            std::array<I2, sizeof...(I)>>;
+    };
+
+    // Note adding "A" to prevent compilation in case nothing else matches
+    template <std::size_t... I, std::size_t... J, class O>
+    struct xreducer_shape_type<fixed_shape<I...>, fixed_shape<J...>, O>
+    {
+        using type = typename fixed_xreducer_shape_type<fixed_shape<I...>, fixed_shape<J...>>::type;
+    };
+
+    namespace detail
+    {
+        template <class S, class E, class X, class M>
+        inline void shape_and_mapping_computation(S& shape, E& e, const X& axes, M& mapping, std::false_type)
+        {
+            auto first = e.shape().begin();
+            auto last = e.shape().end();
+            auto exclude_it = axes.begin();
+
+            using value_type = typename S::value_type;
+            using difference_type = typename S::difference_type;
+            auto d_first = shape.begin();
+            auto map_first = mapping.begin();
+
+            auto iter = first;
+            while (iter != last && exclude_it != axes.end())
+            {
+                auto diff = std::distance(first, iter);
+                if (diff != difference_type(*exclude_it))
+                {
+                    *d_first++ = *iter++;
+                    *map_first++ = value_type(diff);
+                }
+                else
+                {
+                    ++iter;
+                    ++exclude_it;
+                }
+            }
+
+            auto diff = std::distance(first, iter);
+            auto end = std::distance(iter, last);
+            std::iota(map_first, map_first + end, diff);
+            std::copy(iter, last, d_first);
+        }
+
+        template <class S, class E, class X, class M>
+        inline void
+        shape_and_mapping_computation_keep_dim(S& shape, E& e, const X& axes, M& mapping, std::false_type)
+        {
+            for (std::size_t i = 0; i < e.dimension(); ++i)
+            {
+                if (std::find(axes.cbegin(), axes.cend(), i) == axes.cend())
+                {
+                    // i not in axes!
+                    shape[i] = e.shape()[i];
+                }
+                else
+                {
+                    shape[i] = 1;
+                }
+            }
+            std::iota(mapping.begin(), mapping.end(), 0);
+        }
+
+        template <class S, class E, class X, class M>
+        inline void shape_and_mapping_computation(S&, E&, const X&, M&, std::true_type)
+        {
+        }
+
+        template <class S, class E, class X, class M>
+        inline void shape_and_mapping_computation_keep_dim(S&, E&, const X&, M&, std::true_type)
+        {
+        }
+    }
+
+    /***************************
+     * xreducer implementation *
+     ***************************/
+
+    /**
+     * @name Constructor
+     */
+    //@{
+    /**
+     * Constructs an xreducer expression applying the specified
+     * function to the given expression over the given axes.
+     *
+     * @param func the function to apply
+     * @param e the expression to reduce
+     * @param axes the axes along which the reduction is performed
+     * @param options reducer options controlling evaluation strategy and related settings
+     */
+    template <class F, class CT, class X, class O>
+    template <class Func, class CTA, class AX, class OX>
+    inline xreducer<F, CT, X, O>::xreducer(Func&& func, CTA&& e, AX&& axes, OX&& options)
+        : m_e(std::forward<CTA>(e))
+        , m_reduce(xt::get<0>(func))
+        , m_init(xt::get<1>(func))
+        , m_merge(xt::get<2>(func))
+        , m_axes(std::forward<AX>(axes))
+        , m_shape(xtl::make_sequence<inner_shape_type>(
+              typename O::keep_dims() ? m_e.dimension() : m_e.dimension() - m_axes.size(),
+              0
+          ))
+        , m_dim_mapping(xtl::make_sequence<dim_mapping_type>(
+              typename O::keep_dims() ? m_e.dimension() : m_e.dimension() - m_axes.size(),
+              0
+          ))
+        , m_options(std::forward<OX>(options))
+    {
+        // std::less is used, because as the standard says (24.4.5):
+        // A sequence is sorted with respect to a comparator comp if for any iterator i pointing to the
+        // sequence and any non-negative integer n such that i + n is a valid iterator pointing to an element
+        // of the sequence, comp(*(i + n), *i) == false. Therefore less is required to detect duplicates.
+        if (!std::is_sorted(m_axes.cbegin(), m_axes.cend(), std::less<>()))
+        {
+            XTENSOR_THROW(std::runtime_error, "Reducing axes should be sorted.");
+        }
+        if (std::adjacent_find(m_axes.cbegin(), m_axes.cend()) != m_axes.cend())
+        {
+            XTENSOR_THROW(std::runtime_error, "Reducing axes should not contain duplicates.");
+        }
+        if (m_axes.size() != 0 && m_axes[m_axes.size() - 1] > m_e.dimension() - 1)
+        {
+            XTENSOR_THROW(
+                std::runtime_error,
+                "Axis " + std::to_string(m_axes[m_axes.size() - 1]) + " out of bounds for reduction."
+            );
+        }
+
+        if (!typename O::keep_dims())
+        {
+            detail::shape_and_mapping_computation(
+                m_shape,
+                m_e,
+                m_axes,
+                m_dim_mapping,
+                detail::is_fixed<shape_type>{}
+            );
+        }
+        else
+        {
+            detail::shape_and_mapping_computation_keep_dim(
+                m_shape,
+                m_e,
+                m_axes,
+                m_dim_mapping,
+                detail::is_fixed<shape_type>{}
+            );
+        }
+    }
+
+    //@}
+
+    /**
+     * @name Size and shape
+     */
+
+    /**
+     * Returns the shape of the expression.
+     */
+    template <class F, class CT, class X, class O>
+    inline auto xreducer<F, CT, X, O>::shape() const noexcept -> const inner_shape_type&
+    {
+        return m_shape;
+    }
+
+    /**
+     * Returns the shape of the expression.
+     */
+    template <class F, class CT, class X, class O>
+    inline layout_type xreducer<F, CT, X, O>::layout() const noexcept
+    {
+        return static_layout;
+    }
+
+    template <class F, class CT, class X, class O>
+    inline bool xreducer<F, CT, X, O>::is_contiguous() const noexcept
+    {
+        return false;
+    }
+
+    //@}
+
+    /**
+     * @name Data
+     */
+
+    /**
+     * Returns a constant reference to the element at the specified position in the reducer.
+     * @param args a 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.
+     */
+    template <class F, class CT, class X, class O>
+    template <class... Args>
+    inline auto xreducer<F, CT, X, O>::operator()(Args... args) const -> const_reference
+    {
+        XTENSOR_TRY(check_index(shape(), args...));
+        XTENSOR_CHECK_DIMENSION(shape(), args...);
+        std::array<std::size_t, sizeof...(Args)> arg_array = {{static_cast<std::size_t>(args)...}};
+        return element(arg_array.cbegin(), arg_array.cend());
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the reducer.
+     * @param args a 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.
+     * @warning This method is NOT compatible with broadcasting, meaning the following
+     * code has undefined behavior:
+     * @code{.cpp}
+     * xt::xarray<double> a = {{0, 1}, {2, 3}};
+     * xt::xarray<double> b = {0, 1};
+     * auto fd = a + b;
+     * double res = fd.uncheked(0, 1);
+     * @endcode
+     */
+    template <class F, class CT, class X, class O>
+    template <class... Args>
+    inline auto xreducer<F, CT, X, O>::unchecked(Args... args) const -> const_reference
+    {
+        std::array<std::size_t, sizeof...(Args)> arg_array = {{static_cast<std::size_t>(args)...}};
+        return element(arg_array.cbegin(), arg_array.cend());
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the reducer.
+     * @param first iterator starting the sequence of indices
+     * @param last iterator 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.
+     */
+    template <class F, class CT, class X, class O>
+    template <class It>
+    inline auto xreducer<F, CT, X, O>::element(It first, It last) const -> const_reference
+    {
+        XTENSOR_TRY(check_element_index(shape(), first, last));
+        auto stepper = const_stepper(*this, 0);
+        if (first != last)
+        {
+            size_type dim = 0;
+            // drop left most elements
+            auto size = std::ptrdiff_t(this->dimension()) - std::distance(first, last);
+            auto begin = first - size;
+            while (begin != last)
+            {
+                if (begin < first)
+                {
+                    stepper.step(dim++, std::size_t(0));
+                    begin++;
+                }
+                else
+                {
+                    stepper.step(dim++, std::size_t(*begin++));
+                }
+            }
+        }
+        return *stepper;
+    }
+
+    /**
+     * Returns a constant reference to the underlying expression of the reducer.
+     */
+    template <class F, class CT, class X, class O>
+    inline auto xreducer<F, CT, X, O>::expression() const noexcept -> const xexpression_type&
+    {
+        return m_e;
+    }
+
+    //@}
+
+    /**
+     * @name Broadcasting
+     */
+    //@{
+    /**
+     * Broadcast the shape of the reducer to the specified parameter.
+     * @param shape the result shape
+     * @param reuse_cache parameter for internal optimization
+     * @return a boolean indicating whether the broadcasting is trivial
+     */
+    template <class F, class CT, class X, class O>
+    template <class S>
+    inline bool xreducer<F, CT, X, O>::broadcast_shape(S& shape, bool) const
+    {
+        return xt::broadcast_shape(m_shape, shape);
+    }
+
+    /**
+     * Checks whether the xreducer can be linearly assigned to an expression
+     * with the specified strides.
+     * @return a boolean indicating whether a linear assign is possible
+     */
+    template <class F, class CT, class X, class O>
+    template <class S>
+    inline bool xreducer<F, CT, X, O>::has_linear_assign(const S& /*strides*/) const noexcept
+    {
+        return false;
+    }
+
+    //@}
+
+    template <class F, class CT, class X, class O>
+    template <class S>
+    inline auto xreducer<F, CT, X, O>::stepper_begin(const S& shape) const noexcept -> const_stepper
+    {
+        size_type offset = shape.size() - this->dimension();
+        return const_stepper(*this, offset);
+    }
+
+    template <class F, class CT, class X, class O>
+    template <class S>
+    inline auto xreducer<F, CT, X, O>::stepper_end(const S& shape, layout_type l) const noexcept
+        -> const_stepper
+    {
+        size_type offset = shape.size() - this->dimension();
+        return const_stepper(*this, offset, true, l);
+    }
+
+    template <class F, class CT, class X, class O>
+    template <class E>
+    inline auto xreducer<F, CT, X, O>::build_reducer(E&& e) const -> rebind_t<E>
+    {
+        return rebind_t<E>(
+            std::make_tuple(m_reduce, m_init, m_merge),
+            std::forward<E>(e),
+            axes_type(m_axes),
+            m_options
+        );
+    }
+
+    template <class F, class CT, class X, class O>
+    template <class E, class Func, class Opts>
+    inline auto xreducer<F, CT, X, O>::build_reducer(E&& e, Func&& func, Opts&& opts) const
+        -> rebind_t<E, Func, Opts>
+    {
+        return rebind_t<E, Func, Opts>(
+            std::forward<Func>(func),
+            std::forward<E>(e),
+            axes_type(m_axes),
+            std::forward<Opts>(opts)
+        );
+    }
+
+    /***********************************
+     * xreducer_stepper implementation *
+     ***********************************/
+
+    template <class F, class CT, class X, class O>
+    inline xreducer_stepper<F, CT, X, O>::xreducer_stepper(
+        const xreducer_type& red,
+        size_type offset,
+        bool end,
+        layout_type l
+    )
+        : m_reducer(&red)
+        , m_offset(offset)
+        , m_stepper(get_substepper_begin())
+    {
+        if (end)
+        {
+            to_end(l);
+        }
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::operator*() const -> reference
+    {
+        reference r = aggregate(0);
+        return r;
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::step(size_type dim)
+    {
+        if (dim >= m_offset)
+        {
+            m_stepper.step(get_dim(dim - m_offset));
+        }
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::step_back(size_type dim)
+    {
+        if (dim >= m_offset)
+        {
+            m_stepper.step_back(get_dim(dim - m_offset));
+        }
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::step(size_type dim, size_type n)
+    {
+        if (dim >= m_offset)
+        {
+            m_stepper.step(get_dim(dim - m_offset), n);
+        }
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::step_back(size_type dim, size_type n)
+    {
+        if (dim >= m_offset)
+        {
+            m_stepper.step_back(get_dim(dim - m_offset), n);
+        }
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::reset(size_type dim)
+    {
+        if (dim >= m_offset)
+        {
+            // Because the reducer uses `reset` to reset the non-reducing axes,
+            // we need to prevent that here for the KD case where.
+            if (typename O::keep_dims()
+                && std::binary_search(m_reducer->m_axes.begin(), m_reducer->m_axes.end(), dim - m_offset))
+            {
+                // If keep dim activated, and dim is in the axes, do nothing!
+                return;
+            }
+            m_stepper.reset(get_dim(dim - m_offset));
+        }
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::reset_back(size_type dim)
+    {
+        if (dim >= m_offset)
+        {
+            // Note that for *not* KD this is not going to do anything
+            if (typename O::keep_dims()
+                && std::binary_search(m_reducer->m_axes.begin(), m_reducer->m_axes.end(), dim - m_offset))
+            {
+                // If keep dim activated, and dim is in the axes, do nothing!
+                return;
+            }
+            m_stepper.reset_back(get_dim(dim - m_offset));
+        }
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::to_begin()
+    {
+        m_stepper.to_begin();
+    }
+
+    template <class F, class CT, class X, class O>
+    inline void xreducer_stepper<F, CT, X, O>::to_end(layout_type l)
+    {
+        m_stepper.to_end(l);
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::initial_value() const -> reference
+    {
+        return O::has_initial_value ? m_reducer->m_options.initial_value
+                                    : static_cast<reference>(m_reducer->m_init());
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::aggregate(size_type dim) const -> reference
+    {
+        reference res;
+        if (m_reducer->m_e.size() == size_type(0))
+        {
+            res = initial_value();
+        }
+        else if (m_reducer->m_e.shape().empty() || m_reducer->m_axes.size() == 0)
+        {
+            res = m_reducer->m_reduce(initial_value(), *m_stepper);
+        }
+        else
+        {
+            res = aggregate_impl(dim, typename O::keep_dims());
+            if (O::has_initial_value && dim == 0)
+            {
+                res = m_reducer->m_merge(m_reducer->m_options.initial_value, res);
+            }
+        }
+        return res;
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::aggregate_impl(size_type dim, std::false_type) const -> reference
+    {
+        // reference can be std::array, hence the {} initializer
+        reference res = {};
+        size_type index = axis(dim);
+        size_type size = shape(index);
+        if (dim != m_reducer->m_axes.size() - 1)
+        {
+            res = aggregate_impl(dim + 1, typename O::keep_dims());
+            for (size_type i = 1; i != size; ++i)
+            {
+                m_stepper.step(index);
+                res = m_reducer->m_merge(res, aggregate_impl(dim + 1, typename O::keep_dims()));
+            }
+        }
+        else
+        {
+            res = m_reducer->m_reduce(static_cast<reference>(m_reducer->m_init()), *m_stepper);
+            for (size_type i = 1; i != size; ++i)
+            {
+                m_stepper.step(index);
+                res = m_reducer->m_reduce(res, *m_stepper);
+            }
+        }
+        m_stepper.reset(index);
+        return res;
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::aggregate_impl(size_type dim, std::true_type) const -> reference
+    {
+        // reference can be std::array, hence the {} initializer
+        reference res = {};
+        auto ax_it = std::find(m_reducer->m_axes.begin(), m_reducer->m_axes.end(), dim);
+        if (ax_it != m_reducer->m_axes.end())
+        {
+            size_type index = dim;
+            size_type size = m_reducer->m_e.shape()[index];
+            if (ax_it != m_reducer->m_axes.end() - 1 && size != 0)
+            {
+                res = aggregate_impl(dim + 1, typename O::keep_dims());
+                for (size_type i = 1; i != size; ++i)
+                {
+                    m_stepper.step(index);
+                    res = m_reducer->m_merge(res, aggregate_impl(dim + 1, typename O::keep_dims()));
+                }
+            }
+            else
+            {
+                res = m_reducer->m_reduce(static_cast<reference>(m_reducer->m_init()), *m_stepper);
+                for (size_type i = 1; i != size; ++i)
+                {
+                    m_stepper.step(index);
+                    res = m_reducer->m_reduce(res, *m_stepper);
+                }
+            }
+            m_stepper.reset(index);
+        }
+        else
+        {
+            if (dim < m_reducer->m_e.dimension())
+            {
+                res = aggregate_impl(dim + 1, typename O::keep_dims());
+            }
+        }
+        return res;
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::get_substepper_begin() const -> substepper_type
+    {
+        return m_reducer->m_e.stepper_begin(m_reducer->m_e.shape());
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::get_dim(size_type dim) const noexcept -> size_type
+    {
+        return m_reducer->m_dim_mapping[dim];
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::shape(size_type i) const noexcept -> size_type
+    {
+        return m_reducer->m_e.shape()[i];
+    }
+
+    template <class F, class CT, class X, class O>
+    inline auto xreducer_stepper<F, CT, X, O>::axis(size_type i) const noexcept -> size_type
+    {
+        return m_reducer->m_axes[i];
+    }
+}
+
+#endif
diff --git a/include/xtensor/utils/xexception.hpp b/include/xtensor/utils/xexception.hpp
new file mode 100644
index 000000000..025836ce2
--- /dev/null
+++ b/include/xtensor/utils/xexception.hpp
@@ -0,0 +1,372 @@
+/***************************************************************************
+ * 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_EXCEPTION_HPP
+#define XTENSOR_EXCEPTION_HPP
+
+#include <iterator>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+#include <xtl/xcompare.hpp>
+#include <xtl/xsequence.hpp>
+#include <xtl/xspan_impl.hpp>
+
+#include "../core/xtensor_config.hpp"
+
+#ifdef __GNUC__
+#define XTENSOR_UNUSED_VARIABLE __attribute__((unused))
+#else
+#define XTENSOR_UNUSED_VARIABLE
+#endif
+
+namespace xt
+{
+    struct missing_type
+    {
+    };
+
+    namespace
+    {
+        missing_type XTENSOR_UNUSED_VARIABLE missing;
+    }
+
+    namespace detail
+    {
+        template <class... Args>
+        struct last_type_is_missing_impl
+            : std::is_same<missing_type, xtl::mpl::back_t<xtl::mpl::vector<Args...>>>
+        {
+        };
+
+        template <>
+        struct last_type_is_missing_impl<> : std::false_type
+        {
+        };
+
+        template <class... Args>
+        constexpr bool last_type_is_missing = last_type_is_missing_impl<Args...>::value;
+    }
+
+    /*******************
+     * broadcast_error *
+     *******************/
+
+    class broadcast_error : public std::runtime_error
+    {
+    public:
+
+        explicit broadcast_error(const char* msg)
+            : std::runtime_error(msg)
+        {
+        }
+    };
+
+    template <class S1, class S2>
+    [[noreturn]] void throw_broadcast_error(const S1& lhs, const S2& rhs);
+
+    /*********************
+     * concatenate_error *
+     *********************/
+
+    class concatenate_error : public std::runtime_error
+    {
+    public:
+
+        explicit concatenate_error(const char* msg)
+            : std::runtime_error(msg)
+        {
+        }
+    };
+
+    template <class S1, class S2>
+    [[noreturn]] void throw_concatenate_error(const S1& lhs, const S2& rhs);
+
+    /**********************************
+     * broadcast_error implementation *
+     **********************************/
+
+    namespace detail
+    {
+        template <class S1, class S2>
+        inline std::string shape_error_message(const S1& lhs, const S2& rhs)
+        {
+            std::ostringstream buf("Incompatible dimension of arrays:", std::ios_base::ate);
+
+            buf << "\n LHS shape = (";
+            using size_type1 = typename S1::value_type;
+            std::ostream_iterator<size_type1> iter1(buf, ", ");
+            std::copy(lhs.cbegin(), lhs.cend(), iter1);
+
+            buf << ")\n RHS shape = (";
+            using size_type2 = typename S2::value_type;
+            std::ostream_iterator<size_type2> iter2(buf, ", ");
+            std::copy(rhs.cbegin(), rhs.cend(), iter2);
+            buf << ")";
+
+            return buf.str();
+        }
+    }
+
+#ifdef NDEBUG
+    // Do not inline this function
+    template <class S1, class S2>
+    [[noreturn]] void throw_broadcast_error(const S1&, const S2&)
+    {
+        XTENSOR_THROW(broadcast_error, "Incompatible dimension of arrays, compile in DEBUG for more info");
+    }
+#else
+    template <class S1, class S2>
+    [[noreturn]] void throw_broadcast_error(const S1& lhs, const S2& rhs)
+    {
+        std::string msg = detail::shape_error_message(lhs, rhs);
+        XTENSOR_THROW(broadcast_error, msg.c_str());
+    }
+#endif
+
+    /************************************
+     * concatenate_error implementation *
+     ************************************/
+
+#ifdef NDEBUG
+    // Do not inline this function
+    template <class S1, class S2>
+    [[noreturn]] void throw_concatenate_error(const S1&, const S2&)
+    {
+        XTENSOR_THROW(concatenate_error, "Incompatible dimension of arrays, compile in DEBUG for more info");
+    }
+#else
+    template <class S1, class S2>
+    [[noreturn]] void throw_concatenate_error(const S1& lhs, const S2& rhs)
+    {
+        std::string msg = detail::shape_error_message(lhs, rhs);
+        XTENSOR_THROW(concatenate_error, msg.c_str());
+    }
+#endif
+
+    /*******************
+     * transpose_error *
+     *******************/
+
+    class transpose_error : public std::runtime_error
+    {
+    public:
+
+        explicit transpose_error(const char* msg)
+            : std::runtime_error(msg)
+        {
+        }
+    };
+
+    /***************
+     * check_index *
+     ***************/
+
+    template <class S, class... Args>
+    void check_index(const S& shape, Args... args);
+
+    template <class S, class It>
+    void check_element_index(const S& shape, It first, It last);
+
+    namespace detail
+    {
+        template <class S, std::size_t dim>
+        inline void check_index_impl(const S&)
+        {
+        }
+
+        template <class S, std::size_t dim>
+        inline void check_index_impl(const S&, missing_type)
+        {
+        }
+
+        template <class S, std::size_t dim, class T, class... Args>
+        inline void check_index_impl(const S& shape, T arg, Args... args)
+        {
+            if (std::size_t(arg) >= std::size_t(shape[dim]) && shape[dim] != 1)
+            {
+                XTENSOR_THROW(
+                    std::out_of_range,
+                    "index " + std::to_string(arg) + " is out of bounds for axis " + std::to_string(dim)
+                        + " with size " + std::to_string(shape[dim])
+                );
+            }
+            check_index_impl<S, dim + 1>(shape, args...);
+        }
+    }
+
+    template <class S>
+    inline void check_index(const S&)
+    {
+    }
+
+    template <class S>
+    inline void check_index(const S&, missing_type)
+    {
+    }
+
+    template <class S, class Arg, class... Args>
+    inline void check_index(const S& shape, Arg arg, Args... args)
+    {
+        constexpr std::size_t nargs = sizeof...(Args) + 1;
+        if (nargs == shape.size())
+        {
+            detail::check_index_impl<S, 0>(shape, arg, args...);
+        }
+        else if (nargs > shape.size())
+        {
+            // Too many arguments: drop the first
+            check_index(shape, args...);
+        }
+        else if (detail::last_type_is_missing<Args...>)
+        {
+            // Too few arguments & last argument xt::missing: postfix index with zeros
+            detail::check_index_impl<S, 0>(shape, arg, args...);
+        }
+        else
+        {
+            // Too few arguments: ignore the beginning of the shape
+            auto it = shape.end() - nargs;
+            detail::check_index_impl<decltype(it), 0>(it, arg, args...);
+        }
+    }
+
+    template <class S, class It>
+    inline void check_element_index(const S& shape, It first, It last)
+    {
+        using value_type = typename std::iterator_traits<It>::value_type;
+        using size_type = typename S::size_type;
+        auto dst = static_cast<size_type>(last - first);
+        It efirst = last - static_cast<std::ptrdiff_t>((std::min)(shape.size(), dst));
+        std::size_t axis = 0;
+
+        while (efirst != last)
+        {
+            if (*efirst >= value_type(shape[axis]) && shape[axis] != 1)
+            {
+                XTENSOR_THROW(
+                    std::out_of_range,
+                    "index " + std::to_string(*efirst) + " is out of bounds for axis " + std::to_string(axis)
+                        + " with size " + std::to_string(shape[axis])
+                );
+            }
+            ++efirst, ++axis;
+        }
+    }
+
+    /*******************
+     * check_dimension *
+     *******************/
+
+    template <class S, class... Args>
+    inline void check_dimension(const S& shape, Args...)
+    {
+        if (sizeof...(Args) > shape.size())
+        {
+            XTENSOR_THROW(
+                std::out_of_range,
+                "Number of arguments (" + std::to_string(sizeof...(Args))
+                    + ") is greater than the number of dimensions (" + std::to_string(shape.size()) + ")"
+            );
+        }
+    }
+
+    /*******************************
+     *  check_axis implementation  *
+     *******************************/
+
+    template <class A, class D>
+    inline void check_axis_in_dim(A axis, D dim, const char* subject = "Axis")
+    {
+        const auto sdim = static_cast<std::make_signed_t<D>>(dim);
+        if (xtl::cmp_greater_equal(axis, dim) || xtl::cmp_less(axis, -sdim))
+        {
+            XTENSOR_THROW(
+                std::out_of_range,
+                std::string(subject) + " (" + std::to_string(axis)
+                    + ") is not within the number of dimensions (" + std::to_string(dim) + ')'
+            );
+        }
+    }
+
+    /****************
+     * check_access *
+     ****************/
+
+    template <class S, class... Args>
+    inline void check_access(const S& shape, Args... args)
+    {
+        check_dimension(shape, args...);
+        check_index(shape, args...);
+    }
+
+#if (defined(XTENSOR_ENABLE_ASSERT) && !defined(XTENSOR_DISABLE_EXCEPTIONS))
+#define XTENSOR_TRY(expr) XTENSOR_TRY_IMPL(expr, __FILE__, __LINE__)
+#define XTENSOR_TRY_IMPL(expr, file, line)                                                                \
+    try                                                                                                   \
+    {                                                                                                     \
+        expr;                                                                                             \
+    }                                                                                                     \
+    catch (std::exception & e)                                                                            \
+    {                                                                                                     \
+        XTENSOR_THROW(                                                                                    \
+            std::runtime_error,                                                                           \
+            std::string(file) + ':' + std::to_string(line) + ": check failed\n\t" + std::string(e.what()) \
+        );                                                                                                \
+    }
+#else
+#define XTENSOR_TRY(expr)
+#endif
+
+#ifdef XTENSOR_ENABLE_ASSERT
+#define XTENSOR_ASSERT(expr) XTENSOR_ASSERT_IMPL(expr, __FILE__, __LINE__)
+#define XTENSOR_ASSERT_IMPL(expr, file, line)                                                      \
+    if (!(expr))                                                                                   \
+    {                                                                                              \
+        XTENSOR_THROW(                                                                             \
+            std::runtime_error,                                                                    \
+            std::string(file) + ':' + std::to_string(line) + ": assertion failed (" #expr ") \n\t" \
+        );                                                                                         \
+    }
+#else
+#define XTENSOR_ASSERT(expr)
+#endif
+
+#ifdef XTENSOR_ENABLE_CHECK_DIMENSION
+#define XTENSOR_CHECK_DIMENSION(S, ARGS) XTENSOR_TRY(check_dimension(S, ARGS))
+#else
+#define XTENSOR_CHECK_DIMENSION(S, ARGS)
+#endif
+
+#ifdef XTENSOR_ENABLE_ASSERT
+#define XTENSOR_ASSERT_MSG(expr, msg)                                                                            \
+    if (!(expr))                                                                                                 \
+    {                                                                                                            \
+        XTENSOR_THROW(                                                                                           \
+            std::runtime_error,                                                                                  \
+            std::string("Assertion error!\n") + msg + "\n  " + __FILE__ + '(' + std::to_string(__LINE__) + ")\n" \
+        );                                                                                                       \
+    }
+#else
+#define XTENSOR_ASSERT_MSG(expr, msg)
+#endif
+
+#define XTENSOR_PRECONDITION(expr, msg)                                              \
+    if (!(expr))                                                                     \
+    {                                                                                \
+        XTENSOR_THROW(                                                               \
+            std::runtime_error,                                                      \
+            std::string("Precondition violation!\n") + msg + "\n  " + __FILE__ + '(' \
+                + std::to_string(__LINE__) + ")\n"                                   \
+        );                                                                           \
+    }
+}
+#endif  // XEXCEPTION_HPP
diff --git a/include/xtensor/utils/xtensor_simd.hpp b/include/xtensor/utils/xtensor_simd.hpp
new file mode 100644
index 000000000..59816114b
--- /dev/null
+++ b/include/xtensor/utils/xtensor_simd.hpp
@@ -0,0 +1,336 @@
+/***************************************************************************
+ * 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_SIMD_HPP
+#define XTENSOR_SIMD_HPP
+
+#include <vector>
+
+#include <xtl/xdynamic_bitset.hpp>
+
+#include "../utils/xutils.hpp"
+
+#ifdef XTENSOR_USE_XSIMD
+
+#include <xsimd/xsimd.hpp>
+// #include <xsimd/memory/xsimd_load_store.hpp>
+
+#if defined(_MSV_VER) && (_MSV_VER < 1910)
+template <class T, class A>
+inline xsimd::batch_bool<T, A> isnan(const xsimd::batch<T, A>& b)
+{
+    return xsimd::isnan(b);
+}
+#endif
+
+namespace xt_simd
+{
+    template <class T, std::size_t A>
+    using aligned_allocator = xsimd::aligned_allocator<T, A>;
+
+    using aligned_mode = xsimd::aligned_mode;
+    using unaligned_mode = xsimd::unaligned_mode;
+
+    template <class A>
+    using allocator_alignment = xsimd::allocator_alignment<A>;
+
+    template <class A>
+    using allocator_alignment_t = xsimd::allocator_alignment_t<A>;
+
+    template <class C>
+    using container_alignment = xsimd::container_alignment<C>;
+
+    template <class C>
+    using container_alignment_t = xsimd::container_alignment_t<C>;
+
+    template <class T>
+    using simd_traits = xsimd::simd_traits<T>;
+
+    template <class T>
+    using revert_simd_traits = xsimd::revert_simd_traits<T>;
+
+    template <class T>
+    using simd_type = xsimd::simd_type<T>;
+
+    template <class T>
+    using simd_bool_type = xsimd::simd_bool_type<T>;
+
+    template <class T>
+    using revert_simd_type = xsimd::revert_simd_type<T>;
+
+    template <class T1, class T2>
+    using simd_return_type = xsimd::simd_return_type<T1, T2>;
+
+    using xsimd::broadcast_as;
+    using xsimd::get_alignment_offset;
+    using xsimd::load_as;
+    using xsimd::select;
+    using xsimd::store_as;
+
+    template <class V>
+    using is_batch_bool = xsimd::is_batch_bool<V>;
+
+    template <class V>
+    using is_batch_complex = xsimd::is_batch_complex<V>;
+
+    template <class T1, class T2>
+    using simd_condition = xsimd::detail::simd_condition<T1, T2>;
+}
+
+#else  // XTENSOR_USE_XSIMD
+
+namespace xt_simd
+{
+    template <class T, std::size_t A>
+    class aligned_allocator;
+
+    struct aligned_mode
+    {
+    };
+
+    struct unaligned_mode
+    {
+    };
+
+    template <class A>
+    struct allocator_alignment
+    {
+        using type = unaligned_mode;
+    };
+
+    template <class A>
+    using allocator_alignment_t = typename allocator_alignment<A>::type;
+
+    template <class C>
+    struct container_alignment
+    {
+        using type = unaligned_mode;
+    };
+
+    template <class C>
+    using container_alignment_t = typename container_alignment<C>::type;
+
+    template <class T>
+    struct simd_traits
+    {
+        using type = T;
+        using bool_type = bool;
+        using batch_bool = bool;
+        static constexpr std::size_t size = 1;
+    };
+
+    template <class T>
+    struct revert_simd_traits
+    {
+        using type = T;
+        static constexpr std::size_t size = simd_traits<type>::size;
+    };
+
+    template <class T>
+    using simd_type = typename simd_traits<T>::type;
+
+    template <class T>
+    using simd_bool_type = typename simd_traits<T>::bool_type;
+
+    template <class T>
+    using revert_simd_type = typename revert_simd_traits<T>::type;
+
+    template <class R, class T>
+    inline simd_type<R> broadcast_as(const T& value)
+    {
+        return value;
+    }
+
+    template <class R, class T>
+    inline simd_type<R> load_as(const T* src, aligned_mode)
+    {
+        return *src;
+    }
+
+    template <class R, class T>
+    inline simd_type<R> load_as(const T* src, unaligned_mode)
+    {
+        return *src;
+    }
+
+    template <class R, class T>
+    inline void store_as(R* dst, const simd_type<T>& src, aligned_mode)
+    {
+        *dst = src;
+    }
+
+    template <class R, class T>
+    inline void store_as(R* dst, const simd_type<T>& src, unaligned_mode)
+    {
+        *dst = src;
+    }
+
+    template <class T>
+    inline T select(bool cond, const T& t1, const T& t2)
+    {
+        return cond ? t1 : t2;
+    }
+
+    template <class T>
+    inline std::size_t get_alignment_offset(const T* /*p*/, std::size_t size, std::size_t /*block_size*/)
+    {
+        return size;
+    }
+
+    template <class T1, class T2>
+    using simd_return_type = simd_type<T2>;
+
+    template <class V>
+    struct is_batch_bool : std::false_type
+    {
+    };
+
+    template <class V>
+    struct is_batch_complex : std::false_type
+    {
+    };
+
+    template <class T1, class T2>
+    struct simd_condition : std::true_type
+    {
+    };
+}
+
+#endif  // XTENSOR_USE_XSIMD
+
+namespace xt
+{
+    using xt_simd::aligned_mode;
+    using xt_simd::unaligned_mode;
+
+    struct inner_aligned_mode
+    {
+    };
+
+    namespace detail
+    {
+        template <class A1, class A2>
+        struct driven_align_mode_impl
+        {
+            using type = std::conditional_t<std::is_same<A1, A2>::value, A1, ::xt_simd::unaligned_mode>;
+        };
+
+        template <class A>
+        struct driven_align_mode_impl<inner_aligned_mode, A>
+        {
+            using type = A;
+        };
+    }
+
+    template <class A1, class A2>
+    struct driven_align_mode
+    {
+        using type = typename detail::driven_align_mode_impl<A1, A2>::type;
+    };
+
+    template <class A1, class A2>
+    using driven_align_mode_t = typename detail::driven_align_mode_impl<A1, A2>::type;
+
+    namespace detail
+    {
+        template <class E, class T, class = void>
+        struct has_load_simd : std::false_type
+        {
+        };
+
+        template <class E, class T>
+        struct has_load_simd<
+            E,
+            T,
+            void_t<decltype(std::declval<E>().template load_simd<aligned_mode, T>(typename E::size_type(0)))>>
+            : std::true_type
+        {
+        };
+
+        template <class E, class T, bool B = xt_simd::simd_condition<typename E::value_type, T>::value>
+        struct has_simd_interface_impl : has_load_simd<E, T>
+        {
+        };
+
+        template <class E, class T>
+        struct has_simd_interface_impl<E, T, false> : std::false_type
+        {
+        };
+    }
+
+    template <class E, class T = typename std::decay_t<E>::value_type>
+    struct has_simd_interface : detail::has_simd_interface_impl<E, T>
+    {
+    };
+
+    template <class E>
+    concept has_simd_interface_concept = has_simd_interface<E>::value;
+
+    template <class T>
+    struct has_simd_type : std::integral_constant<bool, !std::is_same<T, xt_simd::simd_type<T>>::value>
+    {
+    };
+
+    namespace detail
+    {
+        template <class F, class B, class = void>
+        struct has_simd_apply_impl : std::false_type
+        {
+        };
+
+        template <class F, class B>
+        struct has_simd_apply_impl<F, B, void_t<decltype(&F::template simd_apply<B>)>> : std::true_type
+        {
+        };
+    }
+
+    template <class F, class B>
+    struct has_simd_apply : detail::has_simd_apply_impl<F, B>
+    {
+    };
+
+    template <class T>
+    using bool_load_type = std::conditional_t<std::is_same<T, bool>::value, uint8_t, T>;
+
+    template <class T>
+    struct forbid_simd : std::false_type
+    {
+    };
+
+    template <class A>
+    struct forbid_simd<std::vector<bool, A>> : std::true_type
+    {
+    };
+
+    template <class A>
+    struct forbid_simd<const std::vector<bool, A>> : std::true_type
+    {
+    };
+
+    template <class B, class A>
+    struct forbid_simd<xtl::xdynamic_bitset<B, A>> : std::true_type
+    {
+    };
+
+    template <class B, class A>
+    struct forbid_simd<const xtl::xdynamic_bitset<B, A>> : std::true_type
+    {
+    };
+
+    template <class C, class T1, class T2>
+    struct container_simd_return_type
+        : std::enable_if<!forbid_simd<C>::value, xt_simd::simd_return_type<T1, bool_load_type<T2>>>
+    {
+    };
+
+    template <class C, class T1, class T2>
+    using container_simd_return_type_t = typename container_simd_return_type<C, T1, T2>::type;
+}
+
+#endif
diff --git a/include/xtensor/utils/xutils.hpp b/include/xtensor/utils/xutils.hpp
new file mode 100644
index 000000000..ed4a04f48
--- /dev/null
+++ b/include/xtensor/utils/xutils.hpp
@@ -0,0 +1,935 @@
+/***************************************************************************
+ * 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_UTILS_HPP
+#define XTENSOR_UTILS_HPP
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <initializer_list>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <xtl/xfunctional.hpp>
+#include <xtl/xmeta_utils.hpp>
+#include <xtl/xsequence.hpp>
+#include <xtl/xtype_traits.hpp>
+
+#include "../core/xtensor_config.hpp"
+
+namespace xt
+{
+    /****************
+     * declarations *
+     ****************/
+
+    template <class T>
+    struct remove_class;
+
+    /*template <class F, class... T>
+    void for_each(F&& f, std::tuple<T...>& t) noexcept(implementation_dependent);*/
+
+    /*template <class F, class R, class... T>
+    R accumulate(F&& f, R init, const std::tuple<T...>& t) noexcept(implementation_dependent);*/
+
+    template <std::size_t I, class... Args>
+    constexpr decltype(auto) argument(Args&&... args) noexcept;
+
+    template <class R, class F, class... S>
+    R apply(std::size_t index, F&& func, const std::tuple<S...>& s) noexcept(noexcept(func(std::get<0>(s))));
+
+    template <class T, class S>
+    void nested_copy(T&& iter, const S& s);
+
+    template <class T, class S>
+    void nested_copy(T&& iter, std::initializer_list<S> s);
+
+    template <class C>
+    bool resize_container(C& c, typename C::size_type size);
+
+    template <class T, std::size_t N>
+    bool resize_container(std::array<T, N>& a, typename std::array<T, N>::size_type size);
+
+    template <std::size_t... I>
+    class fixed_shape;
+
+    template <std::size_t... I>
+    bool resize_container(fixed_shape<I...>& a, std::size_t size);
+
+    template <class X, class C>
+    struct rebind_container;
+
+    template <class X, class C>
+    using rebind_container_t = typename rebind_container<X, C>::type;
+
+    std::size_t normalize_axis(std::size_t dim, std::ptrdiff_t axis);
+
+    // gcc 4.9 is affected by C++14 defect CGW 1558
+    // see http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
+    template <class... T>
+    struct make_void
+    {
+        using type = void;
+    };
+
+    template <class... T>
+    using void_t = typename make_void<T...>::type;
+
+    // This is used for non existent types (e.g. storage for some expressions
+    // like generators)
+    struct invalid_type
+    {
+    };
+
+    template <class... T>
+    struct make_invalid_type
+    {
+        using type = invalid_type;
+    };
+
+    template <class T, class R>
+    using disable_integral_t = std::enable_if_t<!xtl::is_integral<T>::value, R>;
+
+    /***************************************
+     * is_specialization_of implementation *
+     ***************************************/
+
+    template <template <class...> class TT, class T>
+    struct is_specialization_of : std::false_type
+    {
+    };
+
+    template <template <class...> class TT, class... Ts>
+    struct is_specialization_of<TT, TT<Ts...>> : std::true_type
+    {
+    };
+
+    /*******************************
+     * remove_class implementation *
+     *******************************/
+
+    template <class T>
+    struct remove_class
+    {
+    };
+
+    template <class C, class R, class... Args>
+    struct remove_class<R (C::*)(Args...)>
+    {
+        typedef R type(Args...);
+    };
+
+    template <class C, class R, class... Args>
+    struct remove_class<R (C::*)(Args...) const>
+    {
+        typedef R type(Args...);
+    };
+
+    template <class T>
+    using remove_class_t = typename remove_class<T>::type;
+
+    /***************************
+     * for_each implementation *
+     ***************************/
+
+    namespace detail
+    {
+        template <class F, size_t... I, class... Ts>
+        void for_each(F&& f, std::tuple<Ts...>& t, std::index_sequence<I...>) noexcept(
+            (noexcept(f(std::get<I>(t))) && ...)
+        )
+        {
+            (f(std::get<I>(t)), ...);
+        }
+
+        template <class F, size_t... I, class... Ts>
+        void for_each(F&& f, const std::tuple<Ts...>& t, std::index_sequence<I...>) noexcept(
+            (noexcept(f(std::get<I>(t))) && ...)
+        )
+        {
+            (f(std::get<I>(t)), ...);
+        }
+    }
+
+    template <class F, class... Ts>
+    inline void for_each(F&& f, std::tuple<Ts...>& t) noexcept(
+        noexcept(detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{}))
+    )
+    {
+        detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{});
+    }
+
+    template <class F, class... Ts>
+    inline void for_each(F&& f, const std::tuple<Ts...>& t) noexcept(
+        noexcept(detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{}))
+    )
+    {
+        detail::for_each(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>{});
+    }
+
+    /*****************************
+     * accumulate implementation *
+     *****************************/
+
+    /// @cond DOXYGEN_INCLUDE_noexcept
+
+    namespace detail
+    {
+        template <class F, class R, class... T, size_t... I>
+        R accumulate_impl(F&& f, R init, const std::tuple<T...>& t, std::index_sequence<I...> /*I*/) noexcept(
+            (noexcept(f(init, std::get<I>(t))) && ...)
+        )
+        {
+            R res = init;
+            auto wrapper = [&](const auto& i, const auto& j)
+            {
+                res = f(i, j);
+            };
+            (wrapper(res, std::get<I>(t)), ...);
+            return res;
+        }
+    }
+
+    template <class F, class R, class... T>
+    inline R accumulate(F&& f, R init, const std::tuple<T...>& t) noexcept(
+        noexcept(detail::accumulate_impl(std::forward<F>(f), init, t, std::make_index_sequence<sizeof...(T)>{}))
+    )
+    {
+        return detail::accumulate_impl(std::forward<F>(f), init, t, std::make_index_sequence<sizeof...(T)>{});
+    }
+
+    /// @endcond
+
+    /***************************
+     * argument implementation *
+     ***************************/
+
+    namespace detail
+    {
+        template <std::size_t I>
+        struct getter
+        {
+            template <class Arg, class... Args>
+            static constexpr decltype(auto) get(Arg&& /*arg*/, Args&&... args) noexcept
+            {
+                return getter<I - 1>::get(std::forward<Args>(args)...);
+            }
+        };
+
+        template <>
+        struct getter<0>
+        {
+            template <class Arg, class... Args>
+            static constexpr Arg&& get(Arg&& arg, Args&&... /*args*/) noexcept
+            {
+                return std::forward<Arg>(arg);
+            }
+        };
+    }
+
+    template <std::size_t I, class... Args>
+    constexpr decltype(auto) argument(Args&&... args) noexcept
+    {
+        static_assert(I < sizeof...(Args), "I should be lesser than sizeof...(Args)");
+        return detail::getter<I>::get(std::forward<Args>(args)...);
+    }
+
+    /************************
+     * apply implementation *
+     ************************/
+
+    template <class R, class F, class... S>
+    inline R
+    apply(std::size_t index, F&& func, const std::tuple<S...>& s) noexcept(noexcept(func(std::get<0>(s))))
+    {
+        XTENSOR_ASSERT(sizeof...(S) > index);
+        return std::apply(
+            [&](const S&... args) -> R
+            {
+                auto f_impl = [&](auto&& self, auto&& i, auto&& h, auto&&... t) -> R
+                {
+                    if (i == index)
+                    {
+                        return static_cast<R>(func(h));
+                    }
+                    if constexpr (sizeof...(t) > 0)
+                    {
+                        return self(self, std::size_t{i + 1}, t...);
+                    }
+                    return R{};
+                };
+                return f_impl(f_impl, std::size_t{0}, args...);
+            },
+            s
+        );
+    }
+
+    /***************************
+     * nested_initializer_list *
+     ***************************/
+
+    template <class T, std::size_t I>
+    struct nested_initializer_list
+    {
+        using type = std::initializer_list<typename nested_initializer_list<T, I - 1>::type>;
+    };
+
+    template <class T>
+    struct nested_initializer_list<T, 0>
+    {
+        using type = T;
+    };
+
+    template <class T, std::size_t I>
+    using nested_initializer_list_t = typename nested_initializer_list<T, I>::type;
+
+    /******************************
+     * nested_copy implementation *
+     ******************************/
+
+    template <class T, class S>
+    inline void nested_copy(T&& iter, const S& s)
+    {
+        *iter++ = s;
+    }
+
+    template <class T, class S>
+    inline void nested_copy(T&& iter, std::initializer_list<S> s)
+    {
+        for (auto it = s.begin(); it != s.end(); ++it)
+        {
+            nested_copy(std::forward<T>(iter), *it);
+        }
+    }
+
+    /***********************************
+     * resize_container implementation *
+     ***********************************/
+    template <class C>
+    inline bool resize_container(C& c, typename C::size_type size)
+    {
+        c.resize(size);
+        return true;
+    }
+
+    template <class T, std::size_t N>
+    inline bool resize_container(std::array<T, N>& /*a*/, typename std::array<T, N>::size_type size)
+    {
+        return size == N;
+    }
+
+    template <std::size_t... I>
+    inline bool resize_container(xt::fixed_shape<I...>&, std::size_t size)
+    {
+        return sizeof...(I) == size;
+    }
+
+    /*********************************
+     * normalize_axis implementation *
+     *********************************/
+
+    // scalar normalize axis
+    inline std::size_t normalize_axis(std::size_t dim, std::ptrdiff_t axis)
+    {
+        return axis < 0 ? static_cast<std::size_t>(static_cast<std::ptrdiff_t>(dim) + axis)
+                        : static_cast<std::size_t>(axis);
+    }
+
+    template <class E, class C>
+    inline std::enable_if_t<
+        !xtl::is_integral<std::decay_t<C>>::value && xtl::is_signed<typename std::decay_t<C>::value_type>::value,
+        rebind_container_t<std::size_t, std::decay_t<C>>>
+    normalize_axis(E& expr, C&& axes)
+    {
+        rebind_container_t<std::size_t, std::decay_t<C>> res;
+        resize_container(res, axes.size());
+
+        for (std::size_t i = 0; i < axes.size(); ++i)
+        {
+            res[i] = normalize_axis(expr.dimension(), axes[i]);
+        }
+
+        XTENSOR_ASSERT(std::all_of(
+            res.begin(),
+            res.end(),
+            [&expr](auto ax_el)
+            {
+                return ax_el < expr.dimension();
+            }
+        ));
+
+        return res;
+    }
+
+    template <class C, class E>
+    inline std::enable_if_t<
+        !xtl::is_integral<std::decay_t<C>>::value && std::is_unsigned<typename std::decay_t<C>::value_type>::value,
+        C&&>
+    normalize_axis(E& expr, C&& axes)
+    {
+        static_cast<void>(expr);
+        XTENSOR_ASSERT(std::all_of(
+            axes.begin(),
+            axes.end(),
+            [&expr](auto ax_el)
+            {
+                return ax_el < expr.dimension();
+            }
+        ));
+        return std::forward<C>(axes);
+    }
+
+    template <class R, class E, class C>
+    inline auto forward_normalize(E& expr, C&& axes)
+        -> std::enable_if_t<xtl::is_signed<std::decay_t<decltype(*std::begin(axes))>>::value, R>
+    {
+        R res;
+        xt::resize_container(res, std::size(axes));
+        auto dim = expr.dimension();
+        std::transform(
+            std::begin(axes),
+            std::end(axes),
+            std::begin(res),
+            [&dim](auto ax_el)
+            {
+                return normalize_axis(dim, ax_el);
+            }
+        );
+
+        XTENSOR_ASSERT(std::all_of(
+            res.begin(),
+            res.end(),
+            [&expr](auto ax_el)
+            {
+                return ax_el < expr.dimension();
+            }
+        ));
+
+        return res;
+    }
+
+    template <class R, class E, class C>
+    inline auto forward_normalize(E& expr, C&& axes) -> std::enable_if_t<
+        !xtl::is_signed<std::decay_t<decltype(*std::begin(axes))>>::value && !std::is_same<R, std::decay_t<C>>::value,
+        R>
+    {
+        static_cast<void>(expr);
+
+        R res;
+        xt::resize_container(res, std::size(axes));
+        std::copy(std::begin(axes), std::end(axes), std::begin(res));
+        XTENSOR_ASSERT(std::all_of(
+            res.begin(),
+            res.end(),
+            [&expr](auto ax_el)
+            {
+                return ax_el < expr.dimension();
+            }
+        ));
+        return res;
+    }
+
+    template <class R, class E, class C>
+    inline auto forward_normalize(E& expr, C&& axes) -> std::enable_if_t<
+        !xtl::is_signed<std::decay_t<decltype(*std::begin(axes))>>::value && std::is_same<R, std::decay_t<C>>::value,
+        R&&>
+    {
+        static_cast<void>(expr);
+        XTENSOR_ASSERT(std::all_of(
+            std::begin(axes),
+            std::end(axes),
+            [&expr](auto ax_el)
+            {
+                return ax_el < expr.dimension();
+            }
+        ));
+        return std::move(axes);
+    }
+
+    /******************
+     * get_value_type *
+     ******************/
+
+    template <class T>
+    struct get_value_type
+    {
+        using type = T;
+    };
+
+    template <class T>
+        requires requires { typename T::value_type; }
+    struct get_value_type<T>
+    {
+        using type = typename T::value_type;
+    };
+
+    template <class T>
+    using get_value_type_t = typename get_value_type<T>::type;
+
+    /**********************
+     * get implementation *
+     **********************/
+
+    // When subclassing from std::tuple not all compilers are able to correctly instantiate get
+    // See here: https://stackoverflow.com/a/37188019/2528668
+    template <std::size_t I, template <typename... Args> class T, typename... Args>
+    decltype(auto) get(T<Args...>&& v)
+    {
+        return std::get<I>(static_cast<std::tuple<Args...>&&>(v));
+    }
+
+    template <std::size_t I, template <typename... Args> class T, typename... Args>
+    decltype(auto) get(T<Args...>& v)
+    {
+        return std::get<I>(static_cast<std::tuple<Args...>&>(v));
+    }
+
+    template <std::size_t I, template <typename... Args> class T, typename... Args>
+    decltype(auto) get(const T<Args...>& v)
+    {
+        return std::get<I>(static_cast<const std::tuple<Args...>&>(v));
+    }
+
+    /**************************
+     * to_array implementation *
+     ***************************/
+
+    namespace detail
+    {
+        template <class T, std::size_t N, std::size_t... I>
+        constexpr std::array<std::remove_cv_t<T>, N> to_array_impl(T (&a)[N], std::index_sequence<I...>)
+        {
+            return {{a[I]...}};
+        }
+    }
+
+    template <class T, std::size_t N>
+    constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N])
+    {
+        return detail::to_array_impl(a, std::make_index_sequence<N>{});
+    }
+
+    /***********************************
+     * container_expression / data_interface_expression / strided_expression / iterable_expression *
+     ************************************************************************************************/
+
+    template <class T>
+    struct xcontainer_inner_types;
+
+    template <class T>
+    concept container_expression = requires {
+        typename xcontainer_inner_types<T>::storage_type;
+        requires !std::is_same_v<typename std::remove_cv<typename xcontainer_inner_types<T>::storage_type>::type, invalid_type>;
+    };
+
+    template <class T>
+    using get_storage_type_t = typename xcontainer_inner_types<T>::storage_type;
+
+    template <class E>
+    concept data_interface_expression = requires { std::declval<E>().data(); };
+
+    template <class E>
+    concept strided_expression = requires { std::declval<E>().strides(); };
+
+    template <class E>
+    concept iterable_expression = requires { std::declval<E>().begin(); };
+
+    /*************************
+     * conditional type cast *
+     *************************/
+
+    template <bool condition, class T>
+    struct conditional_cast_functor;
+
+    template <class T>
+    struct conditional_cast_functor<false, T> : public xtl::identity
+    {
+    };
+
+    template <class T>
+    struct conditional_cast_functor<true, T>
+    {
+        template <class U>
+        inline auto operator()(U&& u) const
+        {
+            return static_cast<T>(std::forward<U>(u));
+        }
+    };
+
+    /**
+     * @brief Perform a type cast when a condition is true.
+     * If <tt>condition</tt> is true, return <tt>static_cast<T>(u)</tt>,
+     * otherwise return <tt>u</tt> unchanged. This is useful when an unconditional
+     * static_cast would force undesired type conversions in some situations where
+     * an error or warning would be desired. The condition determines when the
+     * explicit cast is ok.
+     */
+    template <bool condition, class T, class U>
+    inline auto conditional_cast(U&& u)
+    {
+        return conditional_cast_functor<condition, T>()(std::forward<U>(u));
+    }
+
+    /**********************
+     * tracking allocator *
+     **********************/
+
+    namespace alloc_tracking
+    {
+        inline bool& enabled()
+        {
+            static bool enabled;
+            return enabled;
+        }
+
+        inline void enable()
+        {
+            enabled() = true;
+        }
+
+        inline void disable()
+        {
+            enabled() = false;
+        }
+
+        enum policy
+        {
+            print,
+            assert
+        };
+    }
+
+    template <class T, class A, alloc_tracking::policy P>
+    struct tracking_allocator : private A
+    {
+        using base_type = A;
+        using value_type = typename 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;
+
+        tracking_allocator() = default;
+
+        T* allocate(std::size_t n)
+        {
+            if (alloc_tracking::enabled())
+            {
+                if (P == alloc_tracking::print)
+                {
+                    std::cout << "xtensor allocating: " << n << "" << std::endl;
+                }
+                else if (P == alloc_tracking::assert)
+                {
+                    XTENSOR_THROW(
+                        std::runtime_error,
+                        "xtensor allocation of " + std::to_string(n) + " elements detected"
+                    );
+                }
+            }
+            return base_type::allocate(n);
+        }
+
+        using base_type::deallocate;
+
+// Construct and destroy are removed in --std=c++-20
+#if ((defined(__cplusplus) && __cplusplus < 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG < 202002L))
+        using base_type::construct;
+        using base_type::destroy;
+#endif
+
+        template <class U>
+        struct rebind
+        {
+            using traits = std::allocator_traits<A>;
+            using other = tracking_allocator<U, typename traits::template rebind_alloc<U>, P>;
+        };
+    };
+
+    template <class T, class AT, alloc_tracking::policy PT, class U, class AU, alloc_tracking::policy PU>
+    inline bool operator==(const tracking_allocator<T, AT, PT>&, const tracking_allocator<U, AU, PU>&)
+    {
+        return std::is_same<AT, AU>::value;
+    }
+
+    template <class T, class AT, alloc_tracking::policy PT, class U, class AU, alloc_tracking::policy PU>
+    inline bool operator!=(const tracking_allocator<T, AT, PT>& a, const tracking_allocator<U, AU, PU>& b)
+    {
+        return !(a == b);
+    }
+
+    /*****************
+     * assignable_to *
+     ******************/
+
+    template <class E1, class E2>
+    concept assignable_to_expression = requires { std::declval<const E2&>().assign_to(std::declval<E1&>()); };
+
+    /*************************************
+     * overlapping_memory_checker_traits *
+     *************************************/
+
+    template <class T>
+    concept addressable_to_expression = requires { std::addressof(*std::declval<T>().begin()); };
+
+    struct memory_range
+    {
+        // Checking pointer overlap is more correct in integer values,
+        // for more explanation check https://devblogs.microsoft.com/oldnewthing/20170927-00/?p=97095
+        const uintptr_t m_first = 0;
+        const uintptr_t m_last = 0;
+
+        explicit memory_range() = default;
+
+        template <class T>
+        explicit memory_range(T* first, T* last)
+            : m_first(reinterpret_cast<uintptr_t>(last < first ? last : first))
+            , m_last(reinterpret_cast<uintptr_t>(last < first ? first : last))
+        {
+        }
+
+        template <class T>
+        bool overlaps(T* first, T* last) const
+        {
+            if (first <= last)
+            {
+                return reinterpret_cast<uintptr_t>(first) <= m_last
+                       && reinterpret_cast<uintptr_t>(last) >= m_first;
+            }
+            else
+            {
+                return reinterpret_cast<uintptr_t>(last) <= m_last
+                       && reinterpret_cast<uintptr_t>(first) >= m_first;
+            }
+        }
+    };
+
+    template <class E, class Enable = void>
+    struct overlapping_memory_checker_traits
+    {
+        static bool check_overlap(const E&, const memory_range&)
+        {
+            return true;
+        }
+    };
+
+    template <class E>
+    struct overlapping_memory_checker_traits<E, std::enable_if_t<addressable_to_expression<E>>>
+    {
+        static bool check_overlap(const E& expr, const memory_range& dst_range)
+        {
+            if (expr.size() == 0)
+            {
+                return false;
+            }
+            else
+            {
+                return dst_range.overlaps(std::addressof(*expr.begin()), std::addressof(*expr.rbegin()));
+            }
+        }
+    };
+
+    struct overlapping_memory_checker_base
+    {
+        memory_range m_dst_range;
+
+        explicit overlapping_memory_checker_base() = default;
+
+        explicit overlapping_memory_checker_base(memory_range dst_memory_range)
+            : m_dst_range(std::move(dst_memory_range))
+        {
+        }
+
+        template <class E>
+        bool check_overlap(const E& expr) const
+        {
+            if (!m_dst_range.m_first || !m_dst_range.m_last)
+            {
+                return false;
+            }
+            else
+            {
+                return overlapping_memory_checker_traits<E>::check_overlap(expr, m_dst_range);
+            }
+        }
+    };
+
+    template <class Dst, class Enable = void>
+    struct overlapping_memory_checker : overlapping_memory_checker_base
+    {
+        explicit overlapping_memory_checker(const Dst&)
+            : overlapping_memory_checker_base()
+        {
+        }
+    };
+
+    template <class Dst>
+    struct overlapping_memory_checker<Dst, std::enable_if_t<addressable_to_expression<Dst>>>
+        : overlapping_memory_checker_base
+    {
+        explicit overlapping_memory_checker(const Dst& aDst)
+            : overlapping_memory_checker_base(
+                [&]()
+                {
+                    if (aDst.size() == 0)
+                    {
+                        return memory_range();
+                    }
+                    else
+                    {
+                        return memory_range(std::addressof(*aDst.begin()), std::addressof(*aDst.rbegin()));
+                    }
+                }()
+            )
+        {
+        }
+    };
+
+    template <class Dst>
+    auto make_overlapping_memory_checker(const Dst& a_dst)
+    {
+        return overlapping_memory_checker<Dst>(a_dst);
+    }
+
+    /********************
+     * rebind_container *
+     ********************/
+
+    template <class X, template <class, class> class C, class T, class A>
+    struct rebind_container<X, C<T, A>>
+    {
+        using traits = std::allocator_traits<A>;
+        using allocator = typename traits::template rebind_alloc<X>;
+        using type = C<X, allocator>;
+    };
+
+// Workaround for rebind_container problems when C++17 feature is enabled
+#ifdef __cpp_template_template_args
+    template <class X, class T, std::size_t N>
+    struct rebind_container<X, std::array<T, N>>
+    {
+        using type = std::array<X, N>;
+    };
+#else
+    template <class X, template <class, std::size_t> class C, class T, std::size_t N>
+    struct rebind_container<X, C<T, N>>
+    {
+        using type = C<X, N>;
+    };
+#endif
+
+    /***************
+     * get_strides *
+     ***************/
+
+    template <class CP, class O, class A>
+    class xbuffer_adaptor;
+
+    namespace detail
+    {
+        template <class>
+        inline constexpr bool is_fixed_shape_v = false;
+
+        template <std::size_t... I>
+        inline constexpr bool is_fixed_shape_v<fixed_shape<I...>> = true;
+
+        template <class>
+        inline constexpr bool is_xbuffer_adaptor_v = false;
+
+        template <class CP, class O, class A>
+        inline constexpr bool is_xbuffer_adaptor_v<xbuffer_adaptor<CP, O, A>> = true;
+
+        template <class S>
+        concept fixed_shape_type = is_fixed_shape_v<S>;
+
+        template <class S>
+        concept xbuffer_adaptor_type = is_xbuffer_adaptor_v<S>;
+    }
+
+    // Defers strides-type mapping so callers can use it inside std::conditional_t<cond, A, B>::type
+    // without evaluating both branches (see xshared_expression in xexpression.hpp).
+    template <class S>
+    struct get_strides_type
+    {
+        using type = typename rebind_container<std::ptrdiff_t, S>::type;
+    };
+
+    template <detail::fixed_shape_type S>
+    struct get_strides_type<S>
+    {
+        // TODO we could compute the strides statically here.
+        //  But we'll need full constexpr support to have a
+        //  homogenous ``compute_strides`` method
+        using type = std::array<std::ptrdiff_t, S::size()>;
+    };
+
+    template <detail::xbuffer_adaptor_type S>
+    struct get_strides_type<S>
+    {
+        // In bindings this mapping is called by reshape_view with an inner shape of type
+        // xbuffer_adaptor.
+        // Since we cannot create a buffer adaptor holding data, we map it to an std::vector.
+        using type = std::vector<typename S::value_type, typename S::allocator_type>;
+    };
+
+    template <class S>
+    using get_strides_t = typename get_strides_type<S>::type;
+
+    /*******************
+     * inner_reference *
+     *******************/
+
+    template <class ST>
+    using inner_reference_t = std::conditional_t<
+        std::is_const<std::remove_reference_t<ST>>::value,
+        typename std::decay_t<ST>::const_reference,
+        typename std::decay_t<ST>::reference>;
+
+    /************
+     * get_rank *
+     ************/
+
+    // Define the requirement
+    template <typename T>
+    concept HasRank = requires {
+        T::rank;  // Checks if T::rank exists as a type nested member
+    };
+
+    template <class E>
+    constexpr std::size_t has_rank()
+    {
+        return HasRank<E>;
+    }
+
+    template <class E>
+    constexpr std::size_t get_rank()
+    {
+        if constexpr (HasRank<std::decay_t<E>>)
+        {
+            return std::decay_t<E>::rank;
+        }
+        return SIZE_MAX;
+    }
+
+    template <class E>
+    constexpr std::size_t has_fixed_rank()
+    {
+        return get_rank<E>() != SIZE_MAX;
+    }
+}
+
+#endif
diff --git a/include/xtensor/views/index_mapper.hpp b/include/xtensor/views/index_mapper.hpp
new file mode 100644
index 000000000..d445ac1ec
--- /dev/null
+++ b/include/xtensor/views/index_mapper.hpp
@@ -0,0 +1,551 @@
+/***************************************************************************
+ * 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 access_t
+     * @brief Defines the access policy for the underlying container.
+     */
+    enum class access_t
+    {
+        SAFE,   ///< Use .at() accessor (bounds checked).
+        UNSAFE  ///< Use operator() accessor (no bounds checking).
+    };
+
+    /**
+     * @class index_mapper
+     * @brief A helper class for mapping indices between views and their underlying containers.
+     *
+     * The `index_mapper` class provides functionality to convert indices from a view's coordinate system
+     * to the corresponding indices in the underlying container. This is particularly useful for views
+     * that contain integral slices (fixed indices), as these slices reduce the dimensionality of the view.
+     *
+     * @tparam UndefinedView The primary template parameter, specialized for `xt::xview` types.
+     *
+     * @note This class is specialized for `xt::xview<UnderlyingContainer, Slices...>` types only.
+     *       Other view types will trigger a compilation error.
+     *
+     * @example
+     * @code
+     * 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)
+     * @endcode
+     */
+    template <class UnderlyingContainer, class... Slices>
+    class index_mapper<xt::xview<UnderlyingContainer, Slices...>>
+    {
+    public:
+
+        /// @brief The view type this mapper works with
+        using view_type = xt::xview<UnderlyingContainer, Slices...>;
+
+        /// @brief Reference type of the underlying view.
+        using reference = typename xt::xview<UnderlyingContainer, Slices...>::reference;
+
+        /// @brief Const reference type of the underlying view.
+        using const_reference = typename xt::xview<UnderlyingContainer, Slices...>::const_reference;
+
+        /// @brief Total number of explicitly passed slices in the view
+        static constexpr size_t n_slices = sizeof...(Slices);
+
+        /// @brief Number of slices that are integral constants (fixed indices)
+        static constexpr size_t nb_integral_slices = (std::is_integral_v<Slices> + ...);
+
+        /// @brief Number of slices that are xt::newaxis (insert a  dimension)
+        static constexpr size_t nb_new_axis_slices = (xt::detail::is_newaxis_v<Slices> + ...);
+
+        /**
+         * Compute how many indices are needed to address the underlying container
+         * when given N indices in the view.
+         */
+        template <std::integral... Indices>
+        static constexpr size_t n_indices_full_v = size_t(sizeof...(Indices) + nb_integral_slices);
+
+        /**
+         * @brief Map view indices to container reference using UNSAFE access.
+         * @param container The source container.
+         * @param view The view defining the mapping.
+         * @param indices The indices in view-space.
+         * @return Reference to the element in the container.
+         */
+        template <std::integral... Indices>
+        reference map(UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+        /**
+         * @brief Map view indices to container const_reference using UNSAFE access.
+         * @param container The source container.
+         * @param view The view defining the mapping.
+         * @param indices The indices in view-space.
+         * @return Reference to the element in the container.
+         */
+        template <std::integral... Indices>
+        const_reference
+        cmap(const UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+        /**
+         * @brief Map view indices to container reference using SAFE access.
+         * @param container The source container.
+         * @param view The view defining the mapping.
+         * @param indices The indices in view-space.
+         * @return Reference to the element in the container.
+         */
+        template <std::integral... Indices>
+        reference map_at(UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+        /**
+         * @brief Map view indices to container const_reference using SAFE access.
+         * @param container The source container.
+         * @param view The view defining the mapping.
+         * @param indices The indices in view-space.
+         * @return Reference to the element in the container.
+         */
+        template <std::integral... Indices>
+        const_reference
+        cmap_at(const UnderlyingContainer& container, const view_type& view, const Indices... indices) const;
+
+        /// @brief Return the dimensionality of the view
+        size_t dimension(const UnderlyingContainer& container) const;
+
+    private:
+
+        /// @brief Alias for selecting reference type based on const-correctness.
+        template <bool IS_CONST>
+        using conditional_reference = std::conditional_t<IS_CONST, const_reference, reference>;
+
+        /// @brief Helper type alias for the I-th slice type
+        template <size_t I>
+        using slice_type = std::tuple_element_t<I, std::tuple<Slices...>>;
+
+        /// @brief True if the I-th slice is an integral slice (fixed index)
+        template <size_t I>
+        static consteval bool is_slice_integral();
+
+        /// @brief True if the I-th slice is a newaxis slice
+        template <size_t I>
+        static consteval bool is_slice_new_axis();
+
+        /**
+         * Helper metafunction to build an index_sequence that skips
+         * newaxis slices.
+         *
+         * The resulting sequence contains only the indices that
+         * correspond to real container dimensions.
+         */
+        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>;
+        };
+
+        /// @brief Base case: recursion termination
+        template <size_t bound, size_t... indices>
+        struct indices_sequence_helper<bound, bound, indices...>
+        {
+            using type = std::index_sequence<indices...>;
+        };
+
+        ///<  @brief Index sequence of non-newaxis slices
+        template <size_t bound>
+        using indices_sequence = indices_sequence_helper<0, bound>::type;
+
+        /**
+         * @brief Maps an index for a specific slice to the corresponding index in the underlying container.
+         *
+         * For integral slices (fixed indices), returns the fixed index value.
+         * For non-integral slices (like `xt::all()`), applies the slice transformation to the index.
+         *
+         * @tparam I The slice index to map.
+         * @tparam Index Type of the index (must be integral).
+         * @param view The view object containing slice information.
+         * @param i The index within the slice to map.
+         * @return size_t The mapped index in the underlying container.
+         *
+         * @throws Assertion failure if `i != 0` for integral slices.
+         * @throws Assertion failure if `i >= slice.size()` for non-integral slices.
+         */
+        template <access_t ACCESS, size_t I, std::integral Index>
+        size_t map_ith_index(const view_type& view, const Index i) const;
+
+        /**
+         * @brief Main recursion/logic handler for mapping operations.
+         * Handles dimension dropping if the provided index count exceeds view dimensionality.
+         *
+         * @tparam IS_CONST Boolean flag; true if the operation is on a const container.
+         * @tparam ACCESS The access policy (SAFE for .at(), UNSAFE for operator()).
+         * @param is_const Tag used for compile-time dispatching of const-correctness.
+         * @param container The underlying container (xarray, xtensor, etc.) being accessed.
+         * @param access Tag used for compile-time dispatching of the access method.
+         * @param view The xview instance that defines the coordinate transformation.
+         * @param firstIndice The current leading index in the coordinate pack.
+         * @param otherIndices The remaining indices in the coordinate pack.
+         */
+        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;
+
+        /**
+         * @brief Base case for map_main recursion, where no indices is supplied and assumes (0, 0, ...).
+         *
+         * @tparam IS_CONST Boolean flag; true if the operation is on a const container.
+         * @tparam ACCESS The access policy (SAFE for .at(), UNSAFE for operator()).
+         * @param is_const Tag used for compile-time dispatching of const-correctness.
+         * @param container The underlying container (xarray, xtensor, etc.) being accessed.
+         * @param access Tag used for compile-time dispatching of the access method.
+         * @param view The xview instance that defines the coordinate transformation.
+         */
+        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;
+
+        /**
+         * @brief Maps all indices and accesses the container.
+         *
+         * @tparam IS_CONST Boolean flag for const-correctness.
+         * @tparam ACCESS The access policy (SAFE or UNSAFE).
+         * @tparam n_indices The size of the index array (calculated from view/container info).
+         * @tparam Is A pack of indices `0, 1, ..., n-1` used to unroll the mapping loop.
+         * @param is_const Tag for const-correctness dispatch.
+         * @param container The underlying container being accessed.
+         * @param access Tag for access method dispatch.
+         * @param view The xview instance providing the slice transformations.
+         * @param is_seq An index sequence used to drive the parameter pack expansion.
+         * @param indices An array containing the view-space indices to be mapped.
+         */
+        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;
+
+        /// @brief Expand view indices into a full index array, inserting dummy indices for integral slices
+        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 = static_cast<size_t>(
+            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>
+    {
+        // Work around compilers failing to deduce nb_integral_slices as a non-type template argument inline
+        // (error: use of variable template 'n_indices_full_v' requires template arguments)
+        constexpr size_t n_indices_full = nb_integral_slices;
+
+        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<ACCESS, Is>(view, indices[Is])...);
+        }
+        else
+        {
+            return container(map_ith_index<ACCESS, Is>(view, indices[Is])...);
+        }
+    }
+
+    template <class UnderlyingContainer, class... Slices>
+    template <access_t ACCESS, 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 if constexpr (xt::detail::is_xall_slice<std::decay_t<current_slice>>::value)
+            {
+                return size_t(i);
+            }
+            else
+            {
+                using slice_size_type = typename current_slice::size_type;
+                if constexpr (ACCESS == access_t::UNSAFE)
+                {
+                    assert(static_cast<slice_size_type>(i) < slice.size());
+                }
+                return size_t(slice(static_cast<slice_size_type>(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
diff --git a/include/xtensor/views/xaxis_iterator.hpp b/include/xtensor/views/xaxis_iterator.hpp
new file mode 100644
index 000000000..2b54748d4
--- /dev/null
+++ b/include/xtensor/views/xaxis_iterator.hpp
@@ -0,0 +1,346 @@
+/***************************************************************************
+ * 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_AXIS_ITERATOR_HPP
+#define XTENSOR_AXIS_ITERATOR_HPP
+
+#include "../views/xstrided_view.hpp"
+
+namespace xt
+{
+
+    /******************
+     * xaxis_iterator *
+     ******************/
+
+    /**
+     * @class xaxis_iterator
+     * @brief 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.
+     *
+     * @tparam CT the closure type of the \ref xexpression
+     */
+    template <class CT>
+    class xaxis_iterator
+    {
+    public:
+
+        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;
+
+        template <class CTA>
+        xaxis_iterator(CTA&& e, size_type axis);
+        template <class CTA>
+        xaxis_iterator(CTA&& e, size_type axis, size_type index, size_type offset);
+
+        self_type& operator++();
+        self_type operator++(int);
+
+        reference operator*() const;
+        pointer operator->() const;
+
+        bool equal(const self_type& rhs) const;
+
+    private:
+
+        using storing_type = xtl::ptr_closure_type_t<CT>;
+        mutable storing_type p_expression;
+        size_type m_index;
+        size_type m_add_offset;
+        value_type m_sv;
+
+        template <class T, class CTA>
+        T get_storage_init(CTA&& e) const;
+    };
+
+    template <class CT>
+    bool operator==(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs);
+
+    template <class CT>
+    bool operator!=(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs);
+
+    template <class E>
+    auto axis_begin(E&& e);
+
+    template <class E>
+    auto axis_begin(E&& e, typename std::decay_t<E>::size_type axis);
+
+    template <class E>
+    auto axis_end(E&& e);
+
+    template <class E>
+    auto axis_end(E&& e, typename std::decay_t<E>::size_type axis);
+
+    /*********************************
+     * xaxis_iterator implementation *
+     *********************************/
+
+    namespace detail
+    {
+        template <class CT>
+        auto derive_xstrided_view(
+            CT&& e,
+            typename std::decay_t<CT>::size_type axis,
+            typename std::decay_t<CT>::size_type offset
+        )
+        {
+            using xexpression_type = std::decay_t<CT>;
+            using shape_type = typename xexpression_type::shape_type;
+            using strides_type = typename xexpression_type::strides_type;
+
+            const auto& e_shape = e.shape();
+            shape_type shape(e_shape.size() - 1);
+            auto nxt = std::copy(e_shape.cbegin(), e_shape.cbegin() + axis, shape.begin());
+            std::copy(e_shape.cbegin() + axis + 1, e_shape.end(), nxt);
+
+            const auto& e_strides = e.strides();
+            strides_type strides(e_strides.size() - 1);
+            auto nxt_strides = std::copy(e_strides.cbegin(), e_strides.cbegin() + axis, strides.begin());
+            std::copy(e_strides.cbegin() + axis + 1, e_strides.end(), nxt_strides);
+
+            return strided_view(std::forward<CT>(e), std::move(shape), std::move(strides), offset, e.layout());
+        }
+    }
+
+    template <class CT>
+    template <class T, class CTA>
+    inline T xaxis_iterator<CT>::get_storage_init(CTA&& e) const
+    {
+        if constexpr (xtl::pointer_concept<T>)
+        {
+            return &e;
+        }
+        else
+        {
+            return e;
+        }
+    }
+
+    /**
+     * @name Constructors
+     */
+    //@{
+    /**
+     * Constructs an xaxis_iterator
+     *
+     * @param e the expression to iterate over
+     * @param axis the axis to iterate over taking N-1 dimensional slices
+     */
+    template <class CT>
+    template <class CTA>
+    inline xaxis_iterator<CT>::xaxis_iterator(CTA&& e, size_type axis)
+        : xaxis_iterator(std::forward<CTA>(e), axis, 0, e.data_offset())
+    {
+    }
+
+    /**
+     * Constructs an xaxis_iterator starting at specified index and offset
+     *
+     * @param e the expression to iterate over
+     * @param axis the axis to iterate over taking N-1 dimensional slices
+     * @param index the starting index for the iterator
+     * @param offset the starting offset for the iterator
+     */
+    template <class CT>
+    template <class CTA>
+    inline xaxis_iterator<CT>::xaxis_iterator(CTA&& e, size_type axis, size_type index, size_type offset)
+        : p_expression(get_storage_init<storing_type>(std::forward<CTA>(e)))
+        , m_index(index)
+        , m_add_offset(static_cast<size_type>(e.strides()[axis]))
+        , m_sv(detail::derive_xstrided_view<CTA>(std::forward<CTA>(e), axis, offset))
+    {
+    }
+
+    //@}
+
+    /**
+     * @name Increment
+     */
+    //@{
+    /**
+     * Increments the iterator to the next position and returns it.
+     */
+    template <class CT>
+    inline auto xaxis_iterator<CT>::operator++() -> self_type&
+    {
+        m_sv.set_offset(m_sv.data_offset() + m_add_offset);
+        ++m_index;
+        return *this;
+    }
+
+    /**
+     * Makes a copy of the iterator, increments it to the next
+     * position, and returns the copy.
+     */
+    template <class CT>
+    inline auto xaxis_iterator<CT>::operator++(int) -> self_type
+    {
+        self_type tmp(*this);
+        ++(*this);
+        return tmp;
+    }
+
+    //@}
+
+    /**
+     * @name Reference
+     */
+    //@{
+    /**
+     * Returns the strided view at the current iteration position
+     *
+     * @return a strided_view
+     */
+    template <class CT>
+    inline auto xaxis_iterator<CT>::operator*() const -> reference
+    {
+        return m_sv;
+    }
+
+    /**
+     * Returns a pointer to the strided view at the current iteration position
+     *
+     * @return a pointer to a strided_view
+     */
+    template <class CT>
+    inline auto xaxis_iterator<CT>::operator->() const -> pointer
+    {
+        return xtl::closure_pointer(operator*());
+    }
+
+    //@}
+
+    /*
+     * @name Comparisons
+     */
+    //@{
+    /**
+     * Checks equality of the xaxis_slice_iterator and \c rhs.
+     *
+     * @param rhs iterator to compare with
+     * @return true if the iterators are equivalent, false otherwise
+     */
+    template <class CT>
+    inline bool xaxis_iterator<CT>::equal(const self_type& rhs) const
+    {
+        return p_expression == rhs.p_expression && m_index == rhs.m_index
+               && m_sv.data_offset() == rhs.m_sv.data_offset();
+    }
+
+    /**
+     * Checks equality of the iterators.
+     *
+     * @return true if the iterators are equivalent, false otherwise
+     */
+    template <class CT>
+    inline bool operator==(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs)
+    {
+        return lhs.equal(rhs);
+    }
+
+    /**
+     * Checks inequality of the iterators
+     * @return true if the iterators are different, true otherwise
+     */
+    template <class CT>
+    inline bool operator!=(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    //@}
+
+    /**
+     * @name Iterators
+     */
+    //@{
+    /**
+     * Returns an iterator to the first element of the expression for axis 0
+     *
+     * @param e the expession to iterate over
+     * @return an instance of xaxis_iterator
+     */
+    template <class E>
+    inline auto axis_begin(E&& e)
+    {
+        using return_type = xaxis_iterator<xtl::closure_type_t<E>>;
+        return return_type(std::forward<E>(e), 0);
+    }
+
+    /**
+     * Returns an iterator to the first element of the expression for the specified axis
+     *
+     * @param e the expession to iterate over
+     * @param axis the axis to iterate over
+     * @return an instance of xaxis_iterator
+     */
+    template <class E>
+    inline auto axis_begin(E&& e, typename std::decay_t<E>::size_type axis)
+    {
+        using return_type = xaxis_iterator<xtl::closure_type_t<E>>;
+        return return_type(std::forward<E>(e), axis);
+    }
+
+    /**
+     * Returns an iterator to the element following the last element of
+     * the expression for axis 0
+     *
+     * @param e the expession to iterate over
+     * @return an instance of xaxis_iterator
+     */
+    template <class E>
+    inline auto axis_end(E&& e)
+    {
+        using size_type = typename std::decay_t<E>::size_type;
+        using return_type = xaxis_iterator<xtl::closure_type_t<E>>;
+        return return_type(
+            std::forward<E>(e),
+            0,
+            e.shape()[0],
+            static_cast<size_type>(e.strides()[0]) * e.shape()[0]
+        );
+    }
+
+    /**
+     * Returns an iterator to the element following the last element of
+     * the expression for the specified axis
+     *
+     * @param e the expression to iterate over
+     * @param axis the axis to iterate over
+     * @return an instance of xaxis_iterator
+     */
+    template <class E>
+    inline auto axis_end(E&& e, typename std::decay_t<E>::size_type axis)
+    {
+        using size_type = typename std::decay_t<E>::size_type;
+        using return_type = xaxis_iterator<xtl::closure_type_t<E>>;
+        return return_type(
+            std::forward<E>(e),
+            axis,
+            e.shape()[axis],
+            static_cast<size_type>(e.strides()[axis]) * e.shape()[axis]
+        );
+    }
+
+    //@}
+}
+
+#endif
diff --git a/include/xtensor/views/xaxis_slice_iterator.hpp b/include/xtensor/views/xaxis_slice_iterator.hpp
new file mode 100644
index 000000000..6ee904df9
--- /dev/null
+++ b/include/xtensor/views/xaxis_slice_iterator.hpp
@@ -0,0 +1,362 @@
+/***************************************************************************
+ * 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_AXIS_SLICE_ITERATOR_HPP
+#define XTENSOR_AXIS_SLICE_ITERATOR_HPP
+
+#include "../views/xstrided_view.hpp"
+
+namespace xt
+{
+
+    /**
+     * @class xaxis_slice_iterator
+     * @brief Class for iteration over one-dimensional slices
+     *
+     * The xaxis_slice_iterator iterates over one-dimensional slices
+     * oriented along the specified axis
+     *
+     * @tparam CT the closure type of the \ref xexpression
+     */
+    template <class CT>
+    class xaxis_slice_iterator
+    {
+    public:
+
+        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;
+
+        template <class CTA>
+        xaxis_slice_iterator(CTA&& e, size_type axis);
+        template <class CTA>
+        xaxis_slice_iterator(CTA&& e, size_type axis, size_type index, size_type offset);
+
+        self_type& operator++();
+        self_type operator++(int);
+
+        reference operator*() const;
+        pointer operator->() const;
+
+        bool equal(const self_type& rhs) const;
+
+    private:
+
+        using storing_type = xtl::ptr_closure_type_t<CT>;
+        mutable storing_type p_expression;
+        size_type m_index;
+        size_type m_offset;
+        size_type m_axis_stride;
+        size_type m_lower_shape;
+        size_type m_upper_shape;
+        size_type m_iter_size;
+        bool m_is_target_axis;
+        value_type m_sv;
+
+        template <class T, class CTA>
+        T get_storage_init(CTA&& e) const;
+    };
+
+    template <class CT>
+    bool operator==(const xaxis_slice_iterator<CT>& lhs, const xaxis_slice_iterator<CT>& rhs);
+
+    template <class CT>
+    bool operator!=(const xaxis_slice_iterator<CT>& lhs, const xaxis_slice_iterator<CT>& rhs);
+
+    template <class E>
+    auto xaxis_slice_begin(E&& e);
+
+    template <class E>
+    auto xaxis_slice_begin(E&& e, typename std::decay_t<E>::size_type axis);
+
+    template <class E>
+    auto xaxis_slice_end(E&& e);
+
+    template <class E>
+    auto xaxis_slice_end(E&& e, typename std::decay_t<E>::size_type axis);
+
+    /***************************************
+     * xaxis_slice_iterator implementation *
+     ***************************************/
+
+    template <class CT>
+    template <class T, class CTA>
+    T xaxis_slice_iterator<CT>::get_storage_init(CTA&& e) const
+    {
+        if constexpr (xtl::pointer_concept<T>)
+        {
+            return &e;
+        }
+        else
+        {
+            return e;
+        }
+    }
+
+    /**
+     * @name Constructors
+     */
+    //@{
+    /**
+     * Constructs an xaxis_slice_iterator
+     *
+     * @param e the expression to iterate over
+     * @param axis the axis to iterate over taking one dimensional slices
+     */
+    template <class CT>
+    template <class CTA>
+    inline xaxis_slice_iterator<CT>::xaxis_slice_iterator(CTA&& e, size_type axis)
+        : xaxis_slice_iterator(std::forward<CTA>(e), axis, 0, e.data_offset())
+    {
+    }
+
+    /**
+     * Constructs an xaxis_slice_iterator starting at specified index and offset
+     *
+     * @param e the expression to iterate over
+     * @param axis the axis to iterate over taking one dimensional slices
+     * @param index the starting index for the iterator
+     * @param offset the starting offset for the iterator
+     */
+    template <class CT>
+    template <class CTA>
+    inline xaxis_slice_iterator<CT>::xaxis_slice_iterator(CTA&& e, size_type axis, size_type index, size_type offset)
+        : p_expression(get_storage_init<storing_type>(std::forward<CTA>(e)))
+        , m_index(index)
+        , m_offset(offset)
+        , m_axis_stride(static_cast<size_type>(e.strides()[axis]) * (e.shape()[axis] - 1u))
+        , m_lower_shape(0)
+        , m_upper_shape(0)
+        , m_iter_size(0)
+        , m_is_target_axis(false)
+        , m_sv(strided_view(
+              std::forward<CT>(e),
+              std::forward<shape_type>({e.shape()[axis]}),
+              std::forward<strides_type>({e.strides()[axis]}),
+              offset,
+              e.layout()
+          ))
+    {
+        if (e.layout() == layout_type::row_major)
+        {
+            m_is_target_axis = axis == e.dimension() - 1;
+            m_lower_shape = std::accumulate(
+                e.shape().begin() + axis + 1,
+                e.shape().end(),
+                size_t(1),
+                std::multiplies<>()
+            );
+            m_iter_size = std::accumulate(e.shape().begin() + 1, e.shape().end(), size_t(1), std::multiplies<>());
+        }
+        else
+        {
+            m_is_target_axis = axis == 0;
+            m_lower_shape = std::accumulate(
+                e.shape().begin(),
+                e.shape().begin() + axis,
+                size_t(1),
+                std::multiplies<>()
+            );
+            m_iter_size = std::accumulate(e.shape().begin(), e.shape().end() - 1, size_t(1), std::multiplies<>());
+        }
+        m_upper_shape = m_lower_shape + m_axis_stride;
+    }
+
+    //@}
+
+    /**
+     * @name Increment
+     */
+    //@{
+    /**
+     * Increments the iterator to the next position and returns it.
+     */
+    template <class CT>
+    inline auto xaxis_slice_iterator<CT>::operator++() -> self_type&
+    {
+        ++m_index;
+        ++m_offset;
+        auto index_compare = (m_offset % m_iter_size);
+        if (m_is_target_axis || (m_upper_shape >= index_compare && index_compare >= m_lower_shape))
+        {
+            m_offset += m_axis_stride;
+        }
+        m_sv.set_offset(m_offset);
+        return *this;
+    }
+
+    /**
+     * Makes a copy of the iterator, increments it to the next
+     * position, and returns the copy.
+     */
+    template <class CT>
+    inline auto xaxis_slice_iterator<CT>::operator++(int) -> self_type
+    {
+        self_type tmp(*this);
+        ++(*this);
+        return tmp;
+    }
+
+    //@}
+
+    /**
+     * @name Reference
+     */
+    //@{
+    /**
+     * Returns the strided view at the current iteration position
+     *
+     * @return a strided_view
+     */
+    template <class CT>
+    inline auto xaxis_slice_iterator<CT>::operator*() const -> reference
+    {
+        return m_sv;
+    }
+
+    /**
+     * Returns a pointer to the strided view at the current iteration position
+     *
+     * @return a pointer to a strided_view
+     */
+    template <class CT>
+    inline auto xaxis_slice_iterator<CT>::operator->() const -> pointer
+    {
+        return xtl::closure_pointer(operator*());
+    }
+
+    //@}
+
+    /*
+     * @name Comparisons
+     */
+    //@{
+    /**
+     * Checks equality of the xaxis_slice_iterator and \c rhs.
+     *
+     * @return true if the iterators are equivalent, false otherwise
+     */
+    template <class CT>
+    inline bool xaxis_slice_iterator<CT>::equal(const self_type& rhs) const
+    {
+        return p_expression == rhs.p_expression && m_index == rhs.m_index;
+    }
+
+    /**
+     * Checks equality of the iterators.
+     *
+     * @return true if the iterators are equivalent, false otherwise
+     */
+    template <class CT>
+    inline bool operator==(const xaxis_slice_iterator<CT>& lhs, const xaxis_slice_iterator<CT>& rhs)
+    {
+        return lhs.equal(rhs);
+    }
+
+    /**
+     * Checks inequality of the iterators
+     * @return true if the iterators are different, true otherwise
+     */
+    template <class CT>
+    inline bool operator!=(const xaxis_slice_iterator<CT>& lhs, const xaxis_slice_iterator<CT>& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    //@}
+
+    /**
+     * @name Iterators
+     */
+    //@{
+    /**
+     * Returns an iterator to the first element of the expression for axis 0
+     *
+     * @param e the expession to iterate over
+     * @return an instance of xaxis_slice_iterator
+     */
+    template <class E>
+    inline auto axis_slice_begin(E&& e)
+    {
+        using return_type = xaxis_slice_iterator<xtl::closure_type_t<E>>;
+        return return_type(std::forward<E>(e), 0);
+    }
+
+    /**
+     * Returns an iterator to the first element of the expression for the specified axis
+     *
+     * @param e the expession to iterate over
+     * @param axis the axis to iterate over
+     * @return an instance of xaxis_slice_iterator
+     */
+    template <class E>
+    inline auto axis_slice_begin(E&& e, typename std::decay_t<E>::size_type axis)
+    {
+        using return_type = xaxis_slice_iterator<xtl::closure_type_t<E>>;
+        return return_type(std::forward<E>(e), axis, 0, e.data_offset());
+    }
+
+    /**
+     * Returns an iterator to the element following the last element of
+     * the expression for axis 0
+     *
+     * @param e the expession to iterate over
+     * @return an instance of xaxis_slice_iterator
+     */
+    template <class E>
+    inline auto axis_slice_end(E&& e)
+    {
+        using return_type = xaxis_slice_iterator<xtl::closure_type_t<E>>;
+        return return_type(
+            std::forward<E>(e),
+            0,
+            std::accumulate(e.shape().begin() + 1, e.shape().end(), size_t(1), std::multiplies<>()),
+            e.size()
+        );
+    }
+
+    /**
+     * Returns an iterator to the element following the last element of
+     * the expression for the specified axis
+     *
+     * @param e the expression to iterate over
+     * @param axis the axis to iterate over
+     * @return an instance of xaxis_slice_iterator
+     */
+    template <class E>
+    inline auto axis_slice_end(E&& e, typename std::decay_t<E>::size_type axis)
+    {
+        using return_type = xaxis_slice_iterator<xtl::closure_type_t<E>>;
+        auto index_sum = std::accumulate(
+            e.shape().begin(),
+            e.shape().begin() + axis,
+            size_t(1),
+            std::multiplies<>()
+        );
+        return return_type(
+            std::forward<E>(e),
+            axis,
+            std::accumulate(e.shape().begin() + axis + 1, e.shape().end(), index_sum, std::multiplies<>()),
+            e.size() + axis
+        );
+    }
+
+    //@}
+}
+
+#endif
diff --git a/include/xtensor/xbroadcast.hpp b/include/xtensor/views/xbroadcast.hpp
similarity index 73%
rename from include/xtensor/xbroadcast.hpp
rename to include/xtensor/views/xbroadcast.hpp
index a4e626cce..ae092c2bb 100644
--- a/include/xtensor/xbroadcast.hpp
+++ b/include/xtensor/views/xbroadcast.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_BROADCAST_HPP
 #define XTENSOR_BROADCAST_HPP
@@ -12,18 +13,18 @@
 #include <algorithm>
 #include <array>
 #include <cstddef>
-#include <iterator>
-#include <numeric>
 #include <type_traits>
 #include <utility>
 
 #include <xtl/xsequence.hpp>
 
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xscalar.hpp"
-#include "xstrides.hpp"
-#include "xutils.hpp"
+#include "../containers/xscalar.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
@@ -35,13 +36,8 @@ namespace xt
     template <class E, class S>
     auto broadcast(E&& e, const S& s);
 
-#ifdef X_OLD_CLANG
-    template <class E, class I>
-    auto broadcast(E&& e, std::initializer_list<I> s);
-#else
     template <class E, class I, std::size_t L>
     auto broadcast(E&& e, const I (&s)[L]);
-#endif
 
     /*************************
      * xbroadcast extensions *
@@ -59,8 +55,7 @@ namespace xt
         };
 
         template <class CT, class X>
-        struct xbroadcast_base
-            : xbroadcast_base_impl<xexpression_tag_t<CT>, CT, X>
+        struct xbroadcast_base : xbroadcast_base_impl<xexpression_tag_t<CT>, CT, X>
         {
         };
 
@@ -75,6 +70,9 @@ namespace xt
     template <class CT, class X>
     class xbroadcast;
 
+    template <class E>
+    concept xbroadcast_concept = is_specialization_of<xbroadcast, E>::value;
+
     template <class CT, class X>
     struct xiterable_inner_types<xbroadcast<CT, X>>
     {
@@ -84,6 +82,65 @@ namespace xt
         using stepper = const_stepper;
     };
 
+    template <class CT, class X>
+    struct xcontainer_inner_types<xbroadcast<CT, X>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using reference = typename xexpression_type::const_reference;
+        using const_reference = typename xexpression_type::const_reference;
+        using size_type = typename xexpression_type::size_type;
+    };
+
+    /*****************************
+     * linear_begin / linear_end *
+     *****************************/
+
+    template <class CT, class X>
+    constexpr auto linear_begin(xbroadcast<CT, X>& c) noexcept
+    {
+        return linear_begin(c.expression());
+    }
+
+    template <class CT, class X>
+    constexpr auto linear_end(xbroadcast<CT, X>& c) noexcept
+    {
+        return linear_end(c.expression());
+    }
+
+    template <class CT, class X>
+    constexpr auto linear_begin(const xbroadcast<CT, X>& c) noexcept
+    {
+        return linear_begin(c.expression());
+    }
+
+    template <class CT, class X>
+    constexpr auto linear_end(const xbroadcast<CT, X>& c) noexcept
+    {
+        return linear_end(c.expression());
+    }
+
+    /*************************************
+     * overlapping_memory_checker_traits *
+     *************************************/
+
+    template <xbroadcast_concept E>
+        requires(!addressable_to_expression<std::decay_t<E>>)
+    struct overlapping_memory_checker_traits<E>
+    {
+        static bool check_overlap(const E& expr, const memory_range& dst_range)
+        {
+            if (expr.size() == 0)
+            {
+                return false;
+            }
+            else
+            {
+                using ChildE = std::decay_t<decltype(expr.expression())>;
+                return overlapping_memory_checker_traits<ChildE>::check_overlap(expr.expression(), dst_range);
+            }
+        }
+    };
+
     /**
      * @class xbroadcast
      * @brief Broadcasted xexpression to a specified shape.
@@ -98,23 +155,26 @@ namespace xt
      * @sa broadcast
      */
     template <class CT, class X>
-    class xbroadcast : public xexpression<xbroadcast<CT, X>>,
+    class xbroadcast : public xsharable_expression<xbroadcast<CT, X>>,
                        public xconst_iterable<xbroadcast<CT, X>>,
+                       public xconst_accessible<xbroadcast<CT, X>>,
                        public extension::xbroadcast_base_t<CT, X>
     {
     public:
 
         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 xexpression_type::reference;
-        using const_reference = typename xexpression_type::const_reference;
-        using pointer = typename xexpression_type::pointer;
+        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 xexpression_type::size_type;
+        using size_type = typename inner_types::size_type;
         using difference_type = typename xexpression_type::difference_type;
 
         using iterable_base = xconst_iterable<self_type>;
@@ -124,6 +184,8 @@ namespace xt
         using stepper = typename iterable_base::stepper;
         using const_stepper = typename iterable_base::const_stepper;
 
+        using bool_load_type = typename xexpression_type::bool_load_type;
+
         static constexpr layout_type static_layout = layout_type::dynamic;
         static constexpr bool contiguous_layout = false;
 
@@ -133,26 +195,18 @@ namespace xt
         template <class CTA>
         xbroadcast(CTA&& e, shape_type&& s);
 
-        size_type size() const noexcept;
-        size_type dimension() const noexcept;
+        using accessible_base::size;
         const inner_shape_type& shape() const noexcept;
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+        using accessible_base::shape;
 
         template <class... Args>
         const_reference operator()(Args... args) const;
 
-        template <class... Args>
-        const_reference at(Args... args) const;
-
         template <class... Args>
         const_reference unchecked(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 It>
         const_reference element(It first, It last) const;
 
@@ -169,7 +223,7 @@ namespace xt
         template <class S>
         const_stepper stepper_end(const S& shape, layout_type l) const noexcept;
 
-        template <class E, class XCT = CT, class = std::enable_if_t<xt::is_xscalar<XCT>::value>>
+        template <class E, xscalar_concept XCT = CT>
         void assign_to(xexpression<E>& e) const;
 
         template <class E>
@@ -201,27 +255,18 @@ namespace xt
     template <class E, class S>
     inline auto broadcast(E&& e, const S& s)
     {
-        using broadcast_type = xbroadcast<const_xclosure_t<E>, S>;
-        return broadcast_type(std::forward<E>(e), s);
+        using shape_type = filter_fixed_shape_t<std::decay_t<S>>;
+        using broadcast_type = xbroadcast<const_xclosure_t<E>, shape_type>;
+        return broadcast_type(std::forward<E>(e), xtl::forward_sequence<shape_type, decltype(s)>(s));
     }
 
-#ifdef X_OLD_CLANG
-    template <class E, class I>
-    inline auto broadcast(E&& e, std::initializer_list<I> s)
-    {
-        using broadcast_type = xbroadcast<const_xclosure_t<E>, std::vector<std::size_t>>;
-        using shape_type = typename broadcast_type::shape_type;
-        return broadcast_type(std::forward<E>(e), xtl::forward_sequence<shape_type>(s));
-    }
-#else
     template <class E, class I, std::size_t L>
     inline auto broadcast(E&& e, const I (&s)[L])
     {
         using broadcast_type = xbroadcast<const_xclosure_t<E>, std::array<std::size_t, L>>;
         using shape_type = typename broadcast_type::shape_type;
-        return broadcast_type(std::forward<E>(e), xtl::forward_sequence<shape_type>(s));
+        return broadcast_type(std::forward<E>(e), xtl::forward_sequence<shape_type, decltype(s)>(s));
     }
-#endif
 
     /*****************************
      * xbroadcast implementation *
@@ -245,7 +290,7 @@ namespace xt
     {
         if (s.size() < m_e.dimension())
         {
-            throw xt::broadcast_error("Broadcast shape has fewer elements than original expression.");
+            XTENSOR_THROW(xt::broadcast_error, "Broadcast shape has fewer elements than original expression.");
         }
         xt::resize_container(m_shape, s.size());
         std::copy(s.begin(), s.end(), m_shape.begin());
@@ -262,33 +307,18 @@ namespace xt
     template <class CT, class X>
     template <class CTA>
     inline xbroadcast<CT, X>::xbroadcast(CTA&& e, shape_type&& s)
-        : m_e(std::forward<CTA>(e)), m_shape(std::move(s))
+        : m_e(std::forward<CTA>(e))
+        , m_shape(std::move(s))
     {
         xt::broadcast_shape(m_e.shape(), m_shape);
     }
+
     //@}
 
     /**
      * @name Size and shape
      */
-    /**
-     * Returns the size of the expression.
-     */
-    template <class CT, class X>
-    inline auto xbroadcast<CT, X>::size() const noexcept -> size_type
-    {
-        return compute_size(shape());
-    }
-
-    /**
-     * Returns the number of dimensions of the expression.
-     */
-    template <class CT, class X>
-    inline auto xbroadcast<CT, X>::dimension() const noexcept -> size_type
-    {
-        return m_shape.size();
-    }
-
+    //@{
     /**
      * Returns the shape of the expression.
      */
@@ -306,11 +336,19 @@ namespace xt
     {
         return m_e.layout();
     }
+
+    template <class CT, class X>
+    inline bool xbroadcast<CT, X>::is_contiguous() const noexcept
+    {
+        return false;
+    }
+
     //@}
 
     /**
      * @name Data
      */
+    //@{
     /**
      * Returns a constant reference to the element at the specified position in the expression.
      * @param args a list of indices specifying the position in the function. Indices
@@ -324,23 +362,6 @@ namespace xt
         return m_e(args...);
     }
 
-    /**
-     * Returns a constant reference to the element at the specified position in the expression,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class CT, class X>
-    template <class... Args>
-    inline auto xbroadcast<CT, X>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
     /**
      * Returns a constant reference to the element at the specified position in the expression.
      * @param args a list of indices specifying the position in the expression. Indices
@@ -349,16 +370,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class CT, class X>
     template <class... Args>
@@ -367,33 +388,6 @@ namespace xt
         return this->operator()(args...);
     }
 
-    /**
-     * Returns a constant reference to the element at the specified position in the expression.
-     * @param index a sequence of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices in the sequence should be equal or greater
-     * than the number of dimensions of the container.
-     */
-    template <class CT, class X>
-    template <class S>
-    inline auto xbroadcast<CT, X>::operator[](const S& index) const
-        -> disable_integral_t<S, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class CT, class X>
-    template <class I>
-    inline auto xbroadcast<CT, X>::operator[](std::initializer_list<I> index) const -> const_reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class CT, class X>
-    inline auto xbroadcast<CT, X>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
-    }
-
     /**
      * Returns a constant reference to the element at the specified position in the expression.
      * @param first iterator starting the sequence of indices
@@ -405,7 +399,7 @@ namespace xt
     template <class It>
     inline auto xbroadcast<CT, X>::element(It, It last) const -> const_reference
     {
-        return m_e.element(last - dimension(), last);
+        return m_e.element(last - this->dimension(), last);
     }
 
     /**
@@ -416,6 +410,7 @@ namespace xt
     {
         return m_e;
     }
+
     //@}
 
     /**
@@ -444,10 +439,11 @@ namespace xt
     template <class S>
     inline bool xbroadcast<CT, X>::has_linear_assign(const S& strides) const noexcept
     {
-        return dimension() == m_e.dimension() &&
-            std::equal(m_shape.cbegin(), m_shape.cend(), m_e.shape().cbegin()) &&
-            m_e.has_linear_assign(strides);
+        return this->dimension() == m_e.dimension()
+               && std::equal(m_shape.cbegin(), m_shape.cend(), m_e.shape().cbegin())
+               && m_e.has_linear_assign(strides);
     }
+
     //@}
 
     template <class CT, class X>
@@ -467,7 +463,7 @@ namespace xt
     }
 
     template <class CT, class X>
-    template <class E, class XCT, class>
+    template <class E, xscalar_concept XCT>
     inline void xbroadcast<CT, X>::assign_to(xexpression<E>& e) const
     {
         auto& ed = e.derived_cast();
diff --git a/include/xtensor/xdynamic_view.hpp b/include/xtensor/views/xdynamic_view.hpp
similarity index 69%
rename from include/xtensor/xdynamic_view.hpp
rename to include/xtensor/views/xdynamic_view.hpp
index 3473f9c3e..777ec66d3 100644
--- a/include/xtensor/xdynamic_view.hpp
+++ b/include/xtensor/views/xdynamic_view.hpp
@@ -1,22 +1,23 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 XTENSOR_DYNAMIC_VIEW_HPP
 #define XTENSOR_DYNAMIC_VIEW_HPP
 
+#include <variant>
+
 #include <xtl/xsequence.hpp>
-#include <xtl/xvariant.hpp>
 
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xlayout.hpp"
-#include "xsemantic.hpp"
-#include "xstrided_view_base.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xsemantic.hpp"
+#include "../views/xstrided_view_base.hpp"
 
 namespace xt
 {
@@ -28,7 +29,16 @@ namespace xt
     struct xcontainer_inner_types<xdynamic_view<CT, S, L, FST>>
     {
         using xexpression_type = std::decay_t<CT>;
-        using temporary_type = xarray<std::decay_t<typename xexpression_type::value_type>>;
+        using undecay_expression = CT;
+        using reference = inner_reference_t<undecay_expression>;
+        using const_reference = typename xexpression_type::const_reference;
+        using size_type = typename xexpression_type::size_type;
+        using shape_type = std::decay_t<S>;
+        using undecay_shape = S;
+        using storage_getter = FST;
+        using inner_storage_type = typename storage_getter::type;
+        using temporary_type = xarray<std::decay_t<typename xexpression_type::value_type>, xexpression_type::static_layout>;
+        static constexpr layout_type layout = L;
     };
 
     template <class CT, class S, layout_type L, class FST>
@@ -38,6 +48,13 @@ namespace xt
         using inner_strides_type = inner_shape_type;
         using inner_backstrides_type = inner_shape_type;
 
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 8
+        static constexpr auto
+            random_instantiation_var_for_gcc8_data_iface = data_interface_expression<xdynamic_view<CT, S, L, FST>>;
+        static constexpr auto
+            random_instantiation_var_for_gcc8_has_strides = strided_expression<xdynamic_view<CT, S, L, FST>>;
+#endif
+
         // TODO: implement efficient stepper specific to the dynamic_view
         using const_stepper = xindexed_stepper<const xdynamic_view<CT, S, L, FST>, true>;
         using stepper = xindexed_stepper<xdynamic_view<CT, S, L, FST>, false>;
@@ -59,8 +76,7 @@ namespace xt
         };
 
         template <class CT, class S, layout_type L, class FST>
-        struct xdynamic_view_base
-            : xdynamic_view_base_impl<xexpression_tag_t<CT>, CT, S, L, FST>
+        struct xdynamic_view_base : xdynamic_view_base_impl<xexpression_tag_t<CT>, CT, S, L, FST>
         {
         };
 
@@ -78,16 +94,16 @@ namespace xt
         class xfake_slice;
     }
 
-    template <class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_type_t<CT>>
+    template <class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, XTENSOR_DEFAULT_TRAVERSAL>>
     class xdynamic_view : public xview_semantic<xdynamic_view<CT, S, L, FST>>,
                           public xiterable<xdynamic_view<CT, S, L, FST>>,
                           public extension::xdynamic_view_base_t<CT, S, L, FST>,
-                          private xstrided_view_base<CT, S, L, FST>
+                          private xstrided_view_base<xdynamic_view<CT, S, L, FST>>
     {
     public:
 
         using self_type = xdynamic_view<CT, S, L, FST>;
-        using base_type = xstrided_view_base<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;
@@ -118,25 +134,29 @@ namespace xt
         using stepper = typename iterable_base::stepper;
         using const_stepper = typename iterable_base::const_stepper;
 
-        using base_type::static_layout;
         using base_type::contiguous_layout;
+        using base_type::static_layout;
 
         using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type;
         using base_index_type = xindex_type_t<shape_type>;
 
-        using simd_value_type = xsimd::simd_type<value_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 = xtl::variant<detail::xfake_slice<strides_vt>, xkeep_slice<strides_vt>, xdrop_slice<strides_vt>>;
+        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>;
 
-        template <class CTA>
-        xdynamic_view(CTA&& e, S&& 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 CTA, class FLS>
-        xdynamic_view(CTA&& e, S&& shape, get_strides_t<S>&& strides, std::size_t offset, layout_type layout,
-                      FLS&& flatten_strides, layout_type flatten_layout,
-                      slice_vector_type&& slices, get_strides_t<S>&& adj_strides) noexcept;
+        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);
@@ -144,10 +164,11 @@ namespace xt
         template <class E>
         disable_xexpression<E, self_type>& operator=(const E& e);
 
-        using base_type::size;
         using base_type::dimension;
-        using base_type::shape;
+        using base_type::is_contiguous;
         using base_type::layout;
+        using base_type::shape;
+        using base_type::size;
 
         // Explicitly deleting strides method to avoid compilers complaining
         // about not being able to call the strides method from xstrided_view_base
@@ -163,29 +184,21 @@ namespace xt
         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 OS>
-        disable_integral_t<OS, reference> operator[](const OS& index);
-        template <class I>
-        reference operator[](std::initializer_list<I> index);
-        reference operator[](size_type i);
+        reference flat(size_type index);
+        const_reference flat(size_type index) const;
 
-        template <class OS>
-        disable_integral_t<OS, const_reference> operator[](const OS& index) const;
-        template <class I>
-        const_reference operator[](std::initializer_list<I> index) const;
-        const_reference operator[](size_type i) const;
+        using base_type::operator[];
+        using base_type::at;
+        using base_type::back;
+        using base_type::front;
+        using base_type::in_bounds;
+        using base_type::periodic;
 
         template <class It>
         reference element(It first, It last);
@@ -201,10 +214,12 @@ namespace xt
         value_type* data() noexcept = delete;
         const value_type* data() const noexcept = delete;
 
-        using base_type::storage;
-        using base_type::expression;
         using base_type::broadcast_shape;
-        using base_type::has_linear_assign;
+        using base_type::expression;
+        using base_type::storage;
+
+        template <class O>
+        bool has_linear_assign(const O& str) const noexcept;
 
         template <class T>
         void fill(const T& value);
@@ -219,13 +234,12 @@ namespace xt
         template <class ST>
         const_stepper stepper_end(const ST& shape, layout_type l) const;
 
-        using container_iterator = std::conditional_t<is_const,
-                                                      typename storage_type::const_iterator,
-                                                      typename storage_type::iterator>;
+        using container_iterator = std::
+            conditional_t<is_const, typename storage_type::const_iterator, typename storage_type::iterator>;
         using const_container_iterator = typename storage_type::const_iterator;
 
         template <class E>
-        using rebind_t = xdynamic_view<E, S, L, detail::flat_storage_type_t<E>>;
+        using rebind_t = xdynamic_view<E, S, L, typename FST::template rebind_t<E>>;
 
         template <class E>
         rebind_t<E> build_view(E&& e) const;
@@ -239,23 +253,24 @@ namespace xt
 
         container_iterator data_xbegin() noexcept;
         const_container_iterator data_xbegin() const noexcept;
-        container_iterator data_xend(layout_type l) noexcept;
-        const_container_iterator data_xend(layout_type l) 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 It>
         It data_xbegin_impl(It begin) const noexcept;
 
         template <class It>
-        It data_xend_impl(It end, layout_type l) const noexcept;
+        It data_xend_impl(It end, layout_type l, size_type offset) const noexcept;
 
-        void assign_temporary_impl(temporary_type&& tmp);      
+        void assign_temporary_impl(temporary_type&& tmp);
 
-        template <class T,  class... Args>
+        template <class T, class... Args>
         offset_type adjust_offset(offset_type offset, T idx, Args... args) const noexcept;
         offset_type adjust_offset(offset_type offset) const noexcept;
 
         template <class T, class... Args>
-        offset_type adjust_offset_impl(offset_type offset, size_type idx_offset, T idx, Args... args) const noexcept;
+        offset_type
+        adjust_offset_impl(offset_type offset, size_type idx_offset, T idx, Args... args) const noexcept;
         offset_type adjust_offset_impl(offset_type offset, size_type idx_offset) const noexcept;
 
         template <class It>
@@ -263,7 +278,9 @@ namespace xt
 
         template <class C>
         friend class xstepper;
-        friend class xview_semantic<xdynamic_view<CT, S, L, FST>>;
+        friend class xview_semantic<self_type>;
+        friend class xaccessible<self_type>;
+        friend class xconst_accessible<self_type>;
     };
 
     /**************************
@@ -271,7 +288,7 @@ namespace xt
      **************************/
 
     template <class T>
-    using xdynamic_slice = xtl::variant<
+    using xdynamic_slice = std::variant<
         T,
 
         xrange_adaptor<placeholders::xtuph, T, T>,
@@ -293,8 +310,7 @@ namespace xt
 
         xall_tag,
         xellipsis_tag,
-        xnewaxis_tag
-    >;
+        xnewaxis_tag>;
 
     using xdynamic_slice_vector = std::vector<xdynamic_slice<std::ptrdiff_t>>;
 
@@ -364,24 +380,19 @@ namespace xt
      ********************************/
 
     template <class CT, class S, layout_type L, class FST>
-    template <class CTA>
-    inline xdynamic_view<CT, S, L, FST>::xdynamic_view(CTA&& e, S&& shape, get_strides_t<S>&& strides,
-                                                       std::size_t offset, layout_type layout,
-                                                       slice_vector_type&& slices, get_strides_t<S>&& adj_strides) noexcept
-        : base_type(std::forward<CTA>(e), std::move(shape), std::move(strides), offset, layout),
-          m_slices(std::move(slices)), m_adj_strides(std::move(adj_strides))
-    {
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class CTA, class FLS>
-    inline xdynamic_view<CT, S, L, FST>::xdynamic_view(CTA&& e, S&& shape, get_strides_t<S>&& strides,
-                                                       std::size_t offset, layout_type layout,
-                                                       FLS&& flatten_strides, layout_type flatten_layout,
-                                                       slice_vector_type&& slices, get_strides_t<S>&& adj_strides) noexcept
-        : base_type(std::forward<CTA>(e), std::move(shape), std::move(strides),
-                    offset, layout, std::forward<FLS>(flatten_strides), flatten_layout),
-          m_slices(std::move(slices)), m_adj_strides(std::move(adj_strides))
+    template <class CTA, class SA>
+    inline 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
+    ) noexcept
+        : base_type(std::forward<CTA>(e), std::forward<SA>(shape), std::move(strides), offset, layout)
+        , m_slices(std::move(slices))
+        , m_adj_strides(std::move(adj_strides))
     {
     }
 
@@ -435,19 +446,10 @@ namespace xt
     }
 
     template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xdynamic_view<CT, S, L, FST>::at(Args... args) -> reference
+    template <class O>
+    inline bool xdynamic_view<CT, S, L, FST>::has_linear_assign(const O&) const noexcept
     {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xdynamic_view<CT, S, L, FST>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
+        return false;
     }
 
     template <class CT, class S, layout_type L, class FST>
@@ -469,43 +471,15 @@ namespace xt
     }
 
     template <class CT, class S, layout_type L, class FST>
-    template <class OS>
-    inline auto xdynamic_view<CT, S, L, FST>::operator[](const OS& index) -> disable_integral_t<OS, reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class I>
-    inline auto xdynamic_view<CT, S, L, FST>::operator[](std::initializer_list<I> index) -> reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xdynamic_view<CT, S, L, FST>::operator[](size_type i) -> reference
-    {
-        return operator()(i);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class OS>
-    inline auto xdynamic_view<CT, S, L, FST>::operator[](const OS& index) const -> disable_integral_t<OS, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class I>
-    inline auto xdynamic_view<CT, S, L, FST>::operator[](std::initializer_list<I> index) const -> const_reference
+    inline auto xdynamic_view<CT, S, L, FST>::flat(size_type i) -> reference
     {
-        return element(index.begin(), index.end());
+        return base_type::storage()[data_offset() + i];
     }
 
     template <class CT, class S, layout_type L, class FST>
-    inline auto xdynamic_view<CT, S, L, FST>::operator[](size_type i) const -> const_reference
+    inline auto xdynamic_view<CT, S, L, FST>::flat(size_type i) const -> const_reference
     {
-        return operator()(i);
+        return base_type::storage()[data_offset() + i];
     }
 
     template <class CT, class S, layout_type L, class FST>
@@ -532,7 +506,13 @@ namespace xt
     inline auto xdynamic_view<CT, S, L, FST>::data_offset() const noexcept -> size_type
     {
         size_type offset = base_type::data_offset();
-        size_type sl_offset = xtl::visit([](const auto& sl) { return sl(size_type(0)); }, m_slices[0]);
+        size_type sl_offset = std::visit(
+            [](const auto& sl)
+            {
+                return sl(size_type(0));
+            },
+            m_slices[0]
+        );
         return offset + sl_offset * m_adj_strides[0];
     }
 
@@ -540,7 +520,7 @@ namespace xt
     template <class T>
     inline void xdynamic_view<CT, S, L, FST>::fill(const T& value)
     {
-        return std::fill(this->storage_begin(), this->storage_end(), value);
+        return std::fill(this->linear_begin(), this->linear_end(), value);
     }
 
     template <class CT, class S, layout_type L, class FST>
@@ -569,7 +549,8 @@ namespace xt
 
     template <class CT, class S, layout_type L, class FST>
     template <class ST>
-    inline auto xdynamic_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type /*l*/) const -> const_stepper
+    inline auto xdynamic_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type /*l*/) const
+        -> const_stepper
     {
         size_type offset = shape.size() - dimension();
         return const_stepper(this, offset, true);
@@ -583,8 +564,15 @@ namespace xt
         inner_strides_type str(base_type::strides());
         slice_vector_type svt(m_slices);
         inner_strides_type adj_str(m_adj_strides);
-        return rebind_t<E>(std::forward<E>(e), std::move(sh), std::move(str), 
-                           base_type::data_offset(), this->layout(), std::move(svt), std::move(adj_str));
+        return rebind_t<E>(
+            std::forward<E>(e),
+            std::move(sh),
+            std::move(str),
+            base_type::data_offset(),
+            this->layout(),
+            std::move(svt),
+            std::move(adj_str)
+        );
     }
 
     template <class CT, class S, layout_type L, class FST>
@@ -600,15 +588,17 @@ namespace xt
     }
 
     template <class CT, class S, layout_type L, class FST>
-    inline auto xdynamic_view<CT, S, L, FST>::data_xend(layout_type l) noexcept -> container_iterator
+    inline auto xdynamic_view<CT, S, L, FST>::data_xend(layout_type l, size_type offset) noexcept
+        -> container_iterator
     {
-        return data_xend_impl(this->storage().begin(), l);
+        return data_xend_impl(this->storage().begin(), l, offset);
     }
 
     template <class CT, class S, layout_type L, class FST>
-    inline auto xdynamic_view<CT, S, L, FST>::data_xend(layout_type l) const noexcept -> const_container_iterator
+    inline auto xdynamic_view<CT, S, L, FST>::data_xend(layout_type l, size_type offset) const noexcept
+        -> const_container_iterator
     {
-        return data_xend_impl(this->storage().cbegin(), l);
+        return data_xend_impl(this->storage().cbegin(), l, offset);
     }
 
     template <class CT, class S, layout_type L, class FST>
@@ -622,10 +612,10 @@ namespace xt
 
     template <class CT, class S, layout_type L, class FST>
     template <class It>
-    inline It xdynamic_view<CT, S, L, FST>::data_xend_impl(It begin, layout_type l) const noexcept
+    inline It
+    xdynamic_view<CT, S, L, FST>::data_xend_impl(It begin, layout_type l, size_type offset) const noexcept
     {
-        std::ptrdiff_t end_offset = static_cast<std::ptrdiff_t>(std::accumulate(this->backstrides().begin(), this->backstrides().end(), std::size_t(0)));
-        return strided_data_end(*this, begin + std::ptrdiff_t(data_offset()) + end_offset + 1, l);
+        return strided_data_end(*this, begin + std::ptrdiff_t(data_offset()), l, offset);
     }
 
     template <class CT, class S, layout_type L, class FST>
@@ -636,11 +626,14 @@ namespace xt
 
     template <class CT, class S, layout_type L, class FST>
     template <class T, class... Args>
-    inline auto xdynamic_view<CT, S, L, FST>::adjust_offset(offset_type offset, T idx, Args... args) const noexcept -> offset_type
+    inline auto
+    xdynamic_view<CT, S, L, FST>::adjust_offset(offset_type offset, T idx, Args... args) const noexcept
+        -> offset_type
     {
         constexpr size_type nb_args = sizeof...(Args) + 1;
         size_type dim = base_type::dimension();
-        offset_type res = nb_args > dim ? adjust_offset(offset, args...) : adjust_offset_impl(offset, dim - nb_args, idx, args...);
+        offset_type res = nb_args > dim ? adjust_offset(offset, args...)
+                                        : adjust_offset_impl(offset, dim - nb_args, idx, args...);
         return res;
     }
 
@@ -652,13 +645,18 @@ namespace xt
 
     template <class CT, class S, layout_type L, class FST>
     template <class T, class... Args>
-    inline auto xdynamic_view<CT, S, L, FST>::adjust_offset_impl(offset_type offset, size_type idx_offset, T idx, Args... args) const noexcept
-        -> offset_type
+    inline auto
+    xdynamic_view<CT, S, L, FST>::adjust_offset_impl(offset_type offset, size_type idx_offset, T idx, Args... args)
+        const noexcept -> offset_type
     {
-        offset_type sl_offset = xtl::visit([idx](const auto& sl) {
+        offset_type sl_offset = std::visit(
+            [idx](const auto& sl)
+            {
                 using type = typename std::decay_t<decltype(sl)>::size_type;
                 return sl(type(idx));
-        }, m_slices[idx_offset]);
+            },
+            m_slices[idx_offset]
+        );
         offset_type res = offset + sl_offset * m_adj_strides[idx_offset];
         return adjust_offset_impl(res, idx_offset + 1, args...);
     }
@@ -672,7 +670,9 @@ namespace xt
 
     template <class CT, class S, layout_type L, class FST>
     template <class It>
-    inline auto xdynamic_view<CT, S, L, FST>::adjust_element_offset(offset_type offset, It first, It last) const noexcept -> offset_type
+    inline auto
+    xdynamic_view<CT, S, L, FST>::adjust_element_offset(offset_type offset, It first, It last) const noexcept
+        -> offset_type
     {
         auto dst = std::distance(first, last);
         offset_type dim = static_cast<offset_type>(dimension());
@@ -682,7 +682,13 @@ namespace xt
         for (offset_type i = loop_offset; i < dim; ++i, ++first)
         {
             offset_type j = static_cast<offset_type>(first[idx_offset]);
-            offset_type sl_offset = xtl::visit([j](const auto& sl) { return static_cast<offset_type>(sl(j)); }, m_slices[static_cast<std::size_t>(i)]);
+            offset_type sl_offset = std::visit(
+                [j](const auto& sl)
+                {
+                    return static_cast<offset_type>(sl(j));
+                },
+                m_slices[static_cast<std::size_t>(i)]
+            );
             res += sl_offset * m_adj_strides[static_cast<std::size_t>(i)];
         }
         return res;
@@ -718,26 +724,52 @@ namespace xt
             }
 
             template <class ST, class S>
-            bool fill_args(const xdynamic_slice_vector& slices, std::size_t sl_idx,
-                           std::size_t i, std::size_t old_shape,
-                           const ST& old_stride,
-                           S& shape, get_strides_t<S>& strides)
+            bool fill_args(
+                const xdynamic_slice_vector& slices,
+                std::size_t sl_idx,
+                std::size_t i,
+                std::size_t old_shape,
+                const ST& old_stride,
+                S& shape,
+                get_strides_t<S>& strides
+            )
             {
-                return fill_args_impl<xkeep_slice<std::ptrdiff_t>>(slices, sl_idx, i, old_shape, old_stride, shape, strides)
-                    || fill_args_impl<xdrop_slice<std::ptrdiff_t>>(slices, sl_idx, i, old_shape, old_stride, shape, strides);
+                return fill_args_impl<xkeep_slice<std::ptrdiff_t>>(
+                           slices,
+                           sl_idx,
+                           i,
+                           old_shape,
+                           old_stride,
+                           shape,
+                           strides
+                       )
+                       || fill_args_impl<xdrop_slice<std::ptrdiff_t>>(
+                           slices,
+                           sl_idx,
+                           i,
+                           old_shape,
+                           old_stride,
+                           shape,
+                           strides
+                       );
             }
 
             template <class SL, class ST, class S>
-            bool fill_args_impl(const xdynamic_slice_vector& slices, std::size_t sl_idx,
-                                std::size_t i, std::size_t old_shape,
-                                const ST& old_stride,
-                                S& shape, get_strides_t<S>& strides)
+            bool fill_args_impl(
+                const xdynamic_slice_vector& slices,
+                std::size_t sl_idx,
+                std::size_t i,
+                std::size_t old_shape,
+                const ST& old_stride,
+                S& shape,
+                get_strides_t<S>& strides
+            )
             {
-                auto* sl = xtl::get_if<SL>(&slices[sl_idx]);
+                auto* sl = std::get_if<SL>(&slices[sl_idx]);
                 if (sl != nullptr)
                 {
                     new_slices[i] = *sl;
-                    auto& ns = xtl::get<SL>(new_slices[i]);
+                    auto& ns = std::get<SL>(new_slices[i]);
                     ns.normalize(old_shape);
                     shape[i] = static_cast<std::size_t>(ns.size());
                     strides[i] = std::ptrdiff_t(0);
@@ -755,9 +787,22 @@ namespace xt
         using slice_vector = typename view_type::slice_vector_type;
         using policy = detail::adj_strides_policy<slice_vector>;
         detail::strided_view_args<policy> args;
-        args.fill_args(e.shape(), detail::get_strides(e), detail::get_offset(e), e.layout(), slices);
-        return view_type(std::forward<E>(e), std::move(args.new_shape), std::move(args.new_strides), args.new_offset,
-                         args.new_layout, std::move(args.new_slices), std::move(args.new_adj_strides));
+        args.fill_args(
+            e.shape(),
+            detail::get_strides<XTENSOR_DEFAULT_TRAVERSAL>(e),
+            detail::get_offset<XTENSOR_DEFAULT_TRAVERSAL>(e),
+            e.layout(),
+            slices
+        );
+        return view_type(
+            std::forward<E>(e),
+            std::move(args.new_shape),
+            std::move(args.new_strides),
+            args.new_offset,
+            args.new_layout,
+            std::move(args.new_slices),
+            std::move(args.new_adj_strides)
+        );
     }
 }
 
diff --git a/include/xtensor/views/xfunctor_view.hpp b/include/xtensor/views/xfunctor_view.hpp
new file mode 100644
index 000000000..bedbbe828
--- /dev/null
+++ b/include/xtensor/views/xfunctor_view.hpp
@@ -0,0 +1,1649 @@
+/***************************************************************************
+ * 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_FUNCTOR_VIEW_HPP
+#define XTENSOR_FUNCTOR_VIEW_HPP
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+#include <xtl/xproxy_wrapper.hpp>
+
+#include "../containers/xarray.hpp"
+#include "../containers/xtensor.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterator.hpp"
+#include "../core/xsemantic.hpp"
+#include "../utils/xutils.hpp"
+
+namespace xt
+{
+    /**
+     * @defgroup xt_xfunctor_view Functor view
+     *
+     * Chunked array container.
+     * Defined in ``xtensor/xfunctor_view.hpp``
+     */
+
+    /************************************************
+     * xfunctor_view and xfunctor_adaptor extension *
+     ************************************************/
+
+    namespace extension
+    {
+        template <class Tag, class F, class CT>
+        struct xfunctor_view_base_impl;
+
+        template <class F, class CT>
+        struct xfunctor_view_base_impl<xtensor_expression_tag, F, CT>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class F, class CT>
+        struct xfunctor_view_base : xfunctor_view_base_impl<xexpression_tag_t<CT>, F, CT>
+        {
+        };
+
+        template <class F, class CT>
+        using xfunctor_view_base_t = typename xfunctor_view_base<F, CT>::type;
+    }
+
+    /*************************************
+     * xfunctor_applier_base declaration *
+     *************************************/
+
+    template <class F, class IT>
+    class xfunctor_iterator;
+
+    template <class F, class ST>
+    class xfunctor_stepper;
+
+    template <class D>
+    class xfunctor_applier_base : private xaccessible<D>
+    {
+    public:
+
+        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 = typename std::conditional_t<
+            strided_expression<xexpression_type>,
+            detail::expr_strides_type<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+        using backstrides_type = typename std::conditional_t<
+            strided_expression<xexpression_type>,
+            detail::expr_backstrides_type<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+
+        using inner_shape_type = typename xexpression_type::inner_shape_type;
+        using inner_strides_type = typename std::conditional_t<
+            strided_expression<xexpression_type>,
+            detail::expr_inner_strides_type<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+        using inner_backstrides_type = typename std::conditional_t<
+            strided_expression<xexpression_type>,
+            detail::expr_inner_backstrides_type<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+
+        using bool_load_type = xt::bool_load_type<value_type>;
+
+        static constexpr layout_type static_layout = xexpression_type::static_layout;
+        static constexpr bool contiguous_layout = xexpression_type::contiguous_layout;
+
+        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 = xfunctor_iterator<
+            const functor_type,
+            typename xexpression_type::template const_layout_iterator<L>>;
+
+        template <layout_type L>
+        using reverse_layout_iterator = xfunctor_iterator<
+            functor_type,
+            typename xexpression_type::template reverse_layout_iterator<L>>;
+        template <layout_type L>
+        using const_reverse_layout_iterator = xfunctor_iterator<
+            const functor_type,
+            typename xexpression_type::template const_reverse_layout_iterator<L>>;
+
+        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 = xfunctor_iterator<
+            functor_type,
+            xiterator<typename xexpression_type::const_stepper, S, L>>;
+
+        template <class S, layout_type L>
+        using reverse_broadcast_iterator = xfunctor_iterator<
+            functor_type,
+            typename xexpression_type::template reverse_broadcast_iterator<S, L>>;
+        template <class S, layout_type L>
+        using const_reverse_broadcast_iterator = xfunctor_iterator<
+            functor_type,
+            typename xexpression_type::template const_reverse_broadcast_iterator<S, L>>;
+
+        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 = xfunctor_iterator<
+            const functor_type,
+            typename xexpression_type::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>;
+
+        explicit xfunctor_applier_base(undecay_expression) noexcept;
+
+        template <class Func, class E>
+        xfunctor_applier_base(Func&&, E&&) noexcept;
+
+        size_type size() const noexcept;
+        const inner_shape_type& shape() const noexcept;
+        const inner_strides_type& strides() const noexcept;
+        const inner_backstrides_type& backstrides() const noexcept;
+        using accessible_base::dimension;
+        using accessible_base::shape;
+
+        layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+
+        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;
+
+        using accessible_base::at;
+        using accessible_base::operator[];
+        using accessible_base::back;
+        using accessible_base::front;
+        using accessible_base::periodic;
+
+        using accessible_base::in_bounds;
+
+        xexpression_type& expression() noexcept;
+        const xexpression_type& expression() const noexcept;
+
+        template <class S>
+        bool broadcast_shape(S& shape, bool reuse_cache = false) const;
+
+        template <class S>
+        bool has_linear_assign(const S& strides) const;
+
+        template <class FCT = functor_type>
+        auto data_element(size_type i)
+            -> decltype(std::declval<FCT>()(std::declval<undecay_expression>().data_element(i)))
+        {
+            return m_functor(m_e.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)))
+        {
+            return m_functor(m_e.data_element(i));
+        }
+
+        template <class FCT = functor_type>
+        auto flat(size_type i) -> decltype(std::declval<FCT>()(std::declval<undecay_expression>().flat(i)))
+        {
+            return m_functor(m_e.flat(i));
+        }
+
+        template <class FCT = functor_type>
+        auto flat(size_type i) const
+            -> decltype(std::declval<FCT>()(std::declval<const undecay_expression>().flat(i)))
+        {
+            return m_functor(m_e.flat(i));
+        }
+
+        // The following functions are defined inline because otherwise signatures
+        // don't match on GCC.
+        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
+            ))
+        {
+            return m_functor.template proxy_simd_load<align, requested_type, N>(m_e, 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))
+        {
+            return m_functor.template proxy_simd_store<align>(m_e, i, e);
+        }
+
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto begin() noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto end() noexcept;
+
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto begin() const noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto end() const noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto cbegin() const noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto cend() const noexcept;
+
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto rbegin() noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto rend() noexcept;
+
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto rbegin() const noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto rend() const noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto crbegin() const noexcept;
+        template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        auto crend() const noexcept;
+
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        broadcast_iterator<S, L> begin(const S& shape) noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        broadcast_iterator<S, L> end(const S& shape) noexcept;
+
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
+
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
+
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
+        template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
+        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
+
+        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>
+        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;
+
+    protected:
+
+        undecay_expression m_e;
+        functor_type m_functor;
+
+    private:
+
+        friend class xaccessible<D>;
+        friend class xconst_accessible<D>;
+    };
+
+    template <class D, class T>
+    struct has_simd_interface<xfunctor_applier_base<D>, T>
+        : std::conjunction<
+              has_simd_type<T>,
+              has_simd_interface<typename xfunctor_applier_base<D>::xexpression_type>,
+              detail::has_simd_interface_impl<xfunctor_applier_base<D>, T>>
+    {
+    };
+
+    /********************************
+     * xfunctor_view_temporary_type *
+     ********************************/
+
+    namespace detail
+    {
+        // TODO replace with xexpression_for_shape ...
+        template <class F, class S, layout_type L>
+        struct functorview_temporary_type_impl
+        {
+            using type = xarray<typename F::value_type, L>;
+        };
+
+        template <class F, class T, std::size_t N, layout_type L>
+        struct functorview_temporary_type_impl<F, std::array<T, N>, L>
+        {
+            using type = xtensor<typename F::value_type, N, L>;
+        };
+    }
+
+    template <class F, class E>
+    struct xfunctor_view_temporary_type
+    {
+        using type = typename detail::functorview_temporary_type_impl<F, typename E::shape_type, E::static_layout>::type;
+    };
+
+    /*****************************
+     * xfunctor_view declaration *
+     *****************************/
+
+    template <class F, class CT>
+    class xfunctor_view;
+
+    template <class F, class CT>
+    struct xcontainer_inner_types<xfunctor_view<F, CT>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using undecay_expression = CT;
+        using functor_type = std::decay_t<F>;
+        using reference = decltype(std::declval<F>()(std::declval<xexpression_type>()()));
+        using const_reference = decltype(std::declval<F>()(std::declval<const xexpression_type>()()));
+        using size_type = typename xexpression_type::size_type;
+        using temporary_type = typename xfunctor_view_temporary_type<F, xexpression_type>::type;
+    };
+
+    template <class F, class CT, class T>
+    struct has_simd_interface<xfunctor_view<F, CT>, T>
+        : has_simd_interface<xfunctor_applier_base<xfunctor_view<F, CT>>, T>
+    {
+    };
+
+    /**
+     * 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.
+     *
+     * @ingroup xt_xfunctor_view
+     * @tparam F the functor type to be applied to the elements of specified expression.
+     * @tparam CT the closure type of the xt::xexpression type underlying this view
+     * @see xt::real, xt::imag
+     */
+    template <class F, class CT>
+    class xfunctor_view : public xfunctor_applier_base<xfunctor_view<F, CT>>,
+                          public xview_semantic<xfunctor_view<F, CT>>,
+                          public extension::xfunctor_view_base_t<F, CT>
+    {
+    public:
+
+        using self_type = xfunctor_view<F, CT>;
+        using semantic_base = xview_semantic<self_type>;
+
+        // constructors
+        using xfunctor_applier_base<self_type>::xfunctor_applier_base;
+
+        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>
+        using rebind_t = xfunctor_view<F, E>;
+
+        template <class E>
+        rebind_t<E> build_functor_view(E&& e) const;
+
+    private:
+
+        using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type;
+        void assign_temporary_impl(temporary_type&& tmp);
+        friend class xview_semantic<self_type>;
+        friend class xaccessible<self_type>;
+    };
+
+    /********************************
+     * xfunctor_adaptor declaration *
+     ********************************/
+
+    template <class F, class CT>
+    class xfunctor_adaptor;
+
+    template <class F, class CT>
+    struct xcontainer_inner_types<xfunctor_adaptor<F, CT>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using undecay_expression = CT;
+        using functor_type = std::decay_t<F>;
+        using reference = typename functor_type::reference;
+        using const_reference = typename functor_type::const_reference;
+        using size_type = typename xexpression_type::size_type;
+        using temporary_type = typename xfunctor_view_temporary_type<F, xexpression_type>::type;
+    };
+
+    template <class F, class CT, class T>
+    struct has_simd_interface<xfunctor_adaptor<F, CT>, T>
+        : has_simd_interface<xfunctor_applier_base<xfunctor_adaptor<F, CT>>, T>
+    {
+    };
+
+    /**
+     * 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.
+     *
+     * @ingroup xt_xfunctor_view
+     * @tparam F the functor type to be applied to the elements of specified expression.
+     * @tparam CT the closure type of the xt::xexpression type underlying this view
+     * @see xt::xfunctor_view
+     */
+    template <class F, class CT>
+    class xfunctor_adaptor : public xfunctor_applier_base<xfunctor_adaptor<F, CT>>,
+                             public xcontainer_semantic<xfunctor_adaptor<F, CT>>,
+                             public extension::xfunctor_view_base_t<F, CT>
+    {
+    public:
+
+        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;
+        // constructors
+        using xfunctor_applier_base<self_type>::xfunctor_applier_base;
+
+        template <class E>
+        self_type& operator=(const xexpression<E>& e);
+
+        template <class E>
+        disable_xexpression<E, self_type>& operator=(const E& e);
+
+        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) &;
+
+    private:
+
+        using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type;
+        void assign_temporary_impl(temporary_type&& tmp);
+        friend class xcontainer_semantic<self_type>;
+        friend class xaccessible<self_type>;
+    };
+
+    /*********************************
+     * xfunctor_iterator declaration *
+     *********************************/
+
+    template <class R>
+    struct xproxy_inner_types
+    {
+        using reference = R;
+        using pointer = std::add_pointer_t<std::remove_reference_t<R>>;
+    };
+
+    namespace detail
+    {
+        template <class F, class IT>
+        struct xfunctor_invoker
+        {
+            using type = decltype(std::declval<F>()(*(std::declval<IT>())));
+        };
+
+        template <class F, class IT>
+        using xfunctor_invoker_t = typename xfunctor_invoker<F, IT>::type;
+    }
+
+    template <class F, class IT>
+    class xfunctor_iterator : public xtl::xrandom_access_iterator_base<
+                                  xfunctor_iterator<F, IT>,
+                                  typename std::decay_t<F>::value_type,
+                                  typename std::iterator_traits<IT>::difference_type,
+                                  typename xproxy_inner_types<detail::xfunctor_invoker_t<F, IT>>::pointer,
+                                  typename xproxy_inner_types<detail::xfunctor_invoker_t<F, IT>>::reference>
+    {
+    public:
+
+        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>;
+
+        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;
+
+    private:
+
+        IT m_it;
+        functor_type* p_functor;
+    };
+
+    template <class F, class IT>
+    bool operator==(const xfunctor_iterator<F, IT>& lhs, const xfunctor_iterator<F, IT>& rhs);
+
+    template <class F, class IT>
+    bool operator<(const xfunctor_iterator<F, IT>& lhs, const xfunctor_iterator<F, IT>& rhs);
+
+    /********************************
+     * xfunctor_stepper declaration *
+     ********************************/
+
+    template <class F, class ST>
+    class xfunctor_stepper
+    {
+    public:
+
+        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;
+
+        xfunctor_stepper() = default;
+        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);
+
+    private:
+
+        ST m_stepper;
+        functor_type* p_functor;
+    };
+
+    /****************************************
+     * xfunctor_applier_base implementation *
+     ****************************************/
+
+    /**
+     * @name Constructors
+     */
+    //@{
+
+    /**
+     * Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
+     *
+     * @param e the underlying expression
+     */
+    template <class D>
+    inline xfunctor_applier_base<D>::xfunctor_applier_base(undecay_expression e) noexcept
+        : m_e(e)
+        , m_functor(functor_type())
+    {
+    }
+
+    /**
+     * Constructs an xfunctor_applier_base expression wrappering the specified xt::xexpression.
+     *
+     * @param func the functor to be applied to the elements of the underlying expression.
+     * @param e the underlying expression
+     */
+    template <class D>
+    template <class Func, class E>
+    inline xfunctor_applier_base<D>::xfunctor_applier_base(Func&& func, E&& e) noexcept
+        : m_e(std::forward<E>(e))
+        , m_functor(std::forward<Func>(func))
+    {
+    }
+
+    //@}
+
+    /**
+     * @name Size and shape
+     */
+
+    /**
+     * Returns the size of the expression.
+     */
+    template <class D>
+    inline auto xfunctor_applier_base<D>::size() const noexcept -> size_type
+    {
+        return m_e.size();
+    }
+
+    /**
+     * Returns the shape of the expression.
+     */
+    template <class D>
+    inline auto xfunctor_applier_base<D>::shape() const noexcept -> const inner_shape_type&
+    {
+        return m_e.shape();
+    }
+
+    /**
+     * Returns the strides of the expression.
+     */
+    template <class D>
+    inline auto xfunctor_applier_base<D>::strides() const noexcept -> const inner_strides_type&
+    {
+        return m_e.strides();
+    }
+
+    /**
+     * Returns the backstrides of the expression.
+     */
+    template <class D>
+    inline auto xfunctor_applier_base<D>::backstrides() const noexcept -> const inner_backstrides_type&
+    {
+        return m_e.backstrides();
+    }
+
+    /**
+     * Returns the layout_type of the expression.
+     */
+    template <class D>
+    inline layout_type xfunctor_applier_base<D>::layout() const noexcept
+    {
+        return m_e.layout();
+    }
+
+    template <class D>
+    inline bool xfunctor_applier_base<D>::is_contiguous() const noexcept
+    {
+        return m_e.is_contiguous();
+    }
+
+    //@}
+
+    /**
+     * @name Data
+     */
+
+    /**
+     * Returns a reference to the element at the specified position in the expression.
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xfunctor_applier_base<D>::operator()(Args... args) -> reference
+    {
+        XTENSOR_TRY(check_index(shape(), args...));
+        XTENSOR_CHECK_DIMENSION(shape(), args...);
+        return m_functor(m_e(args...));
+    }
+
+    /**
+     * Returns a reference to the element at the specified position in the expression.
+     * @param args a 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.
+     * @warning This method is NOT compatible with broadcasting, meaning the following
+     * code has undefined behavior:
+     * @code{.cpp}
+     * xt::xarray<double> a = {{0, 1}, {2, 3}};
+     * xt::xarray<double> b = {0, 1};
+     * auto fd = a + b;
+     * double res = fd.unchecked(0, 1);
+     * @endcode
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xfunctor_applier_base<D>::unchecked(Args... args) -> reference
+    {
+        return m_functor(m_e.unchecked(args...));
+    }
+
+    /**
+     * Returns a reference to the element at the specified position in the expression.
+     * @param first iterator starting the sequence of indices
+     * @param last iterator 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.
+     */
+    template <class D>
+    template <class IT>
+    inline auto xfunctor_applier_base<D>::element(IT first, IT last) -> reference
+    {
+        XTENSOR_TRY(check_element_index(shape(), first, last));
+        return m_functor(m_e.element(first, last));
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the expression.
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xfunctor_applier_base<D>::operator()(Args... args) const -> const_reference
+    {
+        XTENSOR_TRY(check_index(shape(), args...));
+        XTENSOR_CHECK_DIMENSION(shape(), args...);
+        return m_functor(m_e(args...));
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the expression.
+     * @param args a 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.
+     * @warning This method is NOT compatible with broadcasting, meaning the following
+     * code has undefined behavior:
+     * @code{.cpp}
+     * xt::xarray<double> a = {{0, 1}, {2, 3}};
+     * xt::xarray<double> b = {0, 1};
+     * auto fd = a + b;
+     * double res = fd.uncheked(0, 1);
+     * @endcode
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xfunctor_applier_base<D>::unchecked(Args... args) const -> const_reference
+    {
+        return m_functor(m_e.unchecked(args...));
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the expression.
+     * @param first iterator starting the sequence of indices
+     * @param last iterator 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.
+     */
+    template <class D>
+    template <class IT>
+    inline auto xfunctor_applier_base<D>::element(IT first, IT last) const -> const_reference
+    {
+        XTENSOR_TRY(check_element_index(shape(), first, last));
+        return m_functor(m_e.element(first, last));
+    }
+
+    /**
+     * Returns a reference to the underlying expression of the view.
+     */
+    template <class D>
+    inline auto xfunctor_applier_base<D>::expression() noexcept -> xexpression_type&
+    {
+        return m_e;
+    }
+
+    /**
+     * Returns a consttant reference to the underlying expression of the view.
+     */
+    template <class D>
+    inline auto xfunctor_applier_base<D>::expression() const noexcept -> const xexpression_type&
+    {
+        return m_e;
+    }
+
+    //@}
+
+    /**
+     * @name Broadcasting
+     */
+    //@{
+    /**
+     * Broadcast the shape of the function to the specified parameter.
+     * @param shape the result shape
+     * @param reuse_cache boolean for reusing a previously computed shape
+     * @return a boolean indicating whether the broadcasting is trivial
+     */
+    template <class D>
+    template <class S>
+    inline bool xfunctor_applier_base<D>::broadcast_shape(S& shape, bool reuse_cache) const
+    {
+        return m_e.broadcast_shape(shape, reuse_cache);
+    }
+
+    /**
+     * Checks whether the xfunctor_applier_base can be linearly assigned to an expression
+     * with the specified strides.
+     *
+     * @return a boolean indicating whether a linear assign is possible
+     */
+    template <class D>
+    template <class S>
+    inline bool xfunctor_applier_base<D>::has_linear_assign(const S& strides) const
+    {
+        return m_e.has_linear_assign(strides);
+    }
+
+    //@}
+
+    /**
+     * @name Iterators
+     */
+    //@{
+    /**
+     * Returns an iterator to the first element of the expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::begin() noexcept
+    {
+        return xfunctor_iterator<functor_type, decltype(m_e.template begin<L>())>(
+            m_e.template begin<L>(),
+            &m_functor
+        );
+    }
+
+    /**
+     * Returns an iterator to the element following the last element
+     * of the expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::end() noexcept
+    {
+        return xfunctor_iterator<functor_type, decltype(m_e.template end<L>())>(m_e.template end<L>(), &m_functor);
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::begin() const noexcept
+    {
+        return this->template cbegin<L>();
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element
+     * of the expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::end() const noexcept
+    {
+        return this->template cend<L>();
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::cbegin() const noexcept
+    {
+        return xfunctor_iterator<const functor_type, decltype(m_e.template cbegin<L>())>(
+            m_e.template cbegin<L>(),
+            &m_functor
+        );
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element
+     * of the expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::cend() const noexcept
+    {
+        return xfunctor_iterator<const functor_type, decltype(m_e.template cend<L>())>(
+            m_e.template cend<L>(),
+            &m_functor
+        );
+    }
+
+    //@}
+
+    /**
+     * @name Broadcast iterators
+     */
+    //@{
+    /**
+     * Returns a constant iterator to the first element of the expression. The
+     * iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::begin(const S& shape) noexcept -> broadcast_iterator<S, L>
+    {
+        return broadcast_iterator<S, L>(m_e.template begin<S, L>(shape), &m_functor);
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element of the
+     * expression. The iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::end(const S& shape) noexcept -> broadcast_iterator<S, L>
+    {
+        return broadcast_iterator<S, L>(m_e.template end<S, L>(shape), &m_functor);
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the expression. The
+     * iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::begin(const S& shape) const noexcept
+        -> const_broadcast_iterator<S, L>
+    {
+        return cbegin<S, L>(shape);
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element of the
+     * expression. The iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::end(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    {
+        return cend<S, L>(shape);
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the expression. The
+     * iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::cbegin(const S& shape) const noexcept
+        -> const_broadcast_iterator<S, L>
+    {
+        return const_broadcast_iterator<S, L>(m_e.template cbegin<S, L>(shape), &m_functor);
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element of the
+     * expression. The iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::cend(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    {
+        return const_broadcast_iterator<S, L>(m_e.template cend<S, L>(shape), &m_functor);
+    }
+
+    //@}
+
+    /**
+     * @name Reverse iterators
+     */
+    //@{
+    /**
+     * Returns an iterator to the first element of the reversed expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::rbegin() noexcept
+    {
+        return xfunctor_iterator<functor_type, decltype(m_e.template rbegin<L>())>(
+            m_e.template rbegin<L>(),
+            &m_functor
+        );
+    }
+
+    /**
+     * Returns an iterator to the element following the last element
+     * of the reversed expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::rend() noexcept
+    {
+        return xfunctor_iterator<functor_type, decltype(m_e.template rend<L>())>(
+            m_e.template rend<L>(),
+            &m_functor
+        );
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the reversed expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::rbegin() const noexcept
+    {
+        return this->template crbegin<L>();
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element
+     * of the reversed expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::rend() const noexcept
+    {
+        return this->template crend<L>();
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the reversed expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::crbegin() const noexcept
+    {
+        return xfunctor_iterator<const functor_type, decltype(m_e.template crbegin<L>())>(
+            m_e.template crbegin<L>(),
+            &m_functor
+        );
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element
+     * of the reversed expression.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <layout_type L>
+    inline auto xfunctor_applier_base<D>::crend() const noexcept
+    {
+        return xfunctor_iterator<const functor_type, decltype(m_e.template crend<L>())>(
+            m_e.template crend<L>(),
+            &m_functor
+        );
+    }
+
+    //@}
+
+    /**
+     * @name Reverse broadcast iterators
+     */
+
+    /**
+     * Returns an iterator to the first element of the expression. The
+     * iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::rbegin(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    {
+        return reverse_broadcast_iterator<S, L>(m_e.template rbegin<S, L>(shape), &m_functor);
+    }
+
+    /**
+     * Returns an iterator to the element following the last element of the
+     * reversed expression. The iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::rend(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    {
+        return reverse_broadcast_iterator<S, L>(m_e.template rend<S, L>(shape), &m_functor);
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the reversed expression.
+     * The iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::rbegin(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
+    {
+        return crbegin<S, L>(shape);
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element
+     * of the reversed expression.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::rend(const S& /*shape*/) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
+    {
+        return crend<S, L>();
+    }
+
+    /**
+     * Returns a constant iterator to the first element of the reversed expression.
+     * The iteration is broadcasted to the specified shape.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::crbegin(const S& /*shape*/) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
+    {
+        return const_reverse_broadcast_iterator<S, L>(m_e.template crbegin<S, L>(), &m_functor);
+    }
+
+    /**
+     * Returns a constant iterator to the element following the last element
+     * of the reversed expression.
+     * @param shape the shape used for broadcasting
+     * @tparam S type of the \c shape parameter.
+     * @tparam L order used for the traversal. Default value is \c XTENSOR_DEFAULT_TRAVERSAL.
+     */
+    template <class D>
+    template <class S, layout_type L>
+    inline auto xfunctor_applier_base<D>::crend(const S& shape) const noexcept
+        -> const_reverse_broadcast_iterator<S, L>
+    {
+        return const_reverse_broadcast_iterator<S, L>(m_e.template crend<S, L>(shape), &m_functor);
+    }
+
+    //@}
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_begin() noexcept -> linear_iterator
+    {
+        return linear_iterator(m_e.linear_begin(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_end() noexcept -> linear_iterator
+    {
+        return linear_iterator(m_e.linear_end(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_begin() const noexcept -> const_linear_iterator
+    {
+        return const_linear_iterator(m_e.linear_begin(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_end() const noexcept -> const_linear_iterator
+    {
+        return const_linear_iterator(m_e.linear_end(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_cbegin() const noexcept -> const_linear_iterator
+    {
+        return const_linear_iterator(m_e.linear_cbegin(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_cend() const noexcept -> const_linear_iterator
+    {
+        return const_linear_iterator(m_e.linear_cend(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_rbegin() noexcept -> reverse_linear_iterator
+    {
+        return reverse_linear_iterator(m_e.linear_rbegin(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_rend() noexcept -> reverse_linear_iterator
+    {
+        return reverse_linear_iterator(m_e.linear_rend(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_rbegin() const noexcept -> const_reverse_linear_iterator
+    {
+        return const_reverse_linear_iterator(m_e.linear_rbegin(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_rend() const noexcept -> const_reverse_linear_iterator
+    {
+        return const_reverse_linear_iterator(m_e.linear_rend(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_crbegin() const noexcept -> const_reverse_linear_iterator
+    {
+        return const_reverse_linear_iterator(m_e.linear_crbegin(), &m_functor);
+    }
+
+    template <class D>
+    inline auto xfunctor_applier_base<D>::linear_crend() const noexcept -> const_reverse_linear_iterator
+    {
+        return const_reverse_linear_iterator(m_e.linear_crend(), &m_functor);
+    }
+
+    /***************
+     * stepper api *
+     ***************/
+
+    template <class D>
+    template <class S>
+    inline auto xfunctor_applier_base<D>::stepper_begin(const S& shape) noexcept -> stepper
+    {
+        return stepper(m_e.stepper_begin(shape), &m_functor);
+    }
+
+    template <class D>
+    template <class S>
+    inline auto xfunctor_applier_base<D>::stepper_end(const S& shape, layout_type l) noexcept -> stepper
+    {
+        return stepper(m_e.stepper_end(shape, l), &m_functor);
+    }
+
+    template <class D>
+    template <class S>
+    inline auto xfunctor_applier_base<D>::stepper_begin(const S& shape) const noexcept -> const_stepper
+    {
+        const xexpression_type& const_m_e = m_e;
+        return const_stepper(const_m_e.stepper_begin(shape), &m_functor);
+    }
+
+    template <class D>
+    template <class S>
+    inline auto xfunctor_applier_base<D>::stepper_end(const S& shape, layout_type l) const noexcept
+        -> const_stepper
+    {
+        const xexpression_type& const_m_e = m_e;
+        return const_stepper(const_m_e.stepper_end(shape, l), &m_functor);
+    }
+
+    /********************************
+     * xfunctor_view implementation *
+     ********************************/
+
+    /**
+     * @name Extended copy semantic
+     */
+    //@{
+    /**
+     * The extended assignment operator.
+     */
+    template <class F, class CT>
+    template <class E>
+    inline auto xfunctor_view<F, CT>::operator=(const xexpression<E>& e) -> self_type&
+    {
+        bool cond = (e.derived_cast().shape().size() == this->dimension())
+                    && std::equal(this->shape().begin(), this->shape().end(), e.derived_cast().shape().begin());
+        if (!cond)
+        {
+            semantic_base::operator=(broadcast(e.derived_cast(), this->shape()));
+        }
+        else
+        {
+            semantic_base::operator=(e);
+        }
+        return *this;
+    }
+
+    //@}
+
+    template <class F, class CT>
+    template <class E>
+    inline auto xfunctor_view<F, CT>::operator=(const E& e) -> disable_xexpression<E, self_type>&
+    {
+        std::fill(this->begin(), this->end(), e);
+        return *this;
+    }
+
+    template <class F, class CT>
+    inline void xfunctor_view<F, CT>::assign_temporary_impl(temporary_type&& tmp)
+    {
+        std::copy(tmp.cbegin(), tmp.cend(), this->begin());
+    }
+
+    template <class F, class CT>
+    template <class E>
+    inline auto xfunctor_view<F, CT>::build_functor_view(E&& e) const -> rebind_t<E>
+    {
+        return rebind_t<E>((this->m_functor), std::forward<E>(e));
+    }
+
+    /***********************************
+     * xfunctor_adaptor implementation *
+     ***********************************/
+
+    /**
+     * @name Extended copy semantic
+     */
+    //@{
+    /**
+     * The extended assignment operator.
+     */
+    template <class F, class CT>
+    template <class E>
+    inline auto xfunctor_adaptor<F, CT>::operator=(const xexpression<E>& e) -> self_type&
+    {
+        const auto& de = e.derived_cast();
+        this->m_e.resize(de.shape());
+
+        if (this->layout() == de.layout())
+        {
+            std::copy(de.linear_begin(), de.linear_end(), this->linear_begin());
+        }
+        else
+        {
+            // note: does this even select the current layout of *this* for iteration?
+            std::copy(de.begin(), de.end(), this->begin());
+        }
+
+        return *this;
+    }
+
+    //@}
+
+    template <class F, class CT>
+    template <class S>
+    auto xfunctor_adaptor<F, CT>::resize(S&& shape, bool force)
+    {
+        this->m_e.resize(std::forward<S>(shape), force);
+    }
+
+    template <class F, class CT>
+    template <class S>
+    auto xfunctor_adaptor<F, CT>::resize(S&& shape, layout_type l)
+    {
+        this->m_e.resize(std::forward<S>(shape), l);
+    }
+
+    template <class F, class CT>
+    template <class S>
+    auto xfunctor_adaptor<F, CT>::resize(S&& shape, const strides_type& strides)
+    {
+        this->m_e.resize(std::forward<S>(shape), strides);
+    }
+
+    template <class F, class CT>
+    template <class S>
+    auto& xfunctor_adaptor<F, CT>::reshape(S&& shape, layout_type layout) &
+    {
+        this->m_e.reshape(std::forward<S>(shape), layout);
+        return *this;
+    }
+
+    /************************************
+     * xfunctor_iterator implementation *
+     ************************************/
+
+    template <class F, class IT>
+    xfunctor_iterator<F, IT>::xfunctor_iterator(const IT& it, functor_type* pf)
+        : m_it(it)
+        , p_functor(pf)
+    {
+    }
+
+    template <class F, class IT>
+    inline auto xfunctor_iterator<F, IT>::operator++() -> self_type&
+    {
+        ++m_it;
+        return *this;
+    }
+
+    template <class F, class IT>
+    inline auto xfunctor_iterator<F, IT>::operator--() -> self_type&
+    {
+        --m_it;
+        return *this;
+    }
+
+    template <class F, class IT>
+    inline auto xfunctor_iterator<F, IT>::operator+=(difference_type n) -> self_type&
+    {
+        m_it += n;
+        return *this;
+    }
+
+    template <class F, class IT>
+    inline auto xfunctor_iterator<F, IT>::operator-=(difference_type n) -> self_type&
+    {
+        m_it -= n;
+        return *this;
+    }
+
+    template <class F, class IT>
+    inline auto xfunctor_iterator<F, IT>::operator-(xfunctor_iterator rhs) const -> difference_type
+    {
+        return m_it - rhs.m_it;
+    }
+
+    template <class F, class IT>
+    auto xfunctor_iterator<F, IT>::operator*() const -> reference
+    {
+        return (*p_functor)(*m_it);
+    }
+
+    template <class F, class IT>
+    auto xfunctor_iterator<F, IT>::operator->() const -> pointer
+    {
+        return &(operator*());
+    }
+
+    template <class F, class IT>
+    auto xfunctor_iterator<F, IT>::equal(const xfunctor_iterator& rhs) const -> bool
+    {
+        return m_it == rhs.m_it;
+    }
+
+    template <class F, class IT>
+    auto xfunctor_iterator<F, IT>::less_than(const xfunctor_iterator& rhs) const -> bool
+    {
+        return m_it < rhs.m_it;
+    }
+
+    template <class F, class IT>
+    bool operator==(const xfunctor_iterator<F, IT>& lhs, const xfunctor_iterator<F, IT>& rhs)
+    {
+        return lhs.equal(rhs);
+    }
+
+    template <class F, class IT>
+    bool operator<(const xfunctor_iterator<F, IT>& lhs, const xfunctor_iterator<F, IT>& rhs)
+    {
+        return !lhs.less_than(rhs);
+    }
+
+    /***********************************
+     * xfunctor_stepper implementation *
+     ***********************************/
+
+    template <class F, class ST>
+    xfunctor_stepper<F, ST>::xfunctor_stepper(const ST& stepper, functor_type* pf)
+        : m_stepper(stepper)
+        , p_functor(pf)
+    {
+    }
+
+    template <class F, class ST>
+    auto xfunctor_stepper<F, ST>::operator*() const -> reference
+    {
+        return (*p_functor)(*m_stepper);
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::step(size_type dim)
+    {
+        m_stepper.step(dim);
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::step_back(size_type dim)
+    {
+        m_stepper.step_back(dim);
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::step(size_type dim, size_type n)
+    {
+        m_stepper.step(dim, n);
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::step_back(size_type dim, size_type n)
+    {
+        m_stepper.step_back(dim, n);
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::reset(size_type dim)
+    {
+        m_stepper.reset(dim);
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::reset_back(size_type dim)
+    {
+        m_stepper.reset_back(dim);
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::to_begin()
+    {
+        m_stepper.to_begin();
+    }
+
+    template <class F, class ST>
+    void xfunctor_stepper<F, ST>::to_end(layout_type l)
+    {
+        m_stepper.to_end(l);
+    }
+}
+#endif
diff --git a/include/xtensor/xindex_view.hpp b/include/xtensor/views/xindex_view.hpp
similarity index 87%
rename from include/xtensor/xindex_view.hpp
rename to include/xtensor/views/xindex_view.hpp
index ae59e3dab..6701d3bf3 100644
--- a/include/xtensor/xindex_view.hpp
+++ b/include/xtensor/views/xindex_view.hpp
@@ -1,24 +1,27 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_VIEW_HPP
 #define XTENSOR_INDEX_VIEW_HPP
 
 #include <algorithm>
+#include <array>
 #include <cstddef>
-#include <tuple>
 #include <type_traits>
 #include <utility>
 
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xstrides.hpp"
-#include "xutils.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xoperation.hpp"
+#include "../core/xsemantic.hpp"
+#include "../core/xstrides.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
@@ -39,8 +42,7 @@ namespace xt
         };
 
         template <class CT, class I>
-        struct xindex_view_base
-            : xindex_view_base_impl<xexpression_tag_t<CT>, CT, I>
+        struct xindex_view_base : xindex_view_base_impl<xexpression_tag_t<CT>, CT, I>
         {
         };
 
@@ -94,12 +96,12 @@ namespace xt
         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 = typename xexpression_type::reference;
+        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;
@@ -118,6 +120,8 @@ namespace xt
         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;
+
         static constexpr layout_type static_layout = layout_type::dynamic;
         static constexpr bool contiguous_layout = false;
 
@@ -133,7 +137,9 @@ namespace xt
         size_type size() const noexcept;
         size_type dimension() const noexcept;
         const inner_shape_type& shape() const noexcept;
+        size_type shape(size_type index) const;
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
 
         template <class T>
         void fill(const T& value);
@@ -279,9 +285,12 @@ namespace xt
     template <class CT, class I>
     template <class CTA, class I2>
     inline xindex_view<CT, I>::xindex_view(CTA&& e, I2&& indices) noexcept
-        : m_e(std::forward<CTA>(e)), m_indices(std::forward<I2>(indices)), m_shape({ m_indices.size() })
+        : m_e(std::forward<CTA>(e))
+        , m_indices(std::forward<I2>(indices))
+        , m_shape({m_indices.size()})
     {
     }
+
     //@}
 
     /**
@@ -297,6 +306,7 @@ namespace xt
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     template <class CT, class I>
@@ -344,12 +354,27 @@ namespace xt
         return m_shape;
     }
 
+    /**
+     * Returns the i-th dimension of the expression.
+     */
+    template <class CT, class I>
+    inline auto xindex_view<CT, I>::shape(size_type i) const -> size_type
+    {
+        return m_shape[i];
+    }
+
     template <class CT, class I>
     inline layout_type xindex_view<CT, I>::layout() const noexcept
     {
         return static_layout;
     }
 
+    template <class CT, class I>
+    inline bool xindex_view<CT, I>::is_contiguous() const noexcept
+    {
+        return false;
+    }
+
     //@}
 
     /**
@@ -432,16 +457,14 @@ namespace xt
      */
     template <class CT, class I>
     template <class S>
-    inline auto xindex_view<CT, I>::operator[](const S& index)
-        -> disable_integral_t<S, reference>
+    inline auto xindex_view<CT, I>::operator[](const S& index) -> disable_integral_t<S, reference>
     {
         return m_e[m_indices[index[0]]];
     }
 
     template <class CT, class I>
     template <class OI>
-    inline auto xindex_view<CT, I>::operator[](std::initializer_list<OI> index)
-        -> reference
+    inline auto xindex_view<CT, I>::operator[](std::initializer_list<OI> index) -> reference
     {
         return m_e[m_indices[*(index.begin())]];
     }
@@ -460,16 +483,14 @@ namespace xt
      */
     template <class CT, class I>
     template <class S>
-    inline auto xindex_view<CT, I>::operator[](const S& index) const
-        -> disable_integral_t<S, const_reference>
+    inline auto xindex_view<CT, I>::operator[](const S& index) const -> disable_integral_t<S, const_reference>
     {
         return m_e[m_indices[index[0]]];
     }
 
     template <class CT, class I>
     template <class OI>
-    inline auto xindex_view<CT, I>::operator[](std::initializer_list<OI> index) const
-        -> const_reference
+    inline auto xindex_view<CT, I>::operator[](std::initializer_list<OI> index) const -> const_reference
     {
         return m_e[m_indices[*(index.begin())]];
     }
@@ -483,7 +504,8 @@ namespace xt
     /**
      * Returns a reference to the element at the specified position in the xindex_view.
      * @param first iterator starting the sequence of indices
-     * The number of indices in the sequence should be equal to or greater 1.
+     * @param last iterator 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.
      */
     template <class CT, class I>
     template <class It>
@@ -495,7 +517,8 @@ namespace xt
     /**
      * Returns a reference to the element at the specified position in the xindex_view.
      * @param first iterator starting the sequence of indices
-     * The number of indices in the sequence should be equal to or greater 1.
+     * @param last iterator 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.
      */
     template <class CT, class I>
     template <class It>
@@ -521,6 +544,7 @@ namespace xt
     {
         return m_e;
     }
+
     //@}
 
     /**
@@ -551,6 +575,7 @@ namespace xt
     {
         return false;
     }
+
     //@}
 
     /***************
@@ -614,9 +639,11 @@ namespace xt
     template <class ECT, class CCT>
     template <class ECTA, class CCTA>
     inline xfiltration<ECT, CCT>::xfiltration(ECTA&& e, CCTA&& condition)
-        : m_e(std::forward<ECTA>(e)), m_condition(std::forward<CCTA>(condition))
+        : m_e(std::forward<ECTA>(e))
+        , m_condition(std::forward<CCTA>(condition))
     {
     }
+
     //@}
 
     /**
@@ -632,8 +659,14 @@ namespace xt
     template <class E>
     inline auto xfiltration<ECT, CCT>::operator=(const E& e) -> disable_xexpression<E, self_type&>
     {
-        return apply([this, &e](const_reference v, bool cond) { return cond ? e : v; });
+        return apply(
+            [this, &e](const_reference v, bool cond)
+            {
+                return cond ? e : v;
+            }
+        );
     }
+
     //@}
 
     /**
@@ -649,7 +682,12 @@ namespace xt
     template <class E>
     inline auto xfiltration<ECT, CCT>::operator+=(const E& e) -> disable_xexpression<E, self_type&>
     {
-        return apply([&e](const_reference v, bool cond) { return cond ? v + e : v; });
+        return apply(
+            [&e](const_reference v, bool cond)
+            {
+                return cond ? v + e : v;
+            }
+        );
     }
 
     /**
@@ -661,7 +699,12 @@ namespace xt
     template <class E>
     inline auto xfiltration<ECT, CCT>::operator-=(const E& e) -> disable_xexpression<E, self_type&>
     {
-        return apply([&e](const_reference v, bool cond) { return cond ? v - e : v; });
+        return apply(
+            [&e](const_reference v, bool cond)
+            {
+                return cond ? v - e : v;
+            }
+        );
     }
 
     /**
@@ -673,7 +716,12 @@ namespace xt
     template <class E>
     inline auto xfiltration<ECT, CCT>::operator*=(const E& e) -> disable_xexpression<E, self_type&>
     {
-        return apply([&e](const_reference v, bool cond) { return cond ? v * e : v; });
+        return apply(
+            [&e](const_reference v, bool cond)
+            {
+                return cond ? v * e : v;
+            }
+        );
     }
 
     /**
@@ -685,7 +733,12 @@ namespace xt
     template <class E>
     inline auto xfiltration<ECT, CCT>::operator/=(const E& e) -> disable_xexpression<E, self_type&>
     {
-        return apply([&e](const_reference v, bool cond) { return cond ? v / e : v; });
+        return apply(
+            [&e](const_reference v, bool cond)
+            {
+                return cond ? v / e : v;
+            }
+        );
     }
 
     /**
@@ -697,7 +750,12 @@ namespace xt
     template <class E>
     inline auto xfiltration<ECT, CCT>::operator%=(const E& e) -> disable_xexpression<E, self_type&>
     {
-        return apply([&e](const_reference v, bool cond) { return cond ? v % e : v; });
+        return apply(
+            [&e](const_reference v, bool cond)
+            {
+                return cond ? v % e : v;
+            }
+        );
     }
 
     template <class ECT, class CCT>
@@ -716,13 +774,13 @@ namespace xt
      * @param e the underlying xexpression
      * @param indices the indices to select
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xarray<double> a = {{1,5,3}, {4,5,6}};
      * b = index_view(a, {{0, 0}, {1, 0}, {1, 1}});
      * std::cout << b << std::endl; // {1, 4, 5}
      * b += 100;
      * std::cout << a << std::endl; // {{101, 5, 3}, {104, 105, 6}}
-     * \endcode
+     * @endcode
      */
     template <class E, class I>
     inline auto index_view(E&& e, I&& indices) noexcept
@@ -730,26 +788,13 @@ namespace xt
         using view_type = xindex_view<xclosure_t<E>, std::decay_t<I>>;
         return view_type(std::forward<E>(e), std::forward<I>(indices));
     }
-#ifdef X_OLD_CLANG
-    template <class E, class I>
-    inline auto index_view(E&& e, std::initializer_list<std::initializer_list<I>> indices) noexcept
-    {
-        std::vector<xindex> idx;
-        for (auto it = indices.begin(); it != indices.end(); ++it)
-        {
-            idx.emplace_back(xindex(it->begin(), it->end()));
-        }
-        using view_type = xindex_view<xclosure_t<E>, std::vector<xindex>>;
-        return view_type(std::forward<E>(e), std::move(idx));
-    }
-#else
+
     template <class E, std::size_t L>
     inline auto index_view(E&& e, const xindex (&indices)[L]) noexcept
     {
         using view_type = xindex_view<xclosure_t<E>, std::array<xindex, L>>;
-        return view_type(std::forward<E>(e), to_array(indices));
+        return view_type(std::forward<E>(e), xt::to_array(indices));
     }
-#endif
 
     /**
      * @brief creates a view into \a e filtered by \a condition.
@@ -760,21 +805,22 @@ namespace xt
      * elements. In that case, you should consider using the \ref filtration function
      * instead.
      *
+     * @tparam L the traversal order
      * @param e the underlying xexpression
      * @param condition xexpression with shape of \a e which selects indices
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xarray<double> a = {{1,5,3}, {4,5,6}};
      * b = filter(a, a >= 5);
      * std::cout << b << std::endl; // {5, 5, 6}
-     * \endcode
+     * @endcode
      *
      * \sa filtration
      */
-    template <class E, class O>
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E, class O>
     inline auto filter(E&& e, O&& condition) noexcept
     {
-        auto indices = argwhere(std::forward<O>(condition));
+        auto indices = argwhere<L>(std::forward<O>(condition));
         using view_type = xindex_view<xclosure_t<E>, decltype(indices)>;
         return view_type(std::forward<E>(e), std::move(indices));
     }
@@ -790,11 +836,11 @@ namespace xt
      * @param e the \ref xexpression to filter
      * @param condition the filtering \ref xexpression
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xarray<double> a = {{1,5,3}, {4,5,6}};
      * filtration(a, a >= 5) += 2;
      * std::cout << a << std::endl; // {{1, 7, 3}, {4, 7, 8}}
-     * \endcode
+     * @endcode
      */
     template <class E, class C>
     inline auto filtration(E&& e, C&& condition) noexcept
diff --git a/include/xtensor/xmasked_view.hpp b/include/xtensor/views/xmasked_view.hpp
similarity index 72%
rename from include/xtensor/xmasked_view.hpp
rename to include/xtensor/views/xmasked_view.hpp
index a8759e538..05210d8c8 100644
--- a/include/xtensor/xmasked_view.hpp
+++ b/include/xtensor/views/xmasked_view.hpp
@@ -1,22 +1,23 @@
 /***************************************************************************
-* Copyright (c) 2017, 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. *
-****************************************************************************/
+ * 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_XMASKED_VIEW_HPP
 #define XTENSOR_XMASKED_VIEW_HPP
 
-#include "xmasked_value.hpp"
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xutils.hpp"
-#include "xshape.hpp"
-#include "xsemantic.hpp"
-#include "xtensor_forward.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xsemantic.hpp"
+#include "../core/xshape.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../utils/xutils.hpp"
+#include "xtl/xmasked_value.hpp"
 
 namespace xt
 {
@@ -36,9 +37,17 @@ namespace xt
     template <class CTD, class CTM>
     struct xcontainer_inner_types<xmasked_view<CTD, CTM>>
     {
-        using base_value_type = typename std::decay_t<CTD>::value_type;
-        using flag_type = typename std::decay_t<CTM>::value_type;
-        using temporary_type = xarray<xmasked_value<base_value_type, flag_type>>;
+        using data_type = std::decay_t<CTD>;
+        using mask_type = std::decay_t<CTM>;
+        using base_value_type = typename data_type::value_type;
+        using flag_type = typename mask_type::value_type;
+        using val_reference = inner_reference_t<CTD>;
+        using mask_reference = inner_reference_t<CTM>;
+        using value_type = xtl::xmasked_value<base_value_type, flag_type>;
+        using reference = xtl::xmasked_value<val_reference, mask_reference>;
+        using const_reference = xtl::xmasked_value<typename data_type::const_reference, typename mask_type::const_reference>;
+        using size_type = typename data_type::size_type;
+        using temporary_type = xarray<xtl::xmasked_value<base_value_type, flag_type>>;
     };
 
     template <class CTD, class CTM>
@@ -67,48 +76,47 @@ namespace xt
      */
     template <class CTD, class CTM>
     class xmasked_view : public xview_semantic<xmasked_view<CTD, CTM>>,
+                         private xaccessible<xmasked_view<CTD, CTM>>,
                          private xiterable<xmasked_view<CTD, CTM>>
     {
     public:
 
         using self_type = xmasked_view<CTD, CTM>;
         using semantic_base = xview_semantic<xmasked_view<CTD, CTM>>;
-        using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type;
+        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 = std::decay_t<CTD>;
-        using mask_type = std::decay_t<CTM>;
+        using data_type = typename inner_types::data_type;
+        using mask_type = typename inner_types::mask_type;
         using value_expression = CTD;
         using mask_expression = CTM;
 
         static constexpr bool is_data_const = std::is_const<std::remove_reference_t<value_expression>>::value;
 
-        using base_value_type = typename data_type::value_type;
+        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 mask_type::value_type;
+        using flag_type = typename inner_types::flag_type;
         using flag_reference = typename mask_type::reference;
         using flag_const_reference = typename mask_type::const_reference;
 
-        static constexpr bool is_val_const = std::is_const<data_type>::value;
-        static constexpr bool is_flag_const = std::is_const<mask_type>::value;
-        using val_reference = std::conditional_t<is_val_const,
-                                                 typename data_type::const_reference,
-                                                 typename data_type::reference>;
-        using mask_reference = std::conditional_t<is_flag_const,
-                                                  typename mask_type::const_reference,
-                                                  typename mask_type::reference>;
+        using val_reference = typename inner_types::val_reference;
+        using mask_reference = typename inner_types::mask_reference;
 
-        using value_type = xmasked_value<base_value_type, flag_type>;
-        using reference = xmasked_value<val_reference, mask_reference>;
-        using const_reference = xmasked_value<typename data_type::const_reference, typename mask_type::const_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 data_type::size_type;
+        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;
 
@@ -151,14 +159,17 @@ namespace xt
         template <class D, class M>
         xmasked_view(D&& data, M&& mask);
 
-        size_type size() const noexcept;
-        constexpr size_type dimension() const noexcept;
+        xmasked_view(const xmasked_view&) = default;
 
+        size_type size() const noexcept;
         const inner_shape_type& shape() const noexcept;
         const inner_strides_type& strides() const noexcept;
         const inner_backstrides_type& backstrides() const noexcept;
+        using accessible_base::dimension;
+        using accessible_base::shape;
 
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
 
         template <class T>
         void fill(const T& value);
@@ -169,29 +180,18 @@ namespace xt
         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);
-        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;
+        using accessible_base::at;
+        using accessible_base::operator[];
+        using accessible_base::back;
+        using accessible_base::front;
+        using accessible_base::in_bounds;
+        using accessible_base::periodic;
 
         template <class It>
         reference element(It first, It last);
@@ -199,6 +199,9 @@ namespace xt
         template <class It>
         const_reference element(It first, It last) const;
 
+        template <class S>
+        bool has_linear_assign(const S& strides) const noexcept;
+
         data_type& value() noexcept;
         const data_type& value() const noexcept;
 
@@ -206,13 +209,13 @@ namespace xt
         const mask_type& visible() const noexcept;
 
         using iterable_base::begin;
-        using iterable_base::end;
         using iterable_base::cbegin;
         using iterable_base::cend;
-        using iterable_base::rbegin;
-        using iterable_base::rend;
         using iterable_base::crbegin;
         using iterable_base::crend;
+        using iterable_base::end;
+        using iterable_base::rbegin;
+        using iterable_base::rend;
 
         template <class S>
         stepper stepper_begin(const S& shape) noexcept;
@@ -224,6 +227,8 @@ namespace xt
         template <class S>
         const_stepper stepper_end(const S& shape, layout_type l) const noexcept;
 
+        self_type& operator=(const self_type& rhs);
+
         template <class E>
         self_type& operator=(const xexpression<E>& e);
 
@@ -237,9 +242,11 @@ namespace xt
 
         void assign_temporary_impl(temporary_type&& tmp);
 
-        friend class xiterable<xmasked_view<CTD, CTM>>;
-        friend class xconst_iterable<xmasked_view<CTD, CTM>>;
-        friend class xview_semantic<xmasked_view<CTD, CTM>>;
+        friend class xiterable<self_type>;
+        friend class xconst_iterable<self_type>;
+        friend class xview_semantic<self_type>;
+        friend class xaccessible<self_type>;
+        friend class xconst_accessible<self_type>;
     };
 
     template <class D, bool is_const>
@@ -250,22 +257,16 @@ namespace xt
         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 = std::conditional_t<is_const,
-                                             typename masked_view_type::const_reference,
-                                             typename masked_view_type::reference>;
-        using pointer = std::conditional_t<is_const,
-                                           typename masked_view_type::const_pointer,
-                                           typename masked_view_type::pointer>;
+        using reference = std::
+            conditional_t<is_const, typename masked_view_type::const_reference, typename masked_view_type::reference>;
+        using pointer = std::
+            conditional_t<is_const, typename masked_view_type::const_pointer, typename masked_view_type::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>;
+        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>;
 
         xmasked_view_stepper(value_stepper vs, mask_stepper fs) noexcept;
 
@@ -306,8 +307,8 @@ namespace xt
     template <class CTD, class CTM>
     template <class D, class M>
     inline xmasked_view<CTD, CTM>::xmasked_view(D&& data, M&& mask)
-        : m_data(std::forward<D>(data)),
-          m_mask(std::forward<M>(mask))
+        : m_data(std::forward<D>(data))
+        , m_mask(std::forward<M>(mask))
     {
     }
 
@@ -315,15 +316,6 @@ namespace xt
      * @name Size and shape
      */
     //@{
-    /**
-     * Returns the number of dimensions of the xmasked_view.
-     */
-    template <class CTD, class CTM>
-    inline constexpr auto xmasked_view<CTD, CTM>::dimension() const noexcept -> size_type
-    {
-        return m_data.dimension();
-    }
-
     /**
      * Returns the number of elements in the xmasked_view.
      */
@@ -359,6 +351,7 @@ namespace xt
     {
         return m_data.backstrides();
     }
+
     //@}
 
     /**
@@ -371,6 +364,12 @@ namespace xt
         return m_data.layout();
     }
 
+    template <class CTD, class CTM>
+    inline bool xmasked_view<CTD, CTM>::is_contiguous() const noexcept
+    {
+        return false;
+    }
+
     /**
      * Fills the data with the given value.
      * @param value the value to fill the data with.
@@ -412,40 +411,6 @@ namespace xt
         return const_reference(m_data(args...), m_mask(args...));
     }
 
-    /**
-     * Returns a reference to the element at the specified position in the xmasked_view,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the xmasked_view. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the xmasked_view.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class CTD, class CTM>
-    template <class... Args>
-    inline auto xmasked_view<CTD, CTM>::at(Args... args) -> reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return reference(m_data(args...), m_mask(args...));
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the xmasked_view,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the xmasked_view. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the xmasked_view.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class CTD, class CTM>
-    template <class... Args>
-    inline auto xmasked_view<CTD, CTM>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return const_reference(m_data(args...), m_mask(args...));
-    }
-
     /**
      * Returns a reference to the element at the specified position in the  xmasked_view.
      * @param args a list of indices specifying the position in the  xmasked_view. Indices
@@ -454,16 +419,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class CTD, class CTM>
     template <class... Args>
@@ -480,16 +445,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.uncheked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class CTD, class CTM>
     template <class... Args>
@@ -498,58 +463,6 @@ namespace xt
         return const_reference(m_data.unchecked(args...), m_mask.unchecked(args...));
     }
 
-    /**
-     * Returns a reference to the element at the specified position in the xmasked_view.
-     * @param index a sequence of indices specifying the position in the xmasked_view. Indices
-     * must be unsigned integers, the number of indices in the list should be equal or greater
-     * than the number of dimensions of the xmasked_view.
-     */
-    template <class CTD, class CTM>
-    template <class S>
-    inline auto xmasked_view<CTD, CTM>::operator[](const S& index) -> disable_integral_t<S, reference>
-    {
-        return disable_integral_t<S, reference>(m_data[index], m_mask[index]);
-    }
-
-    template <class CTD, class CTM>
-    template <class I>
-    inline auto xmasked_view<CTD, CTM>::operator[](std::initializer_list<I> index) -> reference
-    {
-        return reference(m_data[index], m_mask[index]);
-    }
-
-    template <class CTD, class CTM>
-    inline auto xmasked_view<CTD, CTM>::operator[](size_type i) -> reference
-    {
-        return reference(m_data[i], m_mask[i]);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the xmasked_view.
-     * @param index a sequence of indices specifying the position in the xmasked_view. Indices
-     * must be unsigned integers, the number of indices in the list should be equal or greater
-     * than the number of dimensions of the xmasked_view.
-     */
-    template <class CTD, class CTM>
-    template <class S>
-    inline auto xmasked_view<CTD, CTM>::operator[](const S& index) const -> disable_integral_t<S, const_reference>
-    {
-        return disable_integral_t<S, const_reference>(m_data[index], m_mask[index]);
-    }
-
-    template <class CTD, class CTM>
-    template <class I>
-    inline auto xmasked_view<CTD, CTM>::operator[](std::initializer_list<I> index) const -> const_reference
-    {
-        return const_reference(m_data[index], m_mask[index]);
-    }
-
-    template <class CTD, class CTM>
-    inline auto xmasked_view<CTD, CTM>::operator[](size_type i) const -> const_reference
-    {
-        return const_reference(m_data[i], m_mask[i]);
-    }
-
     /**
      * Returns a reference to the element at the specified position in the xmasked_view.
      * @param first iterator starting the sequence of indices
@@ -577,8 +490,16 @@ namespace xt
     {
         return const_reference(m_data.element(first, last), m_mask.element(first, last));
     }
+
     //@}
 
+    template <class CTD, class CTM>
+    template <class S>
+    inline bool xmasked_view<CTD, CTM>::has_linear_assign(const S& strides) const noexcept
+    {
+        return m_data.has_linear_assign(strides) && m_mask.has_linear_assign(strides);
+    }
+
     /**
      * Return an expression for the values of the xmasked_view.
      */
@@ -638,11 +559,19 @@ namespace xt
 
     template <class CTD, class CTM>
     template <class S>
-    inline auto xmasked_view<CTD, CTM>::stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
+    inline auto xmasked_view<CTD, CTM>::stepper_end(const S& shape, layout_type l) const noexcept
+        -> const_stepper
     {
         return const_stepper(value().stepper_end(shape, l), visible().stepper_end(shape, l));
     }
 
+    template <class CTD, class CTM>
+    inline auto xmasked_view<CTD, CTM>::operator=(const self_type& rhs) -> self_type&
+    {
+        temporary_type tmp(rhs);
+        return this->assign_temporary(std::move(tmp));
+    }
+
     template <class CTD, class CTM>
     template <class E>
     inline auto xmasked_view<CTD, CTM>::operator=(const xexpression<E>& e) -> self_type&
@@ -676,7 +605,8 @@ namespace xt
 
     template <class D, bool C>
     inline xmasked_view_stepper<D, C>::xmasked_view_stepper(value_stepper vs, mask_stepper ms) noexcept
-        : m_vs(vs), m_ms(ms)
+        : m_vs(vs)
+        , m_ms(ms)
     {
     }
 
diff --git a/include/xtensor/views/xoffset_view.hpp b/include/xtensor/views/xoffset_view.hpp
new file mode 100644
index 000000000..6c8792aa1
--- /dev/null
+++ b/include/xtensor/views/xoffset_view.hpp
@@ -0,0 +1,82 @@
+/***************************************************************************
+ * 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_OFFSET_VIEW_HPP
+#define XTENSOR_OFFSET_VIEW_HPP
+
+#include <xtl/xcomplex.hpp>
+
+#include "../views/xfunctor_view.hpp"
+
+namespace xt
+{
+    namespace detail
+    {
+        template <class M, std::size_t I>
+        struct offset_forwarder
+        {
+            using value_type = M;
+            using reference = M&;
+            using const_reference = const M&;
+            using pointer = M*;
+            using const_pointer = const M*;
+
+            using proxy = xtl::xproxy_wrapper<M>;
+
+            template <class value_type, class requested_type>
+            using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
+
+            template <class T>
+            decltype(auto) operator()(T&& t) const
+            {
+                return xtl::forward_offset<M, I>(std::forward<T>(t));
+            }
+
+            template <class align, class requested_type, std::size_t N, class E, class MF = M>
+            auto proxy_simd_load(const E& expr, std::size_t n) const
+                requires((std::is_same<MF, double>::value || std::is_same<MF, float>::value) && I <= sizeof(MF))
+            {
+                // TODO refactor using shuffle only
+                auto batch = expr.template load_simd<align, requested_type, N>(n);
+                if (I == 0)
+                {
+                    return batch.real();
+                }
+                else
+                {
+                    return batch.imag();
+                }
+            }
+
+            template <class align, class simd, class E, class MF = M>
+            auto proxy_simd_store(E& expr, std::size_t n, const simd& batch) const
+                requires((std::is_same<MF, double>::value || std::is_same<MF, float>::value) && I <= sizeof(MF))
+            {
+                auto x = expr.template load_simd<align, double, simd::size>(n);
+                if (I == 0)
+                {
+                    x.real() = batch;
+                }
+                else
+                {
+                    x.imag() = batch;
+                }
+                expr.template store_simd<align>(n, x);
+            }
+        };
+    }
+
+    template <class CT, class M, std::size_t I>
+    using xoffset_view = xfunctor_view<detail::offset_forwarder<M, I>, CT>;
+
+    template <class CT, class M, std::size_t I>
+    using xoffset_adaptor = xfunctor_adaptor<detail::offset_forwarder<M, I>, CT>;
+}
+
+#endif
diff --git a/include/xtensor/views/xrepeat.hpp b/include/xtensor/views/xrepeat.hpp
new file mode 100644
index 000000000..f94e93d19
--- /dev/null
+++ b/include/xtensor/views/xrepeat.hpp
@@ -0,0 +1,705 @@
+/***************************************************************************
+ * 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_XREPEAT
+#define XTENSOR_XREPEAT
+
+#include <utility>
+#include <vector>
+
+#include "../core/xaccessible.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+
+namespace xt
+{
+    template <class CT, class R>
+    class xrepeat;
+
+    template <class S, class R>
+    class xrepeat_stepper;
+
+    /*********************
+     * xrepeat extension *
+     *********************/
+
+    namespace extension
+    {
+        template <class Tag, class CT, class X>
+        struct xrepeat_base_impl;
+
+        template <class CT, class X>
+        struct xrepeat_base_impl<xtensor_expression_tag, CT, X>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class CT, class X>
+        struct xrepeat_base : xrepeat_base_impl<xexpression_tag_t<CT>, CT, X>
+        {
+        };
+
+        template <class CT, class X>
+        using xrepeat_base_t = typename xrepeat_base<CT, X>::type;
+    }
+
+    /***********
+     * xrepeat *
+     ***********/
+
+    template <class CT, class R>
+    struct xcontainer_inner_types<xrepeat<CT, R>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using reference = typename xexpression_type::const_reference;
+        using const_reference = typename xexpression_type::const_reference;
+        using size_type = typename xexpression_type::size_type;
+        using temporary_type = typename xexpression_type::temporary_type;
+
+        static constexpr bool is_const = std::is_const<std::remove_reference_t<CT>>::value;
+
+        using extract_storage_type = typename std::conditional_t<
+            data_interface_expression<xexpression_type>,
+            detail::expr_storage_type<xexpression_type>,
+            make_invalid_type<>>::type;
+        using storage_type = std::conditional_t<is_const, const extract_storage_type, extract_storage_type>;
+    };
+
+    template <class CT, class R>
+    struct xiterable_inner_types<xrepeat<CT, R>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using repeats_type = std::decay_t<R>;
+        using inner_shape_type = typename xexpression_type::inner_shape_type;
+        using const_stepper = xrepeat_stepper<typename xexpression_type::const_stepper, repeats_type>;
+        using stepper = const_stepper;
+    };
+
+    /**
+     * @class xrepeat
+     * @brief Expression with repeated values along an axis.
+     *
+     * The xrepeat class implements the repetition of the elements of
+     * an \ref xexpression along a given axis. xrepeat is not meant
+     * to be used directly, but only with the \ref repeat helper
+     * functions.
+     *
+     * @sa repeat
+     */
+    template <class CT, class R>
+    class xrepeat : public xconst_iterable<xrepeat<CT, R>>,
+                    public xconst_accessible<xrepeat<CT, R>>,
+                    public xsharable_expression<xrepeat<CT, R>>,
+                    public extension::xrepeat_base_t<CT, R>
+    {
+    public:
+
+        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;
+
+        static constexpr layout_type static_layout = xexpression_type::static_layout;
+        static constexpr bool contiguous_layout = false;
+
+        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;
+
+        template <class CTA>
+        explicit xrepeat(CTA&& e, R&& repeats, size_type axis);
+
+        using accessible_base::size;
+        const shape_type& shape() const noexcept;
+        layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+        using accessible_base::shape;
+
+        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;
+
+        const xexpression_type& expression() const noexcept;
+
+        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;
+
+        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;
+
+    private:
+
+        CT m_e;
+        size_type m_repeating_axis;
+        repeats_type m_repeats;
+        shape_type m_shape;
+
+        const_reference access() const;
+
+        template <class Arg, class... Args>
+        const_reference access(Arg arg, Args... args) const;
+
+        template <std::size_t I, class Arg, class... Args>
+        const_reference access_impl(stepper&& s, Arg arg, Args... args) const;
+
+        template <std::size_t I>
+        const_reference access_impl(stepper&& s) const;
+    };
+
+    /*******************
+     * xrepeat_stepper *
+     *******************/
+
+    template <class S, class R>
+    class xrepeat_stepper
+    {
+    public:
+
+        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>;
+
+        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);
+
+        template <class T>
+        simd_return_type<T> step_simd();
+
+        void step_leading();
+
+        template <class V>
+        void store_simd(const V& vec);
+
+    private:
+
+        S m_substepper;
+        const shape_type& m_shape;
+
+        std::ptrdiff_t m_repeating_steps;
+        std::vector<size_type> m_positions;
+        size_type m_subposition;
+
+        size_type m_repeating_axis;
+        const repeats_type& m_repeats;
+
+        void make_step(size_type dim, size_type n);
+        void make_step_back(size_type dim, size_type n);
+
+        std::vector<size_type> get_next_positions(size_type dim, size_type steps_to_go) const;
+        std::vector<size_type> get_next_positions_back(size_type dim, size_type steps_to_go) const;
+    };
+
+    /**************************
+     * xrepeat implementation *
+     **************************/
+
+    /**
+     * Constructs an xrepeat expression repeating the element of the specified
+     * \ref xexpression.
+     *
+     * @param e the input expression
+     * @param repeats The number of repetitions for each elements
+     * @param axis The axis along which to repeat the value
+     */
+    template <class CT, class R>
+    template <class CTA>
+    xrepeat<CT, R>::xrepeat(CTA&& e, R&& repeats, size_type axis)
+        : m_e(std::forward<CTA>(e))
+        , m_repeating_axis(axis)
+        , m_repeats(std::forward<R>(repeats))
+        , m_shape(e.shape())
+    {
+        using shape_value_type = typename shape_type::value_type;
+        m_shape[axis] = static_cast<shape_value_type>(
+            std::accumulate(m_repeats.begin(), m_repeats.end(), shape_value_type(0))
+        );
+    }
+
+    /**
+     * @name Size and shape
+     */
+    //@{
+    /**
+     * Returns the shape of the expression.
+     */
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::shape() const noexcept -> const shape_type&
+    {
+        return m_shape;
+    }
+
+    /**
+     * Returns the layout_type of the expression.
+     */
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::layout() const noexcept -> layout_type
+    {
+        return m_e.layout();
+    }
+
+    template <class CT, class R>
+    inline bool xrepeat<CT, R>::is_contiguous() const noexcept
+    {
+        return false;
+    }
+
+    //@}
+
+    /**
+     * @name Data
+     */
+    //@{
+    /**
+     * Returns a constant reference to the element at the specified position in the expression.
+     * @param args a 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.
+     */
+    template <class CT, class R>
+    template <class... Args>
+    inline auto xrepeat<CT, R>::operator()(Args... args) const -> const_reference
+    {
+        return access(args...);
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the expression.
+     * @param args a 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.
+     * @warning This method is NOT compatible with broadcasting, meaning the following
+     * code has undefined behavior:
+     * @code{.cpp}
+     * xt::xarray<double> a = {{0, 1}, {2, 3}};
+     * xt::xarray<double> b = {0, 1};
+     * auto fd = a + b;
+     * double res = fd.uncheked(0, 1);
+     * @endcode
+     */
+    template <class CT, class R>
+    template <class... Args>
+    inline auto xrepeat<CT, R>::unchecked(Args... args) const -> const_reference
+    {
+        return this->operator()(args...);
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the view.
+     * @param first iterator starting the sequence of indices
+     * @param last iterator 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..
+     */
+    template <class CT, class R>
+    template <class It>
+    inline auto xrepeat<CT, R>::element(It first, It last) const -> const_reference
+    {
+        auto s = stepper_begin(m_e.shape());
+        std::size_t dimension = 0;
+        auto iter = first;
+        while (iter != last)
+        {
+            s.step(dimension, *iter);
+            ++dimension;
+            ++iter;
+        }
+        return access_impl<0>(std::forward<stepper>(s));
+    }
+
+    /**
+     * Returns a constant reference to the underlying expression of the broadcast expression.
+     */
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::expression() const noexcept -> const xexpression_type&
+    {
+        return m_e;
+    }
+
+    //@}
+
+    /**
+     * @name Broadcasting
+     */
+    //@{
+    /**
+     * Broadcast the shape of the function to the specified parameter.
+     * @param shape the result shape
+     * @param reuse_cache parameter for internal optimization
+     * @return a boolean indicating whether the broadcasting is trivial
+     */
+    template <class CT, class R>
+    template <class S>
+    inline bool xrepeat<CT, R>::broadcast_shape(S& shape, bool) const
+    {
+        return xt::broadcast_shape(m_shape, shape);
+    }
+
+    /**
+     * Checks whether the xbroadcast can be linearly assigned to an expression
+     * with the specified strides.
+     * @return a boolean indicating whether a linear assign is possible
+     */
+    template <class CT, class R>
+    template <class S>
+    inline bool xrepeat<CT, R>::has_linear_assign(const S&) const noexcept
+    {
+        return false;
+    }
+
+    //@}
+
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::access() const -> const_reference
+    {
+        return access_impl<0>(stepper_begin(m_e.shape()));
+    }
+
+    template <class CT, class R>
+    template <class Arg, class... Args>
+    inline auto xrepeat<CT, R>::access(Arg arg, Args... args) const -> const_reference
+    {
+        constexpr size_t number_of_arguments = 1 + sizeof...(Args);
+        if (number_of_arguments > this->dimension())
+        {
+            return access(args...);
+        }
+        return access_impl<0>(stepper_begin(m_e.shape()), arg, args...);
+    }
+
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::stepper_begin() const -> const_stepper
+    {
+        return stepper_begin(m_e.shape());
+    }
+
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::stepper_begin(const shape_type& s) const -> const_stepper
+    {
+        return const_stepper(m_e.stepper_begin(s), m_shape, m_repeats, m_repeating_axis);
+    }
+
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::stepper_end(layout_type l) const -> const_stepper
+    {
+        return stepper_end(m_e.shape(), l);
+    }
+
+    template <class CT, class R>
+    inline auto xrepeat<CT, R>::stepper_end(const shape_type& s, layout_type l) const -> const_stepper
+    {
+        auto st = const_stepper(m_e.stepper_begin(s), m_shape, m_repeats, m_repeating_axis);
+        st.to_end(l);
+        return st;
+    }
+
+    template <class CT, class R>
+    template <std::size_t I, class Arg, class... Args>
+    inline auto xrepeat<CT, R>::access_impl(stepper&& s, Arg arg, Args... args) const -> const_reference
+    {
+        s.step(I, static_cast<size_type>(arg));
+        return access_impl<I + 1>(std::forward<stepper>(s), args...);
+    }
+
+    template <class CT, class R>
+    template <std::size_t I>
+    inline auto xrepeat<CT, R>::access_impl(stepper&& s) const -> const_reference
+    {
+        return *s;
+    }
+
+    /**********************************
+     * xrepeat_stepper implementation *
+     **********************************/
+
+    template <class S, class R>
+    xrepeat_stepper<S, R>::xrepeat_stepper(S&& s, const shape_type& shape, const repeats_type& repeats, size_type axis)
+        : m_substepper(std::forward<S>(s))
+        , m_shape(shape)
+        , m_repeating_steps(0)
+        , m_positions(shape.size())
+        , m_subposition(0)
+        , m_repeating_axis(axis)
+        , m_repeats(repeats)
+    {
+    }
+
+    template <class S, class R>
+    inline auto xrepeat_stepper<S, R>::operator*() const -> reference
+    {
+        return m_substepper.operator*();
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::step(size_type dim, size_type steps_to_go)
+    {
+        if (m_positions[dim] + steps_to_go >= m_shape[dim])
+        {
+            const auto next_positions = get_next_positions(dim, steps_to_go);
+            if (next_positions[dim] > m_positions[dim])
+            {
+                make_step(dim, next_positions[dim] - m_positions[dim]);
+            }
+            else
+            {
+                make_step_back(dim, m_positions[dim] - next_positions[dim]);
+            }
+            for (size_type d = 0; d < dim; ++d)
+            {
+                make_step(d, next_positions[d] - m_positions[d]);
+            }
+        }
+        else
+        {
+            make_step(dim, steps_to_go);
+        }
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::step_back(size_type dim, size_type steps_to_go)
+    {
+        if (m_positions[dim] < steps_to_go)
+        {
+            const auto next_positions = get_next_positions_back(dim, steps_to_go);
+            if (next_positions[dim] < m_positions[dim])
+            {
+                make_step_back(dim, m_positions[dim] - next_positions[dim]);
+            }
+            else
+            {
+                make_step(dim, next_positions[dim] - m_positions[dim]);
+            }
+            for (size_type d = 0; d < dim; ++d)
+            {
+                make_step_back(d, m_positions[d] - next_positions[d]);
+            }
+        }
+        else
+        {
+            make_step_back(dim, steps_to_go);
+        }
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::reset(size_type dim)
+    {
+        m_substepper.reset(dim);
+        m_positions[dim] = 0;
+        if (dim == m_repeating_axis)
+        {
+            m_subposition = 0;
+            m_repeating_steps = 0;
+        }
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::reset_back(size_type dim)
+    {
+        m_substepper.reset_back(dim);
+        m_positions[dim] = m_shape[dim] - 1;
+        if (dim == m_repeating_axis)
+        {
+            m_subposition = m_repeats.size() - 1;
+            m_repeating_steps = static_cast<std::ptrdiff_t>(m_repeats.back()) - 1;
+        }
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::to_begin()
+    {
+        m_substepper.to_begin();
+        std::fill(m_positions.begin(), m_positions.end(), 0);
+        m_subposition = 0;
+        m_repeating_steps = 0;
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::to_end(layout_type l)
+    {
+        m_substepper.to_end(l);
+        std::transform(
+            m_shape.begin(),
+            m_shape.end(),
+            m_positions.begin(),
+            [](auto value)
+            {
+                return value - 1;
+            }
+        );
+        if (layout_type::row_major == l)
+        {
+            ++m_positions.front();
+        }
+        else
+        {
+            ++m_positions.back();
+        }
+        m_subposition = m_repeats.size();
+        m_repeating_steps = 0;
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::step_leading()
+    {
+        step(m_shape.size() - 1, 1);
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::make_step(size_type dim, size_type steps_to_go)
+    {
+        if (steps_to_go > 0)
+        {
+            if (dim == m_repeating_axis)
+            {
+                size_type subposition = m_subposition;
+                m_repeating_steps += static_cast<std::ptrdiff_t>(steps_to_go);
+                while (m_repeating_steps >= static_cast<ptrdiff_t>(m_repeats[subposition]))
+                {
+                    m_repeating_steps -= static_cast<ptrdiff_t>(m_repeats[subposition]);
+                    ++subposition;
+                }
+                m_substepper.step(dim, subposition - m_subposition);
+                m_subposition = subposition;
+            }
+            else
+            {
+                m_substepper.step(dim, steps_to_go);
+            }
+            m_positions[dim] += steps_to_go;
+        }
+    }
+
+    template <class S, class R>
+    inline void xrepeat_stepper<S, R>::make_step_back(size_type dim, size_type steps_to_go)
+    {
+        if (steps_to_go > 0)
+        {
+            if (dim == m_repeating_axis)
+            {
+                size_type subposition = m_subposition;
+                m_repeating_steps -= static_cast<std::ptrdiff_t>(steps_to_go);
+                while (m_repeating_steps < 0)
+                {
+                    --subposition;
+                    m_repeating_steps += static_cast<ptrdiff_t>(m_repeats[subposition]);
+                }
+                m_substepper.step_back(dim, m_subposition - subposition);
+                m_subposition = subposition;
+            }
+            else
+            {
+                m_substepper.step_back(dim, steps_to_go);
+            }
+            m_positions[dim] -= steps_to_go;
+        }
+    }
+
+    template <class S, class R>
+    inline auto xrepeat_stepper<S, R>::get_next_positions(size_type dim, size_type steps_to_go) const
+        -> std::vector<size_type>
+    {
+        size_type next_position_for_dim = m_positions[dim] + steps_to_go;
+        if (dim > 0)
+        {
+            size_type steps_in_previous_dim = 0;
+            while (next_position_for_dim >= m_shape[dim])
+            {
+                next_position_for_dim -= m_shape[dim];
+                ++steps_in_previous_dim;
+            }
+            if (steps_in_previous_dim > 0)
+            {
+                auto next_positions = get_next_positions(dim - 1, steps_in_previous_dim);
+                next_positions[dim] = next_position_for_dim;
+                return next_positions;
+            }
+        }
+        std::vector<size_type> next_positions = m_positions;
+        next_positions[dim] = next_position_for_dim;
+        return next_positions;
+    }
+
+    template <class S, class R>
+    inline auto xrepeat_stepper<S, R>::get_next_positions_back(size_type dim, size_type steps_to_go) const
+        -> std::vector<size_type>
+    {
+        auto next_position_for_dim = static_cast<std::ptrdiff_t>(m_positions[dim] - steps_to_go);
+        if (dim > 0)
+        {
+            size_type steps_in_previous_dim = 0;
+            while (next_position_for_dim < 0)
+            {
+                next_position_for_dim += static_cast<std::ptrdiff_t>(m_shape[dim]);
+                ++steps_in_previous_dim;
+            }
+            if (steps_in_previous_dim > 0)
+            {
+                auto next_positions = get_next_positions_back(dim - 1, steps_in_previous_dim);
+                next_positions[dim] = static_cast<size_type>(next_position_for_dim);
+                return next_positions;
+            }
+        }
+        std::vector<size_type> next_positions = m_positions;
+        next_positions[dim] = static_cast<size_type>(next_position_for_dim);
+        return next_positions;
+    }
+}
+
+#endif
diff --git a/include/xtensor/xslice.hpp b/include/xtensor/views/xslice.hpp
similarity index 65%
rename from include/xtensor/xslice.hpp
rename to include/xtensor/views/xslice.hpp
index 113c01310..cdae97c9f 100644
--- a/include/xtensor/xslice.hpp
+++ b/include/xtensor/views/xslice.hpp
@@ -1,33 +1,25 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_SLICE_HPP
 #define XTENSOR_SLICE_HPP
 
 #include <cstddef>
+#include <map>
 #include <type_traits>
 #include <utility>
-#include <map>
 
 #include <xtl/xtype_traits.hpp>
 
-#include "xstorage.hpp"
-#include "xutils.hpp"
-
-#ifndef XTENSOR_CONSTEXPR
-    #if(defined(_MSC_VER) || __GNUC__ < 8)
-        #define XTENSOR_CONSTEXPR inline
-        #define XTENSOR_GLOBAL_CONSTEXPR static const
-    #else
-        #define XTENSOR_CONSTEXPR constexpr
-        #define XTENSOR_GLOBAL_CONSTEXPR constexpr
-    #endif
-#endif
+#include "../containers/xstorage.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
@@ -61,26 +53,34 @@ namespace xt
     template <class S>
     using is_xslice = std::is_base_of<xslice<S>, S>;
 
-    template <class E, class R = void>
-    using disable_xslice = typename std::enable_if<!is_xslice<E>::value, R>::type;
-
     template <class... E>
-    using has_xslice = xtl::disjunction<is_xslice<E>...>;
+    using has_xslice = std::disjunction<is_xslice<E>...>;
 
     /**************
      * slice tags *
      **************/
 
-#define DEFINE_TAG_CONVERSION(NAME)                 \
-    template <class T>                              \
-    XTENSOR_CONSTEXPR NAME convert() const noexcept \
-    {                                               \
-        return NAME();                              \
+#define DEFINE_TAG_CONVERSION(NAME)         \
+    template <class T>                      \
+    constexpr NAME convert() const noexcept \
+    {                                       \
+        return NAME();                      \
     }
 
-    struct xall_tag { DEFINE_TAG_CONVERSION(xall_tag) };
-    struct xnewaxis_tag { DEFINE_TAG_CONVERSION(xnewaxis_tag) };
-    struct xellipsis_tag { DEFINE_TAG_CONVERSION(xellipsis_tag) };
+    struct xall_tag
+    {
+        DEFINE_TAG_CONVERSION(xall_tag)
+    };
+
+    struct xnewaxis_tag
+    {
+        DEFINE_TAG_CONVERSION(xnewaxis_tag)
+    };
+
+    struct xellipsis_tag
+    {
+        DEFINE_TAG_CONVERSION(xellipsis_tag)
+    };
 
 #undef DEFINE_TAG_CONVERSION
 
@@ -99,12 +99,12 @@ namespace xt
         xrange() = default;
         xrange(size_type start_val, size_type stop_val) noexcept;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xrange<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xrange<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -143,12 +143,12 @@ namespace xt
         xstepped_range() = default;
         xstepped_range(size_type start_val, size_type stop_val, size_type step) noexcept;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xstepped_range<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xstepped_range<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -188,12 +188,12 @@ namespace xt
         xall() = default;
         explicit xall(size_type size) noexcept;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xall<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xall<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -231,11 +231,11 @@ namespace xt
      *
      * Note: ellipsis can only be used in strided_view!
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xarray<double> a = xarray<double>::from_shape({5, 5, 1, 1, 5});
      * auto v = xt::strided_view(a, {2, xt::ellipsis(), 2});
      * // equivalent to using {2, xt::all(), xt::all(), xt::all(), 2};
-     * \endcode
+     * @endcode
      *
      * @sa strided_view
      */
@@ -258,12 +258,12 @@ namespace xt
 
         xnewaxis() = default;
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xnewaxis<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xnewaxis<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -307,12 +307,6 @@ namespace xt
         struct is_xkeep_slice<xkeep_slice<T>> : std::true_type
         {
         };
-
-        template <class T>
-        using disable_xkeep_slice_t = std::enable_if_t<!is_xkeep_slice<std::decay_t<T>>::value, void>;
-
-        template <class T>
-        using enable_xkeep_slice_t = std::enable_if_t<is_xkeep_slice<std::decay_t<T>>::value, void>;
     }
 
     template <class T>
@@ -324,19 +318,20 @@ namespace xt
         using size_type = typename container_type::value_type;
         using self_type = xkeep_slice<T>;
 
-        template <class C, typename = detail::disable_xkeep_slice_t<C>>
-        explicit xkeep_slice(C& cont);
+        template <class C>
+        explicit xkeep_slice(C& cont)
+            requires(!detail::is_xkeep_slice<std::decay_t<C>>::value);
         explicit xkeep_slice(container_type&& cont);
 
         template <class S>
         xkeep_slice(std::initializer_list<S> t);
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xkeep_slice<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xkeep_slice<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -363,43 +358,34 @@ namespace xt
         friend class xkeep_slice;
     };
 
-    namespace detail
-    {
-        template <class T>
-        using disable_integral_keep = std::enable_if_t<!std::is_integral<std::decay_t<T>>::value,
-            xkeep_slice<typename std::decay_t<T>::value_type>>;
-
-        template <class T, class R>
-        using enable_integral_keep = std::enable_if_t<std::is_integral<T>::value, xkeep_slice<R>>;
-    }
-
     /**
      * Create a non-contigous slice from a container of indices to keep.
      * Note: this slice cannot be used in the xstrided_view!
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = xt::arange(9);
      * a.reshape({3, 3});
      * xt::view(a, xt::keep(0, 2); // => {{0, 1, 2}, {6, 7, 8}}
      * xt::view(a, xt::keep(1, 1, 1); // => {{3, 4, 5}, {3, 4, 5}, {3, 4, 5}}
-     * \endcode
+     * @endcode
      *
      * @param indices The indices container
      * @return instance of xkeep_slice
      */
-    template <class T>
-    inline detail::disable_integral_keep<T> keep(T&& indices)
-    {
-        return xkeep_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
-    }
-
     template <class R = std::ptrdiff_t, class T>
-    inline detail::enable_integral_keep<T, R> keep(T i)
+    inline auto keep(T&& indices)
     {
-        using slice_type = xkeep_slice<R>;
-        using container_type = typename slice_type::container_type;
-        container_type tmp = { static_cast<R>(i) };
-        return slice_type(std::move(tmp));
+        if constexpr (xtl::is_integral<std::decay_t<T>>::value)
+        {
+            using slice_type = xkeep_slice<R>;
+            using container_type = typename slice_type::container_type;
+            container_type tmp = {static_cast<R>(std::forward<T>(indices))};
+            return slice_type(std::move(tmp));
+        }
+        else
+        {
+            return xkeep_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
+        }
     }
 
     template <class R = std::ptrdiff_t, class Arg0, class Arg1, class... Args>
@@ -407,7 +393,7 @@ namespace xt
     {
         using slice_type = xkeep_slice<R>;
         using container_type = typename slice_type::container_type;
-        container_type tmp = { static_cast<R>(i0), static_cast<R>(i1), static_cast<R>(args)... };
+        container_type tmp = {static_cast<R>(i0), static_cast<R>(i1), static_cast<R>(args)...};
         return slice_type(std::move(tmp));
     }
 
@@ -429,12 +415,6 @@ namespace xt
         struct is_xdrop_slice<xdrop_slice<T>> : std::true_type
         {
         };
-
-        template <class T>
-        using disable_xdrop_slice_t = std::enable_if_t<!is_xdrop_slice<std::decay_t<T>>::value, void>;
-
-        template <class T>
-        using enable_xdrop_slice_t = std::enable_if_t<is_xdrop_slice<std::decay_t<T>>::value, void>;
     }
 
     template <class T>
@@ -446,19 +426,20 @@ namespace xt
         using size_type = typename container_type::value_type;
         using self_type = xdrop_slice<T>;
 
-        template <class C, typename = detail::disable_xdrop_slice_t<C>>
-        explicit xdrop_slice(C& cont);
+        template <class C>
+        explicit xdrop_slice(C& cont)
+            requires(!detail::is_xdrop_slice<std::decay_t<C>>::value);
         explicit xdrop_slice(container_type&& cont);
 
         template <class S>
         xdrop_slice(std::initializer_list<S> t);
 
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         operator xdrop_slice<S>() const noexcept;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
-        template <class S, typename = std::enable_if_t<std::is_convertible<S, T>::value, void>>
+        template <std::convertible_to<T> S>
         xdrop_slice<S> convert() const noexcept;
 
         size_type operator()(size_type i) const noexcept;
@@ -487,42 +468,33 @@ namespace xt
         friend class xdrop_slice;
     };
 
-    namespace detail
-    {
-        template <class T>
-        using disable_integral_drop = std::enable_if_t<!std::is_integral<std::decay_t<T>>::value,
-                                     xdrop_slice<typename std::decay_t<T>::value_type>>;
-
-        template <class T, class R>
-        using enable_integral_drop = std::enable_if_t<std::is_integral<T>::value, xdrop_slice<R>>;
-    }
-
     /**
      * Create a non-contigous slice from a container of indices to drop.
      * Note: this slice cannot be used in the xstrided_view!
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = xt::arange(9);
      * a.reshape({3, 3});
      * xt::view(a, xt::drop(0, 2); // => {{3, 4, 5}}
-     * \endcode
+     * @endcode
      *
      * @param indices The container of indices to drop
      * @return instance of xdrop_slice
      */
-    template <class T>
-    inline detail::disable_integral_drop<T> drop(T&& indices)
-    {
-        return xdrop_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
-    }
-
     template <class R = std::ptrdiff_t, class T>
-    inline detail::enable_integral_drop<T, R> drop(T i)
+    inline auto drop(T&& indices)
     {
-        using slice_type = xdrop_slice<R>;
-        using container_type = typename slice_type::container_type;
-        container_type tmp = { static_cast<R>(i) };
-        return slice_type(std::move(tmp));
+        if constexpr (xtl::is_integral<std::remove_cvref_t<T>>::value)
+        {
+            using slice_type = xdrop_slice<R>;
+            using container_type = typename slice_type::container_type;
+            container_type tmp = {static_cast<R>(std::forward<T>(indices))};
+            return slice_type(std::move(tmp));
+        }
+        else
+        {
+            return xdrop_slice<typename std::decay_t<T>::value_type>(std::forward<T>(indices));
+        }
     }
 
     template <class R = std::ptrdiff_t, class Arg0, class Arg1, class... Args>
@@ -530,7 +502,7 @@ namespace xt
     {
         using slice_type = xdrop_slice<R>;
         using container_type = typename slice_type::container_type;
-        container_type tmp = { static_cast<R>(i0), static_cast<R>(i1), static_cast<R>(args)... };
+        container_type tmp = {static_cast<R>(i0), static_cast<R>(i1), static_cast<R>(args)...};
         return slice_type(std::move(tmp));
     }
 
@@ -542,122 +514,102 @@ namespace xt
     struct xrange_adaptor
     {
         xrange_adaptor(A start_val, B stop_val, C step)
-            : m_start(start_val), m_stop(stop_val), m_step(step)
-        {
-        }
-
-        auto normalize(std::ptrdiff_t val, std::size_t ssize) const
+            : m_start(start_val)
+            , m_stop(stop_val)
+            , m_step(step)
         {
-            std::ptrdiff_t size = static_cast<std::ptrdiff_t>(ssize);
-            val = (val >= 0) ? val : val + size;
-            return (std::max)(std::ptrdiff_t(0), (std::min)(size, val));
         }
 
-        auto get_stepped_range(std::ptrdiff_t start, std::ptrdiff_t stop, std::ptrdiff_t step, std::size_t ssize) const
+        template <class MI = A, class MA = B, class STEP = C>
+        auto get(std::size_t size) const
         {
-            std::ptrdiff_t size = static_cast<std::ptrdiff_t>(ssize);
-            start = (start >= 0) ? start : start + size;
-            stop = (stop >= 0) ? stop : stop + size;
-
-            if (step > 0)
+            if constexpr (xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
             {
-                start = (std::max)(std::ptrdiff_t(0), (std::min)(size, start));
-                stop  = (std::max)(std::ptrdiff_t(0), (std::min)(size, stop));
+                return get_stepped_range(m_start, m_stop, m_step, size);
             }
-            else
+            else if constexpr (!xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
             {
-                start = (std::max)(std::ptrdiff_t(-1), (std::min)(size - 1, start));
-                stop  = (std::max)(std::ptrdiff_t(-1), (std::min)(size - 1, stop));
+                return get_stepped_range(
+                    m_step > 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1,
+                    m_stop,
+                    m_step,
+                    size
+                );
+            }
+            else if constexpr (xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            {
+                auto sz = static_cast<std::ptrdiff_t>(size);
+                return get_stepped_range(m_start, m_step > 0 ? sz : -(sz + 1), m_step, size);
+            }
+            else if constexpr (xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xrange<std::ptrdiff_t>(normalize(m_start, size), normalize(m_stop, size));
+            }
+            else if constexpr (!xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && xtl::is_integral<STEP>::value)
+            {
+                std::ptrdiff_t start = m_step >= 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1;
+                std::ptrdiff_t stop = m_step >= 0 ? static_cast<std::ptrdiff_t>(size) : -1;
+                return xstepped_range<std::ptrdiff_t>(start, stop, m_step);
+            }
+            else if constexpr (xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xrange<std::ptrdiff_t>(normalize(m_start, size), static_cast<std::ptrdiff_t>(size));
+            }
+            else if constexpr (!xtl::is_integral<MI>::value && xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xrange<std::ptrdiff_t>(0, normalize(m_stop, size));
+            }
+            else if constexpr (!xtl::is_integral<MI>::value && !xtl::is_integral<MA>::value && !xtl::is_integral<STEP>::value)
+            {
+                return xall<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(size));
             }
-
-            return xstepped_range<std::ptrdiff_t>(start, stop, step);
         }
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<std::is_integral<MI>::value &&
-                                std::is_integral<MA>::value &&
-                                std::is_integral<STEP>::value,
-                                xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
+        A start() const
         {
-            return get_stepped_range(m_start, m_stop, m_step, size);
+            return m_start;
         }
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<!std::is_integral<MI>::value &&
-                                std::is_integral<MA>::value &&
-                                std::is_integral<STEP>::value,
-                                xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
+        B stop() const
         {
-            return get_stepped_range(m_step > 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1, m_stop, m_step, size);
+            return m_stop;
         }
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<std::is_integral<MI>::value &&
-                                !std::is_integral<MA>::value &&
-                                std::is_integral<STEP>::value,
-                                xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
+        C step() const
         {
-            auto sz = static_cast<std::ptrdiff_t>(size);
-            return get_stepped_range(m_start, m_step > 0 ? sz : -(sz + 1), m_step, size);
+            return m_step;
         }
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<std::is_integral<MI>::value &&
-                                std::is_integral<MA>::value &&
-                                !std::is_integral<STEP>::value,
-                                xrange<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return xrange<std::ptrdiff_t>(normalize(m_start, size), normalize(m_stop, size));
-        }
+    private:
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<!std::is_integral<MI>::value &&
-                                !std::is_integral<MA>::value &&
-                                std::is_integral<STEP>::value,
-                                xstepped_range<std::ptrdiff_t>>
-        get(std::size_t size) const
+        static auto normalize(std::ptrdiff_t val, std::size_t ssize)
         {
-            std::ptrdiff_t start = m_step >= 0 ? 0 : static_cast<std::ptrdiff_t>(size) - 1;
-            std::ptrdiff_t stop = m_step >= 0 ? static_cast<std::ptrdiff_t>(size) : -1;
-            return xstepped_range<std::ptrdiff_t>(start, stop, m_step);
+            std::ptrdiff_t size = static_cast<std::ptrdiff_t>(ssize);
+            val = (val >= 0) ? val : val + size;
+            return (std::max)(std::ptrdiff_t(0), (std::min)(size, val));
         }
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<std::is_integral<MI>::value &&
-                                !std::is_integral<MA>::value &&
-                                !std::is_integral<STEP>::value,
-                                xrange<std::ptrdiff_t>>
-        get(std::size_t size) const
+        static auto
+        get_stepped_range(std::ptrdiff_t start, std::ptrdiff_t stop, std::ptrdiff_t step, std::size_t ssize)
         {
-            return xrange<std::ptrdiff_t>(normalize(m_start, size), static_cast<std::ptrdiff_t>(size));
-        }
+            std::ptrdiff_t size = static_cast<std::ptrdiff_t>(ssize);
+            start = (start >= 0) ? start : start + size;
+            stop = (stop >= 0) ? stop : stop + size;
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<!std::is_integral<MI>::value &&
-                                std::is_integral<MA>::value &&
-                                !std::is_integral<STEP>::value,
-                                xrange<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return xrange<std::ptrdiff_t>(0, normalize(m_stop, size));
-        }
+            if (step > 0)
+            {
+                start = (std::max)(std::ptrdiff_t(0), (std::min)(size, start));
+                stop = (std::max)(std::ptrdiff_t(0), (std::min)(size, stop));
+            }
+            else
+            {
+                start = (std::max)(std::ptrdiff_t(-1), (std::min)(size - 1, start));
+                stop = (std::max)(std::ptrdiff_t(-1), (std::min)(size - 1, stop));
+            }
 
-        template <class MI = A, class MA = B, class STEP = C>
-        inline std::enable_if_t<!std::is_integral<MI>::value &&
-                                !std::is_integral<MA>::value &&
-                                !std::is_integral<STEP>::value,
-                                xall<std::ptrdiff_t>>
-        get(std::size_t size) const
-        {
-            return xall<std::ptrdiff_t>(static_cast<std::ptrdiff_t>(size));
+            return xstepped_range<std::ptrdiff_t>(start, stop, step);
         }
 
-    private:
-
         A m_start;
         B m_stop;
         C m_step;
@@ -670,20 +622,22 @@ namespace xt
     namespace placeholders
     {
         // xtensor universal placeholder
-        struct xtuph {};
+        struct xtuph
+        {
+        };
 
         template <class... Args>
         struct rangemaker
         {
-            std::ptrdiff_t rng[3]; // = { 0, 0, 0 };
+            std::ptrdiff_t rng[3];  // = { 0, 0, 0 };
         };
 
-        XTENSOR_CONSTEXPR xtuph get_tuph_or_val(std::ptrdiff_t /*val*/, std::true_type)
+        constexpr xtuph get_tuph_or_val(std::ptrdiff_t /*val*/, std::true_type)
         {
             return xtuph();
         }
 
-        XTENSOR_CONSTEXPR std::ptrdiff_t get_tuph_or_val(std::ptrdiff_t val, std::false_type)
+        constexpr std::ptrdiff_t get_tuph_or_val(std::ptrdiff_t val, std::false_type)
         {
             return val;
         }
@@ -691,54 +645,53 @@ namespace xt
         template <class A, class B, class C>
         struct rangemaker<A, B, C>
         {
-            XTENSOR_CONSTEXPR operator xrange_adaptor<A, B, C>()
+            constexpr operator xrange_adaptor<A, B, C>()
             {
-                return xrange_adaptor<A, B, C>({
-                    get_tuph_or_val(rng[0], std::is_same<A, xtuph>()),
-                    get_tuph_or_val(rng[1], std::is_same<B, xtuph>()),
-                    get_tuph_or_val(rng[2], std::is_same<C, xtuph>())
-                });
+                return xrange_adaptor<A, B, C>(
+                    {get_tuph_or_val(rng[0], std::is_same<A, xtuph>()),
+                     get_tuph_or_val(rng[1], std::is_same<B, xtuph>()),
+                     get_tuph_or_val(rng[2], std::is_same<C, xtuph>())}
+                );
             }
 
-            std::ptrdiff_t rng[3];// = { 0, 0, 0 };
+            std::ptrdiff_t rng[3];  // = { 0, 0, 0 };
         };
 
         template <class A, class B>
         struct rangemaker<A, B>
         {
-            XTENSOR_CONSTEXPR operator xrange_adaptor<A, B, xt::placeholders::xtuph>()
+            constexpr operator xrange_adaptor<A, B, xt::placeholders::xtuph>()
             {
-                return xrange_adaptor<A, B, xt::placeholders::xtuph>({
-                    get_tuph_or_val(rng[0], std::is_same<A, xtuph>()),
-                    get_tuph_or_val(rng[1], std::is_same<B, xtuph>()),
-                    xtuph()
-                });
+                return xrange_adaptor<A, B, xt::placeholders::xtuph>(
+                    {get_tuph_or_val(rng[0], std::is_same<A, xtuph>()),
+                     get_tuph_or_val(rng[1], std::is_same<B, xtuph>()),
+                     xtuph()}
+                );
             }
 
             std::ptrdiff_t rng[3];  // = { 0, 0, 0 };
         };
 
         template <class... OA>
-        XTENSOR_CONSTEXPR auto operator|(const rangemaker<OA...>& rng, const std::ptrdiff_t& t)
+        constexpr auto operator|(const rangemaker<OA...>& rng, const std::ptrdiff_t& t)
         {
-            auto nrng = rangemaker<OA..., std::ptrdiff_t>({ rng.rng[0], rng.rng[1], rng.rng[2] });
+            auto nrng = rangemaker<OA..., std::ptrdiff_t>({rng.rng[0], rng.rng[1], rng.rng[2]});
             nrng.rng[sizeof...(OA)] = t;
             return nrng;
         }
 
         template <class... OA>
-        XTENSOR_CONSTEXPR auto operator|(const rangemaker<OA...>& rng, const xt::placeholders::xtuph& /*t*/)
+        constexpr auto operator|(const rangemaker<OA...>& rng, const xt::placeholders::xtuph& /*t*/)
         {
-            auto nrng = rangemaker<OA..., xt::placeholders::xtuph>({ rng.rng[0], rng.rng[1], rng.rng[2] });
+            auto nrng = rangemaker<OA..., xt::placeholders::xtuph>({rng.rng[0], rng.rng[1], rng.rng[2]});
             return nrng;
         }
 
-
-        XTENSOR_GLOBAL_CONSTEXPR xtuph _{};
-        XTENSOR_GLOBAL_CONSTEXPR rangemaker<> _r = rangemaker<>({ 0, 0, 0 });
-        XTENSOR_GLOBAL_CONSTEXPR xall_tag _a{};
-        XTENSOR_GLOBAL_CONSTEXPR xnewaxis_tag _n{};
-        XTENSOR_GLOBAL_CONSTEXPR xellipsis_tag _e{};
+        constexpr xtuph _{};
+        constexpr rangemaker<> _r = rangemaker<>({{0, 0, 0}});
+        constexpr xall_tag _a{};
+        constexpr xnewaxis_tag _n{};
+        constexpr xellipsis_tag _e{};
     }
 
     inline auto xnone()
@@ -748,21 +701,10 @@ namespace xt
 
     namespace detail
     {
-        template <class T, class E = void>
-        struct cast_if_integer
-        {
-            using type = T;
-
-            type operator()(T t)
-            {
-                return t;
-            }
-        };
-
         template <class T>
-        struct cast_if_integer<T, std::enable_if_t<std::is_integral<T>::value>>
+        struct cast_if_integer
         {
-            using type = std::ptrdiff_t;
+            using type = std::conditional_t<xtl::is_integral<T>::value, std::ptrdiff_t, T>;
 
             type operator()(T t)
             {
@@ -775,16 +717,16 @@ namespace xt
     }
 
     /**
-     * Select a range from start_val to stop_val.
+     * Select a range from start_val to stop_val (excluded).
      * You can use the shorthand `_` syntax to select from the start or until the end.
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * using namespace xt::placeholders;  // to enable _ syntax
      *
      * range(3, _)  // select from index 3 to the end
-     * range(_, 5)  // select from index o to 5
+     * range(_, 5)  // select from index 0 to 5 (excluded)
      * range(_, _)  // equivalent to `all()`
-     * \endcode
+     * @endcode
      *
      * @sa view, strided_view
      */
@@ -792,17 +734,20 @@ namespace xt
     inline auto range(A start_val, B stop_val)
     {
         return xrange_adaptor<detail::cast_if_integer_t<A>, detail::cast_if_integer_t<B>, placeholders::xtuph>(
-            detail::cast_if_integer<A>{}(start_val), detail::cast_if_integer<B>{}(stop_val), placeholders::xtuph());
+            detail::cast_if_integer<A>{}(start_val),
+            detail::cast_if_integer<B>{}(stop_val),
+            placeholders::xtuph()
+        );
     }
 
     /**
-     * Select a range from start_val to stop_val with step
+     * Select a range from start_val to stop_val (excluded) with step
      * You can use the shorthand `_` syntax to select from the start or until the end.
      *
-     * \code{.cpp}
+     * @code{.cpp}
      * using namespace xt::placeholders;  // to enable _ syntax
      * range(3, _, 5)  // select from index 3 to the end with stepsize 5
-     * \endcode
+     * @endcode
      *
      * @sa view, strided_view
      */
@@ -810,7 +755,10 @@ namespace xt
     inline auto range(A start_val, B stop_val, C step)
     {
         return xrange_adaptor<detail::cast_if_integer_t<A>, detail::cast_if_integer_t<B>, detail::cast_if_integer_t<C>>(
-            detail::cast_if_integer<A>{}(start_val), detail::cast_if_integer<B>{}(stop_val), detail::cast_if_integer<C>{}(step));
+            detail::cast_if_integer<A>{}(start_val),
+            detail::cast_if_integer<B>{}(stop_val),
+            detail::cast_if_integer<C>{}(step)
+        );
     }
 
     /******************************************************
@@ -818,15 +766,16 @@ namespace xt
      ******************************************************/
 
     template <class S>
-    inline disable_xslice<S, std::size_t> get_size(const S&) noexcept
+    inline std::size_t get_size(const S& slice) noexcept
     {
-        return 1;
-    }
-
-    template <class S>
-    inline auto get_size(const xslice<S>& slice) noexcept
-    {
-        return slice.derived_cast().size();
+        if constexpr (is_xslice<S>::value)
+        {
+            return static_cast<std::size_t>(slice.size());
+        }
+        else
+        {
+            return 1;
+        }
     }
 
     /*******************************************************
@@ -834,27 +783,29 @@ namespace xt
      *******************************************************/
 
     template <class S>
-    inline disable_xslice<S, std::size_t> step_size(const S&, std::size_t) noexcept
-    {
-        return 0;
-    }
-
-    template <class S>
-    inline disable_xslice<S, std::size_t> step_size(const S&, std::size_t, std::size_t) noexcept
+    inline std::size_t step_size(const S& slice, std::size_t idx) noexcept
     {
-        return 0;
-    }
-
-    template <class S>
-    inline auto step_size(const xslice<S>& slice, std::size_t idx) noexcept
-    {
-        return slice.derived_cast().step_size(idx);
+        if constexpr (is_xslice<S>::value)
+        {
+            return static_cast<std::size_t>(slice.step_size(idx));
+        }
+        else
+        {
+            return 0;
+        }
     }
 
     template <class S>
-    inline auto step_size(const xslice<S>& slice, std::size_t idx, std::size_t n) noexcept
+    inline std::size_t step_size(const S& slice, std::size_t idx, std::size_t n) noexcept
     {
-        return slice.derived_cast().step_size(idx, n);
+        if constexpr (is_xslice<S>::value)
+        {
+            return static_cast<std::size_t>(slice.step_size(idx, n));
+        }
+        else
+        {
+            return 0;
+        }
     }
 
     /*********************************************
@@ -862,58 +813,113 @@ namespace xt
      *********************************************/
 
     template <class S, class I>
-    inline disable_xslice<S, std::size_t> value(const S& s, I) noexcept
+    inline std::size_t value(const S& slice, I i) noexcept
     {
-        return static_cast<std::size_t>(s);
-    }
-
-    template <class S, class I>
-    inline auto value(const xslice<S>& slice, I i) noexcept
-    {
-        using ST = typename S::size_type;
-        return slice.derived_cast()(static_cast<ST>(i));
+        if constexpr (is_xslice<S>::value)
+        {
+            using ST = typename S::size_type;
+            return static_cast<std::size_t>(slice(static_cast<ST>(i)));
+        }
+        else
+        {
+            return static_cast<std::size_t>(slice);
+        }
     }
 
     /****************************************
      * homogeneous get_slice_implementation *
      ****************************************/
 
-    template <class E, class SL>
-    inline auto get_slice_implementation(E& /*e*/, SL&& slice, std::size_t /*index*/)
+    namespace detail
     {
-        return std::forward<SL>(slice);
-    }
+        template <class T>
+        struct slice_implementation_getter
+        {
+            template <class E, class SL>
+            inline decltype(auto) operator()(E& e, SL&& slice, std::size_t index) const
+            {
+                return get_slice(e, std::forward<SL>(slice), index, xtl::is_signed<std::decay_t<SL>>());
+            }
 
-    template <class E, class T>
-    inline auto get_slice_implementation(E& e, xkeep_slice<T>&& slice, std::size_t index)
-    {
-        slice.normalize(e.shape()[index]);
-        return slice;
-    }
+        private:
 
-    template <class E, class T>
-    inline auto get_slice_implementation(E& e, xdrop_slice<T>&& slice, std::size_t index)
-    {
-        slice.normalize(e.shape()[index]);
-        return slice;
-    }
+            template <class E, class SL>
+            inline decltype(auto) get_slice(E&, SL&& slice, std::size_t, std::false_type) const
+            {
+                return std::forward<SL>(slice);
+            }
 
-    template <class E>
-    inline auto get_slice_implementation(E& e, xall_tag&&, std::size_t index)
-    {
-        return xall<typename E::size_type>(e.shape()[index]);
-    }
+            template <class E, class SL>
+            inline decltype(auto) get_slice(E& e, SL&& slice, std::size_t index, std::true_type) const
+            {
+                using int_type = std::decay_t<SL>;
+                return slice < int_type(0) ? slice + static_cast<std::ptrdiff_t>(e.shape(index))
+                                           : std::ptrdiff_t(slice);
+            }
+        };
 
-    template <class E>
-    inline auto get_slice_implementation(E& /*e*/, xnewaxis_tag&&, std::size_t /*index*/)
-    {
-        return xnewaxis<typename E::size_type>();
+        struct keep_drop_getter
+        {
+            template <class E, class SL>
+            inline decltype(auto) operator()(E& e, SL&& slice, std::size_t index) const
+            {
+                slice.normalize(e.shape()[index]);
+                return std::forward<SL>(slice);
+            }
+
+            template <class E, class SL>
+            inline auto operator()(E& e, const SL& slice, std::size_t index) const
+            {
+                return this->operator()(e, SL(slice), index);
+            }
+        };
+
+        template <class T>
+        struct slice_implementation_getter<xkeep_slice<T>> : keep_drop_getter
+        {
+        };
+
+        template <class T>
+        struct slice_implementation_getter<xdrop_slice<T>> : keep_drop_getter
+        {
+        };
+
+        template <>
+        struct slice_implementation_getter<xall_tag>
+        {
+            template <class E, class SL>
+            inline auto operator()(E& e, SL&&, std::size_t index) const
+            {
+                return xall<typename E::size_type>(e.shape()[index]);
+            }
+        };
+
+        template <>
+        struct slice_implementation_getter<xnewaxis_tag>
+        {
+            template <class E, class SL>
+            inline auto operator()(E&, SL&&, std::size_t) const
+            {
+                return xnewaxis<typename E::size_type>();
+            }
+        };
+
+        template <class A, class B, class C>
+        struct slice_implementation_getter<xrange_adaptor<A, B, C>>
+        {
+            template <class E, class SL>
+            inline auto operator()(E& e, SL&& adaptor, std::size_t index) const
+            {
+                return adaptor.get(e.shape()[index]);
+            }
+        };
     }
 
-    template <class E, class A, class B, class C>
-    inline auto get_slice_implementation(E& e, xrange_adaptor<A, B, C>&& adaptor, std::size_t index)
+    template <class E, class SL>
+    inline auto get_slice_implementation(E& e, SL&& slice, std::size_t index)
     {
-        return adaptor.get(e.shape()[index]);
+        detail::slice_implementation_getter<std::decay_t<SL>> getter;
+        return getter(e, std::forward<SL>(slice), index);
     }
 
     /******************************
@@ -972,12 +978,13 @@ namespace xt
 
     template <class T>
     inline xrange<T>::xrange(size_type start_val, size_type stop_val) noexcept
-        : m_start(start_val), m_size(stop_val > start_val ? stop_val - start_val: 0)
+        : m_start(start_val)
+        , m_size(stop_val > start_val ? stop_val - start_val : 0)
     {
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xrange<T>::operator xrange<S>() const noexcept
     {
         xrange<S> ret;
@@ -987,7 +994,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xrange<S> xrange<T>::convert() const noexcept
     {
         return xrange<S>(*this);
@@ -1047,14 +1054,21 @@ namespace xt
 
     template <class T>
     inline xstepped_range<T>::xstepped_range(size_type start_val, size_type stop_val, size_type step) noexcept
-        : m_start(start_val), m_size(size_type(0)), m_step(step)
+        : m_start(start_val)
+        , m_size(size_type(0))
+        , m_step(step)
     {
+        if ((step > 0 && start_val >= stop_val) || (step < 0 && start_val <= stop_val))
+        {
+            m_size = 0;
+            return;
+        }
         size_type n = stop_val - start_val;
-        m_size = n / step + (((n < 0) ^ (step > 0)) && (n % step));
+        m_size = n / step + static_cast<bool>(n % step);
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xstepped_range<T>::operator xstepped_range<S>() const noexcept
     {
         xstepped_range<S> ret;
@@ -1065,7 +1079,7 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xstepped_range<S> xstepped_range<T>::convert() const noexcept
     {
         return xstepped_range<S>(*this);
@@ -1130,14 +1144,14 @@ namespace xt
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xall<T>::operator xall<S>() const noexcept
     {
         return xall<S>(static_cast<S>(m_size));
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xall<S> xall<T>::convert() const noexcept
     {
         return xall<S>(*this);
@@ -1196,14 +1210,14 @@ namespace xt
      ***************************/
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xnewaxis<T>::operator xnewaxis<S>() const noexcept
     {
         return xnewaxis<S>();
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xnewaxis<S> xnewaxis<T>::convert() const noexcept
     {
         return xnewaxis<S>(*this);
@@ -1262,8 +1276,9 @@ namespace xt
      ******************************/
 
     template <class T>
-    template <class C, typename>
+    template <class C>
     inline xkeep_slice<T>::xkeep_slice(C& cont)
+        requires(!detail::is_xkeep_slice<std::decay_t<C>>::value)
         : m_raw_indices(cont.begin(), cont.end())
     {
     }
@@ -1279,12 +1294,19 @@ namespace xt
     inline xkeep_slice<T>::xkeep_slice(std::initializer_list<S> t)
         : m_raw_indices(t.size())
     {
-        std::transform(t.begin(), t.end(), m_raw_indices.begin(),
-            [](auto t) { return static_cast<size_type>(t); });
+        std::transform(
+            t.begin(),
+            t.end(),
+            m_raw_indices.begin(),
+            [](auto t)
+            {
+                return static_cast<size_type>(t);
+            }
+        );
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xkeep_slice<T>::operator xkeep_slice<S>() const noexcept
     {
         xkeep_slice<S> ret;
@@ -1292,15 +1314,29 @@ namespace xt
         us_type sz = static_cast<us_type>(size());
         ret.m_raw_indices.resize(sz);
         ret.m_indices.resize(sz);
-        std::transform(m_raw_indices.cbegin(), m_raw_indices.cend(), ret.m_raw_indices.begin(),
-                       [](const T& val) { return static_cast<S>(val); });
-        std::transform(m_indices.cbegin(), m_indices.cend(), ret.m_indices.begin(),
-                       [](const T& val) { return static_cast<S>(val); });
+        std::transform(
+            m_raw_indices.cbegin(),
+            m_raw_indices.cend(),
+            ret.m_raw_indices.begin(),
+            [](const T& val)
+            {
+                return static_cast<S>(val);
+            }
+        );
+        std::transform(
+            m_indices.cbegin(),
+            m_indices.cend(),
+            ret.m_indices.begin(),
+            [](const T& val)
+            {
+                return static_cast<S>(val);
+            }
+        );
         return ret;
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xkeep_slice<S> xkeep_slice<T>::convert() const noexcept
     {
         return xkeep_slice<S>(*this);
@@ -1313,14 +1349,15 @@ namespace xt
         std::size_t sz = m_indices.size();
         for (std::size_t i = 0; i < sz; ++i)
         {
-            m_indices[i] = m_raw_indices[i] < 0 ? static_cast<std::ptrdiff_t>(shape) + m_raw_indices[i] : m_raw_indices[i];
+            m_indices[i] = m_raw_indices[i] < 0 ? static_cast<size_type>(shape) + m_raw_indices[i]
+                                                : m_raw_indices[i];
         }
     }
 
     template <class T>
     inline auto xkeep_slice<T>::operator()(size_type i) const noexcept -> size_type
     {
-        return m_indices[static_cast<std::size_t>(i)];
+        return m_indices.size() == size_type(1) ? m_indices.front() : m_indices[static_cast<std::size_t>(i)];
     }
 
     template <class T>
@@ -1332,9 +1369,13 @@ namespace xt
     template <class T>
     inline auto xkeep_slice<T>::step_size(std::size_t i, std::size_t n) const noexcept -> size_type
     {
-        if (i + 1 == m_indices.size())
+        if (m_indices.size() == 1)
         {
-            return 1;
+            return 0;
+        }
+        if (i + n >= m_indices.size())
+        {
+            return m_indices.back() - m_indices[i] + 1;
         }
         else
         {
@@ -1352,7 +1393,7 @@ namespace xt
         }
         else
         {
-            throw std::runtime_error("Index i (" + std::to_string(i) + ") not in indices of islice.");
+            XTENSOR_THROW(std::runtime_error, "Index i (" + std::to_string(i) + ") not in indices of islice.");
         }
     }
 
@@ -1379,8 +1420,9 @@ namespace xt
      ******************************/
 
     template <class T>
-    template <class C, typename>
+    template <class C>
     inline xdrop_slice<T>::xdrop_slice(C& cont)
+        requires(!detail::is_xdrop_slice<std::decay_t<C>>::value)
         : m_raw_indices(cont.begin(), cont.end())
     {
     }
@@ -1396,29 +1438,57 @@ namespace xt
     inline xdrop_slice<T>::xdrop_slice(std::initializer_list<S> t)
         : m_raw_indices(t.size())
     {
-        std::transform(t.begin(), t.end(), m_raw_indices.begin(),
-            [](auto t) { return static_cast<size_type>(t); });
+        std::transform(
+            t.begin(),
+            t.end(),
+            m_raw_indices.begin(),
+            [](auto t)
+            {
+                return static_cast<size_type>(t);
+            }
+        );
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xdrop_slice<T>::operator xdrop_slice<S>() const noexcept
     {
         xdrop_slice<S> ret;
         ret.m_raw_indices.resize(m_raw_indices.size());
         ret.m_indices.resize(m_indices.size());
-        std::transform(m_raw_indices.cbegin(), m_raw_indices.cend(), ret.m_raw_indices.begin(),
-                       [](const T& val) { return static_cast<S>(val); });
-        std::transform(m_indices.cbegin(), m_indices.cend(), ret.m_indices.begin(),
-                       [](const T& val) { return static_cast<S>(val); });
-        std::transform(m_inc.cbegin(), m_inc.cend(), std::inserter(ret.m_inc, ret.m_inc.begin()),
-            [](const auto& val) { return std::make_pair(static_cast<S>(val.first), static_cast<S>(val.second)); });
+        std::transform(
+            m_raw_indices.cbegin(),
+            m_raw_indices.cend(),
+            ret.m_raw_indices.begin(),
+            [](const T& val)
+            {
+                return static_cast<S>(val);
+            }
+        );
+        std::transform(
+            m_indices.cbegin(),
+            m_indices.cend(),
+            ret.m_indices.begin(),
+            [](const T& val)
+            {
+                return static_cast<S>(val);
+            }
+        );
+        std::transform(
+            m_inc.cbegin(),
+            m_inc.cend(),
+            std::inserter(ret.m_inc, ret.m_inc.begin()),
+            [](const auto& val)
+            {
+                return std::make_pair(static_cast<S>(val.first), static_cast<S>(val.second));
+            }
+        );
         ret.m_size = static_cast<S>(m_size);
         return ret;
     }
 
     template <class T>
-    template <class S, typename>
+    template <std::convertible_to<T> S>
     inline xdrop_slice<S> xdrop_slice<T>::convert() const noexcept
     {
         return xdrop_slice<S>(*this);
@@ -1433,7 +1503,8 @@ namespace xt
         std::size_t sz = m_indices.size();
         for (std::size_t i = 0; i < sz; ++i)
         {
-            m_indices[i] = m_raw_indices[i] < 0 ? static_cast<std::ptrdiff_t>(shape) + m_raw_indices[i] : m_raw_indices[i];
+            m_indices[i] = m_raw_indices[i] < 0 ? static_cast<size_type>(shape) + m_raw_indices[i]
+                                                : m_raw_indices[i];
         }
         size_type cum = size_type(0);
         size_type prev_cum = cum;
@@ -1454,7 +1525,7 @@ namespace xt
     template <class T>
     inline auto xdrop_slice<T>::operator()(size_type i) const noexcept -> size_type
     {
-        if (i < m_inc.begin()->first)
+        if (m_inc.empty() || i < m_inc.begin()->first)
         {
             return i;
         }
@@ -1474,13 +1545,13 @@ namespace xt
     template <class T>
     inline auto xdrop_slice<T>::step_size(std::size_t i, std::size_t n) const noexcept -> size_type
     {
-        if(i + 1 == static_cast<std::size_t>(m_size))
+        if (i + n >= static_cast<std::size_t>(m_size))
         {
-            return 1;
+            return (*this)(static_cast<size_type>(m_size - 1)) - (*this)(static_cast<size_type>(i)) + 1;
         }
         else
         {
-            return (*this)(i + n) - (*this)(i);
+            return (*this)(static_cast<size_type>(i + n)) - (*this)(static_cast<size_type>(i));
         }
     }
 
@@ -1496,7 +1567,9 @@ namespace xt
             auto iter = --m_inc.lower_bound(i);
             auto check = iter->first + iter->second;
             if (check > i)
+            {
                 --iter;
+            }
             return i - iter->second;
         }
     }
@@ -1520,6 +1593,4 @@ namespace xt
     }
 }
 
-#undef XTENSOR_CONSTEXPR
-
 #endif
diff --git a/include/xtensor/views/xstrided_view.hpp b/include/xtensor/views/xstrided_view.hpp
new file mode 100644
index 000000000..3faff70c8
--- /dev/null
+++ b/include/xtensor/views/xstrided_view.hpp
@@ -0,0 +1,913 @@
+/***************************************************************************
+ * 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_STRIDED_VIEW_HPP
+#define XTENSOR_STRIDED_VIEW_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+#include <xtl/xsequence.hpp>
+
+#include "../containers/xstorage.hpp"
+#include "../core/xexpression.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xsemantic.hpp"
+#include "../utils/xutils.hpp"
+#include "../views/xstrided_view_base.hpp"
+
+namespace xt
+{
+    /***************************
+     * xstrided_view extension *
+     ***************************/
+
+    namespace extension
+    {
+        template <class Tag, class CT, class S, layout_type L, class FST>
+        struct xstrided_view_base_impl;
+
+        template <class CT, class S, layout_type L, class FST>
+        struct xstrided_view_base_impl<xtensor_expression_tag, CT, S, L, FST>
+        {
+            using type = xtensor_empty_base;
+        };
+
+        template <class CT, class S, layout_type L, class FST>
+        struct xstrided_view_base : xstrided_view_base_impl<xexpression_tag_t<CT>, CT, S, L, FST>
+        {
+        };
+
+        template <class CT, class S, layout_type L, class FST>
+        using xstrided_view_base_t = typename xstrided_view_base<CT, S, L, FST>::type;
+    }
+
+    template <layout_type L1, layout_type L2, class T>
+    struct select_iterable_base
+    {
+        using type = std::conditional_t<L1 == L2 && L1 != layout_type::dynamic, xcontiguous_iterable<T>, xiterable<T>>;
+    };
+
+    template <layout_type L1, layout_type L2, class T>
+    using select_iterable_base_t = typename select_iterable_base<L1, L2, T>::type;
+
+
+    template <class CT, class S, layout_type L, class FST>
+    class xstrided_view;
+
+    template <class CT, class S, layout_type L, class FST>
+    struct xcontainer_inner_types<xstrided_view<CT, S, L, FST>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using undecay_expression = CT;
+        using reference = inner_reference_t<undecay_expression>;
+        using const_reference = typename xexpression_type::const_reference;
+        using size_type = typename xexpression_type::size_type;
+        using shape_type = std::decay_t<S>;
+        using undecay_shape = S;
+        using storage_getter = FST;
+        using inner_storage_type = typename storage_getter::type;
+        using temporary_type = typename detail::xtype_for_shape<
+            S>::template type<typename xexpression_type::value_type, xexpression_type::static_layout>;
+        using storage_type = std::remove_reference_t<inner_storage_type>;
+        static constexpr layout_type layout = L;
+    };
+
+    template <class CT, class S, layout_type L, class FST>
+    struct xiterable_inner_types<xstrided_view<CT, S, L, FST>>
+    {
+        using inner_shape_type = std::decay_t<S>;
+        using inner_strides_type = get_strides_t<inner_shape_type>;
+        using inner_backstrides_type_type = inner_strides_type;
+
+        using const_stepper = std::conditional_t<
+            is_indexed_stepper<typename std::decay_t<CT>::stepper>::value,
+            xindexed_stepper<const xstrided_view<CT, S, L, FST>, true>,
+            xstepper<const xstrided_view<CT, S, L, FST>>>;
+
+        using stepper = std::conditional_t<
+            is_indexed_stepper<typename std::decay_t<CT>::stepper>::value,
+            xindexed_stepper<xstrided_view<CT, S, L, FST>, false>,
+            xstepper<xstrided_view<CT, S, L, FST>>>;
+    };
+
+    template <class CT, class S, layout_type L, class FST, class RHS>
+    struct can_assign<xstrided_view<CT, S, L, FST>, RHS> : can_assign<CT, RHS>
+    {
+    };
+
+    /*****************
+     * xstrided_view *
+     *****************/
+
+    /**
+     * @class xstrided_view
+     * @brief View of an xexpression using strides
+     *
+     * The xstrided_view class implements a view utilizing an initial offset
+     * and strides.
+     *
+     * @tparam CT the closure type of the \ref xexpression type underlying this view
+     * @tparam L the layout of the strided view
+     * @tparam S the strides type of the strided view
+     * @tparam FST the flat storage type used for the strided view
+     *
+     * @sa strided_view, transpose
+     */
+    template <class CT, class S, layout_type L = layout_type::dynamic, class FST = detail::flat_storage_getter<CT, XTENSOR_DEFAULT_TRAVERSAL>>
+    class xstrided_view
+        : public xview_semantic<xstrided_view<CT, S, L, FST>>,
+          public select_iterable_base_t<L, std::decay_t<CT>::static_layout, xstrided_view<CT, S, L, FST>>,
+          private xstrided_view_base<xstrided_view<CT, S, L, FST>>,
+          public extension::xstrided_view_base_t<CT, S, L, FST>
+    {
+    public:
+
+        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 base_type::is_const;
+
+        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 base_type::contiguous_layout;
+        using base_type::static_layout;
+
+        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;
+
+        static constexpr bool provides_simd_interface = has_simd_interface<xexpression_type>::value
+                                                        && L != layout_type::dynamic;
+
+        template <class CTA, class SA>
+        xstrided_view(CTA&& e, SA&& shape, strides_type&& strides, std::size_t offset, layout_type layout) noexcept;
+
+        xstrided_view(const xstrided_view& rhs) = default;
+
+        self_type& operator=(const self_type&);
+
+        template <class E>
+        self_type& operator=(const xexpression<E>& e);
+
+        template <class E>
+        disable_xexpression<E, self_type>& operator=(const E& e);
+
+        using base_type::backstrides;
+        using base_type::dimension;
+        using base_type::is_contiguous;
+        using base_type::layout;
+        using base_type::shape;
+        using base_type::size;
+        using base_type::strides;
+
+        using base_type::operator();
+        using base_type::at;
+        using base_type::unchecked;
+        using base_type::operator[];
+        using base_type::data;
+        using base_type::data_offset;
+        using base_type::element;
+        using base_type::expression;
+        using base_type::storage;
+
+        using base_type::broadcast_shape;
+        using base_type::has_linear_assign;
+
+        template <class T>
+        void fill(const T& 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 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 requested_type>
+        using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
+
+        template <class align, class simd>
+        void store_simd(size_type i, const simd& e)
+            requires provides_simd_interface;
+
+        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
+            requires provides_simd_interface;
+
+        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;
+
+        using container_iterator = std::
+            conditional_t<is_const, typename storage_type::const_iterator, typename storage_type::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>>;
+
+        template <class E>
+        rebind_t<E> build_view(E&& e) const;
+
+    private:
+
+        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 It>
+        It data_xbegin_impl(It begin) const noexcept;
+
+        template <class It>
+        It data_xend_impl(It end, layout_type l, size_type offset) const noexcept;
+
+        void assign_temporary_impl(temporary_type&& tmp);
+
+        using base_type::set_offset;
+
+        template <class C>
+        friend class xstepper;
+        friend class xview_semantic<self_type>;
+        friend class xaccessible<self_type>;
+        friend class xconst_accessible<self_type>;
+        template <class D>
+        friend class xaxis_iterator;
+        template <class D>
+        friend class xaxis_slice_iterator;
+    };
+
+    /**************************
+     * xstrided_view builders *
+     **************************/
+
+    template <class T>
+    using xstrided_slice = std::variant<
+        T,
+
+        xrange_adaptor<placeholders::xtuph, T, T>,
+        xrange_adaptor<T, placeholders::xtuph, T>,
+        xrange_adaptor<T, T, placeholders::xtuph>,
+
+        xrange_adaptor<T, placeholders::xtuph, placeholders::xtuph>,
+        xrange_adaptor<placeholders::xtuph, T, placeholders::xtuph>,
+        xrange_adaptor<placeholders::xtuph, placeholders::xtuph, T>,
+
+        xrange_adaptor<T, T, T>,
+        xrange_adaptor<placeholders::xtuph, placeholders::xtuph, placeholders::xtuph>,
+
+        xrange<T>,
+        xstepped_range<T>,
+
+        xall_tag,
+        xellipsis_tag,
+        xnewaxis_tag>;
+
+    /**
+     * @typedef xstrided_slice_vector
+     * @brief vector of slices used to build a `xstrided_view`
+     */
+    using xstrided_slice_vector = std::vector<xstrided_slice<std::ptrdiff_t>>;
+
+    template <layout_type L = layout_type::dynamic, class E, class S, class X>
+    auto strided_view(E&& e, S&& shape, X&& stride, std::size_t offset = 0, layout_type layout = L) noexcept;
+
+    template <class E>
+    auto strided_view(E&& e, const xstrided_slice_vector& slices);
+
+    /********************************
+     * xstrided_view implementation *
+     ********************************/
+
+    /**
+     * @name Constructor
+     */
+    //@{
+    /**
+     * Constructs an xstrided_view
+     *
+     * @param e the underlying xexpression for this view
+     * @param shape the shape of the view
+     * @param strides the strides of the view
+     * @param offset the offset of the first element in the underlying container
+     * @param layout the layout of the view
+     */
+    template <class CT, class S, layout_type L, class FST>
+    template <class CTA, class SA>
+    inline xstrided_view<CT, S, L, FST>::xstrided_view(
+        CTA&& e,
+        SA&& shape,
+        strides_type&& strides,
+        std::size_t offset,
+        layout_type layout
+    ) noexcept
+        : base_type(std::forward<CTA>(e), std::forward<SA>(shape), std::move(strides), offset, layout)
+    {
+    }
+
+    //@}
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::operator=(const self_type& rhs) -> self_type&
+    {
+        temporary_type tmp(rhs);
+        return this->assign_temporary(std::move(tmp));
+    }
+
+    /**
+     * @name Extended copy semantic
+     */
+    //@{
+    /**
+     * The extended assignment operator.
+     */
+    template <class CT, class S, layout_type L, class FST>
+    template <class E>
+    inline auto xstrided_view<CT, S, L, FST>::operator=(const xexpression<E>& e) -> self_type&
+    {
+        return semantic_base::operator=(e);
+    }
+
+    //@}
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class E>
+    inline auto xstrided_view<CT, S, L, FST>::operator=(const E& e) -> disable_xexpression<E, self_type>&
+    {
+        this->fill(e);
+        return *this;
+    }
+
+    namespace xstrided_view_detail
+    {
+        template <class V, class T>
+        inline void run_assign_temporary_impl(V& v, const T& t, std::true_type /* enable strided assign */)
+        {
+            strided_loop_assigner<true>::run(v, t);
+        }
+
+        template <class V, class T>
+        inline void
+        run_assign_temporary_impl(V& v, const T& t, std::false_type /* fallback to iterator assign */)
+        {
+            std::copy(t.cbegin(), t.cend(), v.begin());
+        }
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline void xstrided_view<CT, S, L, FST>::assign_temporary_impl(temporary_type&& tmp)
+    {
+        constexpr bool
+            fast_assign = xassign_traits<xstrided_view<CT, S, L, FST>, temporary_type>::simd_strided_assign();
+        xstrided_view_detail::run_assign_temporary_impl(*this, tmp, std::integral_constant<bool, fast_assign>{});
+    }
+
+    /**
+     * @name Data
+     */
+    //@{
+
+    /**
+     * Fills the view with the given value.
+     * @param value the value to fill the view with.
+     */
+    template <class CT, class S, layout_type L, class FST>
+    template <class T>
+    inline void xstrided_view<CT, S, L, FST>::fill(const T& value)
+    {
+        if (layout() != layout_type::dynamic)
+        {
+            std::fill(this->linear_begin(), this->linear_end(), value);
+        }
+        else
+        {
+            std::fill(this->begin(), this->end(), value);
+        }
+    }
+
+    //@}
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::data_element(size_type i) -> reference
+    {
+        return storage()[i];
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::data_element(size_type i) const -> const_reference
+    {
+        return storage()[i];
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::flat(size_type i) -> reference
+    {
+        return storage()[i];
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::flat(size_type i) const -> const_reference
+    {
+        return storage()[i];
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_begin() -> linear_iterator
+    {
+        return this->storage().begin() + static_cast<std::ptrdiff_t>(data_offset());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_end() -> linear_iterator
+    {
+        return this->storage().begin() + static_cast<std::ptrdiff_t>(data_offset() + size());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_begin() const -> const_linear_iterator
+    {
+        return this->linear_cbegin();
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_end() const -> const_linear_iterator
+    {
+        return this->linear_cend();
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_cbegin() const -> const_linear_iterator
+    {
+        return this->storage().cbegin() + static_cast<std::ptrdiff_t>(data_offset());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_cend() const -> const_linear_iterator
+    {
+        return this->storage().cbegin() + static_cast<std::ptrdiff_t>(data_offset() + size());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_rbegin() -> reverse_linear_iterator
+    {
+        return reverse_linear_iterator(this->linear_begin());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_rend() -> reverse_linear_iterator
+    {
+        return reverse_linear_iterator(this->linear_end());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_rbegin() const -> const_reverse_linear_iterator
+    {
+        return this->linear_crbegin();
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_rend() const -> const_reverse_linear_iterator
+    {
+        return this->linear_crend();
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_crbegin() const -> const_reverse_linear_iterator
+    {
+        return const_reverse_linear_iterator(this->linear_cbegin());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::linear_crend() const -> const_reverse_linear_iterator
+    {
+        return const_reverse_linear_iterator(this->linear_cend());
+    }
+
+    /***************
+     * stepper api *
+     ***************/
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_begin(const ST& shape) -> disable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return stepper(this, data_xbegin(), offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type l)
+        -> disable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return stepper(this, data_xend(l, offset), offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_begin(const ST& shape) -> enable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return stepper(this, offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type /*l*/)
+        -> enable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return stepper(this, offset, true);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_begin(const ST& shape) const
+        -> disable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return const_stepper(this, data_xbegin(), offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type l) const
+        -> disable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return const_stepper(this, data_xend(l, offset), offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_begin(const ST& shape) const
+        -> enable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return const_stepper(this, offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class ST, class STEP>
+    inline auto xstrided_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type /*l*/) const
+        -> enable_indexed_stepper_t<STEP>
+    {
+        size_type offset = shape.size() - dimension();
+        return const_stepper(this, offset, true);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class It>
+    inline It xstrided_view<CT, S, L, FST>::data_xbegin_impl(It begin) const noexcept
+    {
+        return begin + static_cast<std::ptrdiff_t>(this->data_offset());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class It>
+    inline It
+    xstrided_view<CT, S, L, FST>::data_xend_impl(It begin, layout_type l, size_type offset) const noexcept
+    {
+        return strided_data_end(*this, begin + std::ptrdiff_t(this->data_offset()), l, offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::data_xbegin() noexcept -> container_iterator
+    {
+        return data_xbegin_impl(this->storage().begin());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::data_xbegin() const noexcept -> const_container_iterator
+    {
+        return data_xbegin_impl(this->storage().cbegin());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::data_xend(layout_type l, size_type offset) noexcept
+        -> container_iterator
+    {
+        return data_xend_impl(this->storage().begin(), l, offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    inline auto xstrided_view<CT, S, L, FST>::data_xend(layout_type l, size_type offset) const noexcept
+        -> const_container_iterator
+    {
+        return data_xend_impl(this->storage().cbegin(), l, offset);
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class alignment, class simd>
+    inline void xstrided_view<CT, S, L, FST>::store_simd(size_type i, const simd& e)
+        requires provides_simd_interface
+    {
+        using align_mode = driven_align_mode_t<alignment, data_alignment>;
+        xt_simd::store_as(&(storage()[i]), e, align_mode());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class alignment, class requested_type, std::size_t N>
+    inline auto xstrided_view<CT, S, L, FST>::load_simd(size_type i) const -> simd_return_type<requested_type>
+        requires provides_simd_interface
+    {
+        using align_mode = driven_align_mode_t<alignment, data_alignment>;
+        return xt_simd::load_as<requested_type>(&(storage()[i]), align_mode());
+    }
+
+    template <class CT, class S, layout_type L, class FST>
+    template <class E>
+    inline auto xstrided_view<CT, S, L, FST>::build_view(E&& e) const -> rebind_t<E>
+    {
+        inner_shape_type sh(this->shape());
+        inner_strides_type str(this->strides());
+        return rebind_t<E>(
+            std::forward<E>(e),
+            std::move(sh),
+            std::move(str),
+            base_type::data_offset(),
+            this->layout()
+        );
+    }
+
+    /*****************************************
+     * xstrided_view builders implementation *
+     *****************************************/
+
+    /**
+     * Construct a strided view from an xexpression, shape, strides and offset.
+     *
+     * @param e xexpression
+     * @param shape the shape of the view
+     * @param strides the new strides of the view
+     * @param offset the offset of the first element in the underlying container
+     * @param layout the new layout of the expression
+     *
+     * @tparam L the static layout type of the view (default: dynamic)
+     * @tparam E type of xexpression
+     * @tparam S strides type
+     * @tparam X strides type
+     *
+     * @return the view
+     */
+    template <layout_type L, class E, class S, class X>
+    inline auto strided_view(E&& e, S&& shape, X&& strides, std::size_t offset, layout_type layout) noexcept
+    {
+        using view_type = xstrided_view<xclosure_t<E>, S, L>;
+        return view_type(std::forward<E>(e), std::forward<S>(shape), std::forward<X>(strides), offset, layout);
+    }
+
+    namespace detail
+    {
+        struct no_adj_strides_policy
+        {
+        protected:
+
+            inline void resize(std::size_t)
+            {
+            }
+
+            inline void set_fake_slice(std::size_t)
+            {
+            }
+
+            template <class ST, class S>
+            bool fill_args(
+                const xstrided_slice_vector& /*slices*/,
+                std::size_t /*sl_idx*/,
+                std::size_t /*i*/,
+                std::size_t /*old_shape*/,
+                const ST& /*old_stride*/,
+                S& /*shape*/,
+                get_strides_t<S>& /*strides*/
+            )
+            {
+                return false;
+            }
+        };
+    }
+
+    /**
+     * Function to create a dynamic view from
+     * an xexpression and an xstrided_slice_vector.
+     *
+     * @param e xexpression
+     * @param slices the slice vector
+     *
+     * @return initialized strided_view according to slices
+     *
+     * @code{.cpp}
+     * xt::xarray<double> a = {{1, 2, 3}, {4, 5, 6}};
+     * xt::xstrided_slice_vector sv({xt::range(0, 1)});
+     * sv.push_back(xt::range(0, 3, 2));
+     * auto v = xt::strided_view(a, sv);
+     * // ==> {{1, 3}}
+     * @endcode
+     *
+     * You can also achieve the same with the following short-hand syntax:
+     *
+     * @code{.cpp}
+     * xt::xarray<double> a = {{1, 2, 3}, {4, 5, 6}};
+     * auto v = xt::strided_view(a, {xt::range(0, 1), xt::range(0, 3, 2)});
+     * // ==> {{1, 3}}
+     * @endcode
+     */
+    template <class E>
+    inline auto strided_view(E&& e, const xstrided_slice_vector& slices)
+    {
+        detail::strided_view_args<detail::no_adj_strides_policy> args;
+        args.fill_args(
+            e.shape(),
+            detail::get_strides<XTENSOR_DEFAULT_TRAVERSAL>(e),
+            detail::get_offset<XTENSOR_DEFAULT_TRAVERSAL>(e),
+            e.layout(),
+            slices
+        );
+        using view_type = xstrided_view<xclosure_t<E>, decltype(args.new_shape)>;
+        return view_type(
+            std::forward<E>(e),
+            std::move(args.new_shape),
+            std::move(args.new_strides),
+            args.new_offset,
+            args.new_layout
+        );
+    }
+
+    namespace detail
+    {
+        template <typename S>
+        struct rebind_shape;
+
+        template <std::size_t... X>
+        struct rebind_shape<xt::fixed_shape<X...>>
+        {
+            using type = xt::fixed_shape<X...>;
+        };
+
+        template <class S>
+        struct rebind_shape
+        {
+            using type = rebind_container_t<size_t, S>;
+        };
+
+        template <class S>
+        inline void recalculate_shape_impl(S& shape, size_t size)
+        {
+            if constexpr (std::is_signed_v<get_value_type_t<typename std::decay<S>::type>>)
+            {
+                using value_type = get_value_type_t<typename std::decay_t<S>>;
+                XTENSOR_ASSERT(std::count(shape.cbegin(), shape.cend(), -1) <= 1);
+                auto iter = std::find(shape.begin(), shape.end(), -1);
+                if (iter != std::end(shape))
+                {
+                    const auto total = std::accumulate(shape.cbegin(), shape.cend(), -1, std::multiplies<int>{});
+                    const auto missing_dimension = size / static_cast<size_t>(total);
+                    (*iter) = static_cast<value_type>(missing_dimension);
+                }
+            }
+        }
+
+        template <class S>
+        inline auto recalculate_shape(S&& shape, size_t size)
+        {
+            return recalculate_shape_impl(shape, size);
+        }
+    }
+
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E, class S>
+    inline auto reshape_view(E&& e, S&& shape)
+    {
+        static_assert(
+            L == layout_type::row_major || L == layout_type::column_major,
+            "traversal has to be row or column major"
+        );
+
+        using shape_type = std::decay_t<decltype(shape)>;
+        using unsigned_shape_type = typename detail::rebind_shape<shape_type>::type;
+        get_strides_t<unsigned_shape_type> strides;
+
+        detail::recalculate_shape(shape, e.size());
+        xt::resize_container(strides, shape.size());
+        compute_strides(shape, L, strides);
+        constexpr auto computed_layout = std::decay_t<E>::static_layout == L ? L : layout_type::dynamic;
+        using view_type = xstrided_view<
+            xclosure_t<E>,
+            unsigned_shape_type,
+            computed_layout,
+            detail::flat_adaptor_getter<xclosure_t<E>, L>>;
+        return view_type(
+            std::forward<E>(e),
+            xtl::forward_sequence<unsigned_shape_type, S>(shape),
+            std::move(strides),
+            0,
+            e.layout()
+        );
+    }
+
+    /**
+     * @deprecated
+     * @brief Return a view on a container with a new shape
+     *
+     * Note: if you resize the underlying container, this view becomes
+     * invalidated.
+     *
+     * @param e xexpression to reshape
+     * @param shape new shape
+     * @param order traversal order (optional)
+     *
+     * @return view on xexpression with new shape
+     */
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E, class S>
+    inline auto reshape_view(E&& e, S&& shape, layout_type /*order*/)
+    {
+        return reshape_view<L>(std::forward<E>(e), std::forward<S>(shape));
+    }
+
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E, class I, std::size_t N>
+    inline auto reshape_view(E&& e, const I (&shape)[N], layout_type order)
+    {
+        using shape_type = std::array<std::size_t, N>;
+        return reshape_view<L>(std::forward<E>(e), xtl::forward_sequence<shape_type, decltype(shape)>(shape), order);
+    }
+
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E, class I, std::size_t N>
+    inline auto reshape_view(E&& e, const I (&shape)[N])
+    {
+        using shape_type = std::array<I, N>;
+        return reshape_view<L>(std::forward<E>(e), xtl::forward_sequence<shape_type, decltype(shape)>(shape));
+    }
+}
+
+#endif
diff --git a/include/xtensor/views/xstrided_view_base.hpp b/include/xtensor/views/xstrided_view_base.hpp
new file mode 100644
index 000000000..bea02ac12
--- /dev/null
+++ b/include/xtensor/views/xstrided_view_base.hpp
@@ -0,0 +1,972 @@
+/***************************************************************************
+ * 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_STRIDED_VIEW_BASE_HPP
+#define XTENSOR_STRIDED_VIEW_BASE_HPP
+
+#include <type_traits>
+#include <variant>
+
+#include <xtl/xsequence.hpp>
+
+#include "../core/xaccessible.hpp"
+#include "../core/xstrides.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../utils/xutils.hpp"
+#include "../views/xslice.hpp"
+
+namespace xt
+{
+    namespace detail
+    {
+        template <class CT, layout_type L>
+        class flat_expression_adaptor
+        {
+        public:
+
+            using xexpression_type = std::decay_t<CT>;
+            using shape_type = typename xexpression_type::shape_type;
+            using inner_strides_type = get_strides_t<shape_type>;
+            using index_type = inner_strides_type;
+            using size_type = typename xexpression_type::size_type;
+            using value_type = typename xexpression_type::value_type;
+            using const_reference = typename xexpression_type::const_reference;
+            using reference = std::conditional_t<
+                std::is_const<std::remove_reference_t<CT>>::value,
+                typename xexpression_type::const_reference,
+                typename xexpression_type::reference>;
+
+            using iterator = decltype(std::declval<std::remove_reference_t<CT>>().template begin<L>());
+            using const_iterator = decltype(std::declval<std::decay_t<CT>>().template cbegin<L>());
+            using reverse_iterator = decltype(std::declval<std::remove_reference_t<CT>>().template rbegin<L>());
+            using const_reverse_iterator = decltype(std::declval<std::decay_t<CT>>().template crbegin<L>());
+
+            explicit flat_expression_adaptor(CT* e);
+
+            template <class FST>
+            flat_expression_adaptor(CT* e, FST&& strides);
+
+            void update_pointer(CT* ptr) const;
+
+            size_type size() const;
+            reference operator[](size_type idx);
+            const_reference operator[](size_type idx) const;
+
+            iterator begin();
+            iterator end();
+            const_iterator begin() const;
+            const_iterator end() const;
+            const_iterator cbegin() const;
+            const_iterator cend() const;
+
+        private:
+
+            static index_type& get_index();
+
+            mutable CT* m_e;
+            inner_strides_type m_strides;
+            size_type m_size;
+        };
+
+        template <class T>
+        struct is_flat_expression_adaptor : std::false_type
+        {
+        };
+
+        template <class CT, layout_type L>
+        struct is_flat_expression_adaptor<flat_expression_adaptor<CT, L>> : std::true_type
+        {
+        };
+
+        template <class E, class ST>
+        struct provides_data_interface
+            : std::bool_constant<data_interface_expression<std::decay_t<E>> && !is_flat_expression_adaptor<ST>::value>
+        {
+        };
+    }
+
+    template <class D>
+    class xstrided_view_base : public xaccessible<D>
+    {
+    public:
+
+        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;
+        static constexpr bool is_const = std::is_const<std::remove_reference_t<undecay_expression>>::value;
+
+        using value_type = typename xexpression_type::value_type;
+        using reference = typename inner_types::reference;
+        using const_reference = typename inner_types::const_reference;
+        using pointer = std::
+            conditional_t<is_const, typename xexpression_type::const_pointer, typename xexpression_type::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;
+
+        static constexpr layout_type static_layout = inner_types::layout;
+        static constexpr bool contiguous_layout = static_layout != layout_type::dynamic
+                                                  && xexpression_type::contiguous_layout;
+
+        static constexpr bool
+            provides_data_interface = detail::provides_data_interface<xexpression_type, storage_type>::value;
+
+        template <class CTA, class SA>
+        xstrided_view_base(CTA&& e, SA&& shape, strides_type&& strides, size_type offset, layout_type layout) noexcept;
+
+        xstrided_view_base(xstrided_view_base&& rhs);
+
+        xstrided_view_base(const xstrided_view_base& rhs);
+
+        const inner_shape_type& shape() const noexcept;
+        const inner_strides_type& strides() const noexcept;
+        const inner_backstrides_type& backstrides() const noexcept;
+        layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+        using base_type::shape;
+
+        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;
+
+        template <class It>
+        reference element(It first, It last);
+
+        template <class It>
+        const_reference element(It first, It last) const;
+
+        storage_type& storage() noexcept;
+        const storage_type& storage() const noexcept;
+
+        pointer data() noexcept
+            requires(provides_data_interface);
+        const_pointer data() const noexcept
+            requires(provides_data_interface);
+
+        size_type data_offset() const noexcept;
+
+        xexpression_type& expression() noexcept;
+        const xexpression_type& expression() const noexcept;
+
+        template <class O>
+        bool broadcast_shape(O& shape, bool reuse_cache = false) const;
+
+        template <class O>
+        bool has_linear_assign(const O& strides) const noexcept;
+
+    protected:
+
+        using offset_type = typename strides_type::value_type;
+
+        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;
+
+        void set_offset(size_type offset);
+
+    private:
+
+        undecay_expression m_e;
+        inner_storage_type m_storage;
+        inner_shape_type m_shape;
+        inner_strides_type m_strides;
+        inner_backstrides_type m_backstrides;
+        size_type m_offset;
+        layout_type m_layout;
+    };
+
+    /***************************
+     * flat_expression_adaptor *
+     ***************************/
+
+    namespace detail
+    {
+        template <class CT>
+        struct inner_storage_getter
+        {
+            using type = decltype(std::declval<CT>().storage());
+            using reference = std::add_lvalue_reference_t<CT>;
+
+            template <class E>
+            using rebind_t = inner_storage_getter<E>;
+
+            static decltype(auto) get_flat_storage(reference e)
+            {
+                return e.storage();
+            }
+
+            static auto get_offset(reference e)
+            {
+                return e.data_offset();
+            }
+
+            static decltype(auto) get_strides(reference e)
+            {
+                return e.strides();
+            }
+        };
+
+        template <class CT, layout_type L>
+        struct flat_adaptor_getter
+        {
+            using type = flat_expression_adaptor<std::remove_reference_t<CT>, L>;
+            using reference = std::add_lvalue_reference_t<CT>;
+
+            template <class E>
+            using rebind_t = flat_adaptor_getter<E, L>;
+
+            static type get_flat_storage(reference e)
+            {
+                // moved to addressof because ampersand on xview returns a closure pointer
+                return type(std::addressof(e));
+            }
+
+            static auto get_offset(reference)
+            {
+                return typename std::decay_t<CT>::size_type(0);
+            }
+
+            static auto get_strides(reference e)
+            {
+                dynamic_shape<std::ptrdiff_t> strides;
+                strides.resize(e.shape().size());
+                compute_strides(e.shape(), L, strides);
+                return strides;
+            }
+        };
+
+        template <class CT, layout_type L>
+        using flat_storage_getter = std::conditional_t<
+            data_interface_expression<std::decay_t<CT>>,
+            inner_storage_getter<CT>,
+            flat_adaptor_getter<CT, L>>;
+
+        template <layout_type L, class E>
+        inline auto get_offset(E& e)
+        {
+            return flat_storage_getter<E, L>::get_offset(e);
+        }
+
+        template <layout_type L, class E>
+        inline decltype(auto) get_strides(E& e)
+        {
+            return flat_storage_getter<E, L>::get_strides(e);
+        }
+    }
+
+    /*************************************
+     * xstrided_view_base implementation *
+     *************************************/
+
+    /**
+     * @name Constructor
+     */
+    //@{
+    /**
+     * Constructs an xstrided_view_base
+     *
+     * @param e the underlying xexpression for this view
+     * @param shape the shape of the view
+     * @param strides the strides of the view
+     * @param offset the offset of the first element in the underlying container
+     * @param layout the layout of the view
+     */
+    template <class D>
+    template <class CTA, class SA>
+    inline xstrided_view_base<D>::xstrided_view_base(
+        CTA&& e,
+        SA&& shape,
+        strides_type&& strides,
+        size_type offset,
+        layout_type layout
+    ) noexcept
+        : m_e(std::forward<CTA>(e))
+        ,
+        // m_storage(detail::get_flat_storage<undecay_expression>(m_e)),
+        m_storage(storage_getter::get_flat_storage(m_e))
+        , m_shape(std::forward<SA>(shape))
+        , m_strides(std::move(strides))
+        , m_offset(offset)
+        , m_layout(layout)
+    {
+        m_backstrides = xtl::make_sequence<backstrides_type>(m_shape.size(), 0);
+        adapt_strides(m_shape, m_strides, m_backstrides);
+    }
+
+    namespace detail
+    {
+        template <class T, class S>
+        auto& copy_move_storage(T& expr, const S& /*storage*/)
+        {
+            return expr.storage();
+        }
+
+        template <class T, class E, layout_type L>
+        auto copy_move_storage(T& expr, const detail::flat_expression_adaptor<E, L>& storage)
+        {
+            detail::flat_expression_adaptor<E, L> new_storage = storage;  // copy storage
+            new_storage.update_pointer(std::addressof(expr));
+            return new_storage;
+        }
+    }
+
+    template <class D>
+    inline xstrided_view_base<D>::xstrided_view_base(xstrided_view_base&& rhs)
+        : base_type(std::move(rhs))
+        , m_e(std::forward<undecay_expression>(rhs.m_e))
+        , m_storage(detail::copy_move_storage(m_e, rhs.m_storage))
+        , m_shape(std::move(rhs.m_shape))
+        , m_strides(std::move(rhs.m_strides))
+        , m_backstrides(std::move(rhs.m_backstrides))
+        , m_offset(std::move(rhs.m_offset))
+        , m_layout(std::move(rhs.m_layout))
+    {
+    }
+
+    template <class D>
+    inline xstrided_view_base<D>::xstrided_view_base(const xstrided_view_base& rhs)
+        : base_type(rhs)
+        , m_e(rhs.m_e)
+        , m_storage(detail::copy_move_storage(m_e, rhs.m_storage))
+        , m_shape(rhs.m_shape)
+        , m_strides(rhs.m_strides)
+        , m_backstrides(rhs.m_backstrides)
+        , m_offset(rhs.m_offset)
+        , m_layout(rhs.m_layout)
+    {
+    }
+
+    //@}
+
+    /**
+     * @name Size and shape
+     */
+    //@{
+    /**
+     * Returns the shape of the xtrided_view_base.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::shape() const noexcept -> const inner_shape_type&
+    {
+        return m_shape;
+    }
+
+    /**
+     * Returns the strides of the xtrided_view_base.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::strides() const noexcept -> const inner_strides_type&
+    {
+        return m_strides;
+    }
+
+    /**
+     * Returns the backstrides of the xtrided_view_base.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::backstrides() const noexcept -> const inner_backstrides_type&
+    {
+        return m_backstrides;
+    }
+
+    /**
+     * Returns the layout of the xtrided_view_base.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::layout() const noexcept -> layout_type
+    {
+        return m_layout;
+    }
+
+    template <class D>
+    inline bool xstrided_view_base<D>::is_contiguous() const noexcept
+    {
+        return m_layout != layout_type::dynamic && m_e.is_contiguous();
+    }
+
+    //@}
+
+    /**
+     * @name Data
+     */
+    //@{
+    template <class D>
+    inline auto xstrided_view_base<D>::operator()() -> reference
+    {
+        return m_storage[static_cast<size_type>(m_offset)];
+    }
+
+    template <class D>
+    inline auto xstrided_view_base<D>::operator()() const -> const_reference
+    {
+        return m_storage[static_cast<size_type>(m_offset)];
+    }
+
+    /**
+     * Returns a reference to the element at the specified position in the view.
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xstrided_view_base<D>::operator()(Args... args) -> reference
+    {
+        XTENSOR_TRY(check_index(shape(), args...));
+        XTENSOR_CHECK_DIMENSION(shape(), args...);
+        offset_type index = compute_index(args...);
+        return m_storage[static_cast<size_type>(index)];
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the view.
+     * @param args a 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.
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xstrided_view_base<D>::operator()(Args... args) const -> const_reference
+    {
+        XTENSOR_TRY(check_index(shape(), args...));
+        XTENSOR_CHECK_DIMENSION(shape(), args...);
+        offset_type index = compute_index(args...);
+        return m_storage[static_cast<size_type>(index)];
+    }
+
+    /**
+     * Returns a reference to the element at the specified position in the view.
+     * @param args a 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.
+     * @warning This method is NOT compatible with broadcasting, meaning the following
+     * code has undefined behavior:
+     * @code{.cpp}
+     * xt::xarray<double> a = {{0, 1}, {2, 3}};
+     * xt::xarray<double> b = {0, 1};
+     * auto fd = a + b;
+     * double res = fd.uncheked(0, 1);
+     * @endcode
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xstrided_view_base<D>::unchecked(Args... args) -> reference
+    {
+        offset_type index = compute_unchecked_index(args...);
+        return m_storage[static_cast<size_type>(index)];
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the view.
+     * @param args a 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.
+     * @warning This method is NOT compatible with broadcasting, meaning the following
+     * code has undefined behavior:
+     * @code{.cpp}
+     * xt::xarray<double> a = {{0, 1}, {2, 3}};
+     * xt::xarray<double> b = {0, 1};
+     * auto fd = a + b;
+     * double res = fd.uncheked(0, 1);
+     * @endcode
+     */
+    template <class D>
+    template <class... Args>
+    inline auto xstrided_view_base<D>::unchecked(Args... args) const -> const_reference
+    {
+        offset_type index = compute_unchecked_index(args...);
+        return m_storage[static_cast<size_type>(index)];
+    }
+
+    /**
+     * Returns a reference to the element at the specified position in the view.
+     * @param first iterator starting the sequence of indices
+     * @param last iterator 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..
+     */
+    template <class D>
+    template <class It>
+    inline auto xstrided_view_base<D>::element(It first, It last) -> reference
+    {
+        XTENSOR_TRY(check_element_index(shape(), first, last));
+        return m_storage[static_cast<size_type>(compute_element_index(first, last))];
+    }
+
+    /**
+     * Returns a constant reference to the element at the specified position in the view.
+     * @param first iterator starting the sequence of indices
+     * @param last iterator 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..
+     */
+    template <class D>
+    template <class It>
+    inline auto xstrided_view_base<D>::element(It first, It last) const -> const_reference
+    {
+        XTENSOR_TRY(check_element_index(shape(), first, last));
+        return m_storage[static_cast<size_type>(compute_element_index(first, last))];
+    }
+
+    /**
+     * Returns a reference to the buffer containing the elements of the view.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::storage() noexcept -> storage_type&
+    {
+        return m_storage;
+    }
+
+    /**
+     * Returns a constant reference to the buffer containing the elements of the view.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::storage() const noexcept -> const storage_type&
+    {
+        return m_storage;
+    }
+
+    /**
+     * Returns a pointer to the underlying array serving as element storage.
+     * The first element of the view is at data() + data_offset().
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::data() noexcept -> pointer
+        requires(provides_data_interface)
+    {
+        return m_e.data();
+    }
+
+    /**
+     * Returns a constant pointer to the underlying array serving as element storage.
+     * The first element of the view is at data() + data_offset().
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::data() const noexcept -> const_pointer
+        requires(provides_data_interface)
+    {
+        return m_e.data();
+    }
+
+    /**
+     * Returns the offset to the first element in the view.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::data_offset() const noexcept -> size_type
+    {
+        return m_offset;
+    }
+
+    /**
+     * Returns a reference to the underlying expression of the view.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::expression() noexcept -> xexpression_type&
+    {
+        return m_e;
+    }
+
+    /**
+     * Returns a constant reference to the underlying expression of the view.
+     */
+    template <class D>
+    inline auto xstrided_view_base<D>::expression() const noexcept -> const xexpression_type&
+    {
+        return m_e;
+    }
+
+    //@}
+
+    /**
+     * @name Broadcasting
+     */
+    //@{
+    /**
+     * Broadcast the shape of the view to the specified parameter.
+     * @param shape the result shape
+     * @param reuse_cache parameter for internal optimization
+     * @return a boolean indicating whether the broadcasting is trivial
+     */
+    template <class D>
+    template <class O>
+    inline bool xstrided_view_base<D>::broadcast_shape(O& shape, bool) const
+    {
+        return xt::broadcast_shape(m_shape, shape);
+    }
+
+    /**
+     * Checks whether the xstrided_view_base can be linearly assigned to an expression
+     * with the specified strides.
+     * @return a boolean indicating whether a linear assign is possible
+     */
+    template <class D>
+    template <class O>
+    inline bool xstrided_view_base<D>::has_linear_assign(const O& str) const noexcept
+    {
+        return data_interface_expression<xexpression_type> && str.size() == strides().size()
+               && std::equal(str.cbegin(), str.cend(), strides().begin());
+    }
+
+    //@}
+
+    template <class D>
+    template <class... Args>
+    inline auto xstrided_view_base<D>::compute_index(Args... args) const -> offset_type
+    {
+        return static_cast<offset_type>(m_offset)
+               + xt::data_offset<offset_type>(strides(), static_cast<offset_type>(args)...);
+    }
+
+    template <class D>
+    template <class... Args>
+    inline auto xstrided_view_base<D>::compute_unchecked_index(Args... args) const -> offset_type
+    {
+        return static_cast<offset_type>(m_offset)
+               + xt::unchecked_data_offset<offset_type>(strides(), static_cast<offset_type>(args)...);
+    }
+
+    template <class D>
+    template <class It>
+    inline auto xstrided_view_base<D>::compute_element_index(It first, It last) const -> offset_type
+    {
+        return static_cast<offset_type>(m_offset) + xt::element_offset<offset_type>(strides(), first, last);
+    }
+
+    template <class D>
+    void xstrided_view_base<D>::set_offset(size_type offset)
+    {
+        m_offset = offset;
+    }
+
+    /******************************************
+     * flat_expression_adaptor implementation *
+     ******************************************/
+
+    namespace detail
+    {
+        template <class CT, layout_type L>
+        inline flat_expression_adaptor<CT, L>::flat_expression_adaptor(CT* e)
+            : m_e(e)
+        {
+            resize_container(get_index(), m_e->dimension());
+            resize_container(m_strides, m_e->dimension());
+            m_size = compute_size(m_e->shape());
+            compute_strides(m_e->shape(), L, m_strides);
+        }
+
+        template <class CT, layout_type L>
+        template <class FST>
+        inline flat_expression_adaptor<CT, L>::flat_expression_adaptor(CT* e, FST&& strides)
+            : m_e(e)
+            , m_strides(xtl::forward_sequence<inner_strides_type, FST>(strides))
+        {
+            resize_container(get_index(), m_e->dimension());
+            m_size = m_e->size();
+        }
+
+        template <class CT, layout_type L>
+        inline void flat_expression_adaptor<CT, L>::update_pointer(CT* ptr) const
+        {
+            m_e = ptr;
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::size() const -> size_type
+        {
+            return m_size;
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::operator[](size_type idx) -> reference
+        {
+            auto i = static_cast<typename index_type::value_type>(idx);
+            get_index() = detail::unravel_noexcept(i, m_strides, L);
+            return m_e->element(get_index().cbegin(), get_index().cend());
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::operator[](size_type idx) const -> const_reference
+        {
+            auto i = static_cast<typename index_type::value_type>(idx);
+            get_index() = detail::unravel_noexcept(i, m_strides, L);
+            return m_e->element(get_index().cbegin(), get_index().cend());
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::begin() -> iterator
+        {
+            return m_e->template begin<L>();
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::end() -> iterator
+        {
+            return m_e->template end<L>();
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::begin() const -> const_iterator
+        {
+            return m_e->template cbegin<L>();
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::end() const -> const_iterator
+        {
+            return m_e->template cend<L>();
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::cbegin() const -> const_iterator
+        {
+            return m_e->template cbegin<L>();
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::cend() const -> const_iterator
+        {
+            return m_e->template cend<L>();
+        }
+
+        template <class CT, layout_type L>
+        inline auto flat_expression_adaptor<CT, L>::get_index() -> index_type&
+        {
+            thread_local static index_type index;
+            return index;
+        }
+    }
+
+    /**********************************
+     * Builder helpers implementation *
+     **********************************/
+
+    namespace detail
+    {
+        template <class S>
+        struct slice_getter_impl
+        {
+            const S& m_shape;
+            mutable std::size_t idx;
+            using array_type = std::array<std::ptrdiff_t, 3>;
+
+            explicit slice_getter_impl(const S& shape)
+                : m_shape(shape)
+                , idx(0)
+            {
+            }
+
+            template <class T>
+            array_type operator()(const T& /*t*/) const
+            {
+                return array_type{{0, 0, 0}};
+            }
+
+            template <class A, class B, class C>
+            array_type operator()(const xrange_adaptor<A, B, C>& range) const
+            {
+                auto sl = range.get(static_cast<std::size_t>(m_shape[idx]));
+                return array_type({sl(0), sl.size(), sl.step_size()});
+            }
+
+            template <class T>
+            array_type operator()(const xrange<T>& range) const
+            {
+                return array_type({range(T(0)), range.size(), T(1)});
+            }
+
+            template <class T>
+            array_type operator()(const xstepped_range<T>& range) const
+            {
+                return array_type({range(T(0)), range.size(), range.step_size(T(0))});
+            }
+        };
+
+        template <class adj_strides_policy>
+        struct strided_view_args : adj_strides_policy
+        {
+            using base_type = adj_strides_policy;
+
+            template <class S, class ST, class V>
+            void
+            fill_args(const S& shape, ST&& old_strides, std::size_t base_offset, layout_type layout, const V& slices)
+            {
+                // Compute dimension
+                std::size_t dimension = shape.size(), n_newaxis = 0, n_add_all = 0;
+                std::ptrdiff_t dimension_check = static_cast<std::ptrdiff_t>(shape.size());
+
+                bool has_ellipsis = false;
+                for (const auto& el : slices)
+                {
+                    if (std::get_if<xt::xnewaxis_tag>(&el) != nullptr)
+                    {
+                        ++dimension;
+                        ++n_newaxis;
+                    }
+                    else if (std::get_if<std::ptrdiff_t>(&el) != nullptr)
+                    {
+                        --dimension;
+                        --dimension_check;
+                    }
+                    else if (std::get_if<xt::xellipsis_tag>(&el) != nullptr)
+                    {
+                        if (has_ellipsis == true)
+                        {
+                            XTENSOR_THROW(std::runtime_error, "Ellipsis can only appear once.");
+                        }
+                        has_ellipsis = true;
+                    }
+                    else
+                    {
+                        --dimension_check;
+                    }
+                }
+
+                if (dimension_check < 0)
+                {
+                    XTENSOR_THROW(std::runtime_error, "Too many slices for view.");
+                }
+
+                if (has_ellipsis)
+                {
+                    // replace ellipsis with N * xt::all
+                    // remove -1 because of the ellipsis slize itself
+                    n_add_all = shape.size() - (slices.size() - 1 - n_newaxis);
+                }
+
+                // Compute strided view
+                new_offset = base_offset;
+                new_shape.resize(dimension);
+                new_strides.resize(dimension);
+                base_type::resize(dimension);
+
+                auto old_shape = shape;
+                using old_strides_value_type = typename std::decay_t<ST>::value_type;
+
+                std::ptrdiff_t axis_skip = 0;
+                std::size_t idx = 0, i = 0, i_ax = 0;
+
+                auto slice_getter = detail::slice_getter_impl<S>(shape);
+
+                for (; i < slices.size(); ++i)
+                {
+                    i_ax = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(i) - axis_skip);
+                    auto ptr = std::get_if<std::ptrdiff_t>(&slices[i]);
+                    if (ptr != nullptr)
+                    {
+                        auto slice0 = static_cast<old_strides_value_type>(*ptr);
+                        new_offset += static_cast<std::size_t>(slice0 * old_strides[i_ax]);
+                    }
+                    else if (std::get_if<xt::xnewaxis_tag>(&slices[i]) != nullptr)
+                    {
+                        new_shape[idx] = 1;
+                        base_type::set_fake_slice(idx);
+                        ++axis_skip, ++idx;
+                    }
+                    else if (std::get_if<xt::xellipsis_tag>(&slices[i]) != nullptr)
+                    {
+                        for (std::size_t j = 0; j < n_add_all; ++j)
+                        {
+                            new_shape[idx] = old_shape[i_ax];
+                            new_strides[idx] = old_strides[i_ax];
+                            base_type::set_fake_slice(idx);
+                            ++idx, ++i_ax;
+                        }
+                        axis_skip = axis_skip - static_cast<std::ptrdiff_t>(n_add_all) + 1;
+                    }
+                    else if (std::get_if<xt::xall_tag>(&slices[i]) != nullptr)
+                    {
+                        new_shape[idx] = old_shape[i_ax];
+                        new_strides[idx] = old_strides[i_ax];
+                        base_type::set_fake_slice(idx);
+                        ++idx;
+                    }
+                    else if (base_type::fill_args(slices, i, idx, old_shape[i_ax], old_strides[i_ax], new_shape, new_strides))
+                    {
+                        ++idx;
+                    }
+                    else
+                    {
+                        slice_getter.idx = i_ax;
+                        auto info = std::visit(slice_getter, slices[i]);
+                        new_offset += static_cast<std::size_t>(info[0] * old_strides[i_ax]);
+                        new_shape[idx] = static_cast<std::size_t>(info[1]);
+                        new_strides[idx] = info[2] * old_strides[i_ax];
+                        base_type::set_fake_slice(idx);
+                        ++idx;
+                    }
+                }
+
+                i_ax = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(i) - axis_skip);
+                for (; i_ax < old_shape.size(); ++i_ax, ++idx)
+                {
+                    new_shape[idx] = old_shape[i_ax];
+                    new_strides[idx] = old_strides[i_ax];
+                    base_type::set_fake_slice(idx);
+                }
+
+                new_layout = do_strides_match(new_shape, new_strides, layout, true) ? layout
+                                                                                    : layout_type::dynamic;
+            }
+
+            using shape_type = dynamic_shape<std::size_t>;
+            shape_type new_shape;
+            using strides_type = dynamic_shape<std::ptrdiff_t>;
+            strides_type new_strides;
+            std::size_t new_offset;
+            layout_type new_layout;
+        };
+    }
+}
+
+#endif
diff --git a/include/xtensor/xview.hpp b/include/xtensor/views/xview.hpp
similarity index 58%
rename from include/xtensor/xview.hpp
rename to include/xtensor/views/xview.hpp
index 5d7eab9db..c647572de 100644
--- a/include/xtensor/xview.hpp
+++ b/include/xtensor/views/xview.hpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_VIEW_HPP
 #define XTENSOR_VIEW_HPP
@@ -17,19 +18,21 @@
 #include <utility>
 
 #include <xtl/xclosure.hpp>
-#include <xtl/xsequence.hpp>
 #include <xtl/xmeta_utils.hpp>
+#include <xtl/xsequence.hpp>
 #include <xtl/xtype_traits.hpp>
 
-#include "xbroadcast.hpp"
-#include "xcontainer.hpp"
-#include "xiterable.hpp"
-#include "xsemantic.hpp"
-#include "xslice.hpp"
-#include "xtensor_forward.hpp"
-#include "xtensor.hpp"
-#include "xview_utils.hpp"
-
+#include "../containers/xarray.hpp"
+#include "../containers/xcontainer.hpp"
+#include "../containers/xtensor.hpp"
+#include "../core/xaccessible.hpp"
+#include "../core/xiterable.hpp"
+#include "../core/xsemantic.hpp"
+#include "../core/xtensor_config.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../views/xbroadcast.hpp"
+#include "../views/xslice.hpp"
+#include "../views/xview_utils.hpp"
 
 namespace xt
 {
@@ -62,13 +65,6 @@ namespace xt
      * xview declaration *
      *********************/
 
-    template <class CT, class... S>
-    struct xcontainer_inner_types<xview<CT, S...>>
-    {
-        using xexpression_type = std::decay_t<CT>;
-        using temporary_type = view_temporary_type_t<xexpression_type, S...>;
-    };
-
     template <bool is_const, class CT, class... S>
     class xview_stepper;
 
@@ -79,26 +75,22 @@ namespace xt
     {
 
         template <class T>
-        struct is_xrange
-            : std::false_type
+        struct is_xrange : std::false_type
         {
         };
 
         template <class T>
-        struct is_xrange<xrange<T>>
-            : std::true_type
+        struct is_xrange<xrange<T>> : std::true_type
         {
         };
 
         template <class S>
-        struct is_xall_slice
-            : std::false_type
+        struct is_xall_slice : std::false_type
         {
         };
 
         template <class T>
-        struct is_xall_slice<xall<T>>
-            : std::true_type
+        struct is_xall_slice<xall<T>> : std::true_type
         {
         };
 
@@ -137,39 +129,40 @@ namespace xt
         template <class CT, class... S>
         struct is_xscalar_impl<xview<CT, S...>>
         {
-            static constexpr bool value = static_cast<std::ptrdiff_t>(integral_count<S...>()) == static_dimension<typename std::decay_t<CT>::shape_type>::value ? true : false;
+            static constexpr bool value = static_cast<std::ptrdiff_t>(integral_count<S...>()
+                                          ) == static_dimension<typename std::decay_t<CT>::shape_type>::value
+                                              ? true
+                                              : false;
         };
 
-        template <class S>
-        struct is_strided_slice_impl
-            : std::true_type
-        {
-        };
+        template <typename S>
+        inline constexpr bool is_strided_slice_impl = true;
+        template <typename T>
+        inline constexpr bool is_strided_slice_impl<xkeep_slice<T>> = false;
+        template <typename T>
+        inline constexpr bool is_strided_slice_impl<xdrop_slice<T>> = false;
 
-        template <class T>
-        struct is_strided_slice_impl<xkeep_slice<T>>
-            : std::false_type
-        {
-        };
+        template <typename S>
+        concept is_strided_slice_concept = is_strided_slice_impl<S>;
 
-        template <class T>
-        struct is_strided_slice_impl<xdrop_slice<T>>
-            : std::false_type
+        template <class... S>
+        constexpr bool is_strided_slice()
         {
-        };
+            return (is_strided_slice_concept<std::decay_t<S>> && ...);
+        }
 
         // If we have no discontiguous slices, we can calculate strides for this view.
         template <class E, class... S>
         struct is_strided_view
-            : std::integral_constant<bool, xtl::conjunction<has_data_interface<E>, is_strided_slice_impl<S>...>::value>
+            : std::integral_constant<bool, data_interface_expression<E> && is_strided_slice<S...>()>
         {
         };
 
         // if row major the view can only be (statically) computed as contiguous if:
-        // any number of integers is followed by either one or no range which 
+        // any number of integers is followed by either one or no range which
         // are followed by explicit (or implicit) all's
-        // 
-        // e.g. 
+        //
+        // e.g.
         //      (i, j, all(), all()) == contiguous
         //      (i, range(0, 2), all()) == contiguous
         //      (i) == contiguous (implicit all slices)
@@ -180,18 +173,19 @@ namespace xt
         {
             using slice = xtl::mpl::front_t<V>;
             static constexpr bool is_range_slice = is_xrange<slice>::value;
-            static constexpr bool is_int_slice = std::is_integral<slice>::value;
+            static constexpr bool is_int_slice = xtl::is_integral<slice>::value;
             static constexpr bool is_all_slice = is_xall_slice<slice>::value;
             static constexpr bool have_all_seen = all_seen || is_all_slice;
             static constexpr bool have_range_seen = is_range_slice;
 
-            static constexpr bool is_valid = valid && (have_all_seen ? is_all_slice : (!range_seen && (is_int_slice || is_range_slice)));
+            static constexpr bool is_valid = valid
+                                             && (have_all_seen
+                                                     ? is_all_slice
+                                                     : (!range_seen && (is_int_slice || is_range_slice)));
 
-            static constexpr bool value = is_contiguous_view_impl<layout_type::row_major,
-                                                                  is_valid,
-                                                                  have_all_seen,
-                                                                  range_seen || is_range_slice,
-                                                                  xtl::mpl::pop_front_t<V>>::value;
+            static constexpr bool value = is_contiguous_view_impl < layout_type::row_major, is_valid,
+                                  have_all_seen, range_seen || is_range_slice,
+                                  xtl::mpl::pop_front_t < V >> ::value;
         };
 
         template <bool valid, bool all_seen, bool range_seen>
@@ -208,17 +202,18 @@ namespace xt
         {
             using slice = xtl::mpl::front_t<V>;
             static constexpr bool is_range_slice = is_xrange<slice>::value;
-            static constexpr bool is_int_slice = std::is_integral<slice>::value;
+            static constexpr bool is_int_slice = xtl::is_integral<slice>::value;
             static constexpr bool is_all_slice = is_xall_slice<slice>::value;
 
             static constexpr bool have_int_seen = int_seen || is_int_slice;
 
-            static constexpr bool is_valid = valid && (have_int_seen ? is_int_slice : (!range_seen && (is_all_slice || is_range_slice)));
-            static constexpr bool value = is_contiguous_view_impl<layout_type::column_major,
-                                                                  is_valid,
-                                                                  have_int_seen,
-                                                                  is_range_slice || range_seen,
-                                                                  xtl::mpl::pop_front_t<V>>::value;
+            static constexpr bool is_valid = valid
+                                             && (have_int_seen
+                                                     ? is_int_slice
+                                                     : (!range_seen && (is_all_slice || is_range_slice)));
+            static constexpr bool value = is_contiguous_view_impl < layout_type::column_major, is_valid,
+                                  have_int_seen, is_range_slice || range_seen,
+                                  xtl::mpl::pop_front_t < V >> ::value;
         };
 
         template <bool valid, bool int_seen, bool range_seen>
@@ -230,11 +225,14 @@ namespace xt
         // TODO relax has_data_interface constraint here!
         template <class E, class... S>
         struct is_contiguous_view
-            : std::integral_constant<bool,
-                has_data_interface<E>::value &&
-                !(E::static_layout == layout_type::column_major && static_dimension<typename E::shape_type>::value != sizeof...(S)) &&
-                is_contiguous_view_impl<E::static_layout, true, false, false, xtl::mpl::vector<S...>>::value
-              >
+            : std::integral_constant<
+                  bool,
+                  data_interface_expression<E>
+                      && !(
+                          E::static_layout == layout_type::column_major
+                          && static_cast<std::size_t>(static_dimension<typename E::shape_type>::value) != sizeof...(S)
+                      )
+                      && is_contiguous_view_impl<E::static_layout, true, false, false, xtl::mpl::vector<S...>>::value>
         {
         };
 
@@ -272,25 +270,51 @@ namespace xt
         struct get_contigous_shape_type
         {
             // if we have no `range` in the slices we can re-use the shape with an offset
-            using type = std::conditional_t<xtl::disjunction<is_xrange<S>...>::value, 
-                                            typename xview_shape_type<typename E::shape_type, S...>::type,
-                                            // In the false branch we know that we have only integers at the front OR end, and NO range
-                                            typename unwrap_offset_container<E::static_layout, typename E::inner_shape_type, integral_count<S...>()>::type>;
+            using type = std::conditional_t<
+                std::disjunction<is_xrange<S>...>::value,
+                typename xview_shape_type<typename E::shape_type, S...>::type,
+                // In the false branch we know that we have only integers at the front OR end, and NO range
+                typename unwrap_offset_container<E::static_layout, typename E::inner_shape_type, integral_count<S...>()>::type>;
         };
 
         template <class T>
-        struct is_sequence_view
-            : std::integral_constant<bool, false>
+        struct is_sequence_view : std::integral_constant<bool, false>
         {
         };
 
         template <class T, std::ptrdiff_t S, std::ptrdiff_t E>
-        struct is_sequence_view<sequence_view<T, S, E>>
-            : std::integral_constant<bool, true>
+        struct is_sequence_view<sequence_view<T, S, E>> : std::integral_constant<bool, true>
         {
         };
     }
 
+    template <class E, class... S>
+    concept contiguous_view_concept = detail::is_contiguous_view<E, S...>::value;
+    template <class E, class... S>
+    concept strided_view_concept = detail::is_strided_view<std::decay_t<E>, S...>::value;
+
+    template <class CT, class... S>
+    struct xcontainer_inner_types<xview<CT, S...>>
+    {
+        using xexpression_type = std::decay_t<CT>;
+        using reference = inner_reference_t<CT>;
+        using const_reference = typename xexpression_type::const_reference;
+        using size_type = typename xexpression_type::size_type;
+        using temporary_type = view_temporary_type_t<xexpression_type, S...>;
+
+        static constexpr layout_type layout = detail::is_contiguous_view<xexpression_type, S...>::value
+                                                  ? xexpression_type::static_layout
+                                                  : layout_type::dynamic;
+
+        static constexpr bool is_const = std::is_const<std::remove_reference_t<CT>>::value;
+
+        using extract_storage_type = typename std::conditional_t<
+            data_interface_expression<xexpression_type>,
+            detail::expr_storage_type<xexpression_type>,
+            make_invalid_type<>>::type;
+        using storage_type = std::conditional_t<is_const, const extract_storage_type, extract_storage_type>;
+    };
+
     template <class CT, class... S>
     struct xiterable_inner_types<xview<CT, S...>>
     {
@@ -299,18 +323,20 @@ namespace xt
         static constexpr bool is_strided_view = detail::is_strided_view<xexpression_type, S...>::value;
         static constexpr bool is_contiguous_view = detail::is_contiguous_view<xexpression_type, S...>::value;
 
+        using inner_shape_type = std::conditional_t<
+            is_contiguous_view,
+            typename detail::get_contigous_shape_type<xexpression_type, S...>::type,
+            typename xview_shape_type<typename xexpression_type::shape_type, S...>::type>;
 
-        using inner_shape_type = std::conditional_t<is_contiguous_view,
-                                                    typename detail::get_contigous_shape_type<xexpression_type, S...>::type,
-                                                    typename xview_shape_type<typename xexpression_type::shape_type, S...>::type>;
-
-        using stepper = std::conditional_t<is_strided_view,
-                                           xstepper<xview<CT, S...>>,
-                                           xview_stepper<std::is_const<std::remove_reference_t<CT>>::value, CT, S...>>;
+        using stepper = std::conditional_t<
+            is_strided_view,
+            xstepper<xview<CT, S...>>,
+            xview_stepper<std::is_const<std::remove_reference_t<CT>>::value, CT, S...>>;
 
-        using const_stepper = std::conditional_t<is_strided_view,
-                                                 xstepper<const xview<CT, S...>>,
-                                                 xview_stepper<true, std::remove_cv_t<CT>, S...>>;
+        using const_stepper = std::conditional_t<
+            is_strided_view,
+            xstepper<const xview<CT, S...>>,
+            xview_stepper<true, std::remove_cv_t<CT>, S...>>;
     };
 
     /**
@@ -329,36 +355,38 @@ namespace xt
      */
     template <class CT, class... S>
     class xview : public xview_semantic<xview<CT, S...>>,
-                  public xiterable<xview<CT, S...>>,
+                  public std::conditional_t<
+                      detail::is_contiguous_view<std::decay_t<CT>, S...>::value,
+                      xcontiguous_iterable<xview<CT, S...>>,
+                      xiterable<xview<CT, S...>>>,
+                  public xaccessible<xview<CT, S...>>,
                   public extension::xview_base_t<CT, S...>
     {
     public:
 
         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;
 
         static constexpr bool is_const = std::is_const<std::remove_reference_t<CT>>::value;
         using value_type = typename xexpression_type::value_type;
-        using simd_value_type = xsimd::simd_type<value_type>;
-        using reference = std::conditional_t<is_const,
-                                             typename xexpression_type::const_reference,
-                                             typename xexpression_type::reference>;
-        using const_reference = typename xexpression_type::const_reference;
-        using pointer = std::conditional_t<is_const,
-                                           typename xexpression_type::const_pointer,
-                                           typename xexpression_type::pointer>;
+        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 = std::
+            conditional_t<is_const, typename xexpression_type::const_pointer, typename xexpression_type::pointer>;
         using const_pointer = typename xexpression_type::const_pointer;
-        using size_type = typename xexpression_type::size_type;
+        using size_type = typename inner_types::size_type;
         using difference_type = typename xexpression_type::difference_type;
 
-        static constexpr layout_type static_layout = detail::is_contiguous_view<xexpression_type, S...>::value ?
-                                                                                xexpression_type::static_layout :
-                                                                                layout_type::dynamic;
+        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;
@@ -368,21 +396,38 @@ namespace xt
         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 = xtl::mpl::eval_if_t<has_strides<xexpression_type>,
-                                                                   detail::expr_inner_strides_type<xexpression_type>,
-                                                                   get_strides_type<shape_type>>;
-
-        using storage_type = xtl::mpl::eval_if_t<has_data_interface<xexpression_type>,
-                                                 detail::expr_storage_type<xexpression_type>,
-                                                 make_invalid_type<>>;
-
-        using inner_strides_type = std::conditional_t<is_contiguous_view,
-                                                      typename detail::unwrap_offset_container<xexpression_type::static_layout, xexpression_inner_strides_type, integral_count<S...>()>::type,
-                                                      get_strides_t<shape_type>>;
+        using xexpression_inner_strides_type = typename std::conditional_t<
+            strided_expression<xexpression_type>,
+            detail::expr_inner_strides_type<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+
+        using xexpression_inner_backstrides_type = typename std::conditional_t<
+            strided_expression<xexpression_type>,
+            detail::expr_inner_backstrides_type<xexpression_type>,
+            get_strides_type<shape_type>>::type;
+
+        using storage_type = typename inner_types::storage_type;
+
+        static constexpr bool has_trivial_strides = is_contiguous_view
+                                                    && !std::disjunction<detail::is_xrange<S>...>::value;
+        using inner_strides_type = 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>>;
+
+        using inner_backstrides_type = 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>>;
 
-        using inner_backstrides_type = inner_strides_type;
         using strides_type = get_strides_t<shape_type>;
-        using back_strides_type = strides_type;
+        using backstrides_type = strides_type;
 
 
         using slice_type = std::tuple<S...>;
@@ -390,15 +435,21 @@ namespace xt
         using stepper = typename iterable_base::stepper;
         using const_stepper = typename iterable_base::const_stepper;
 
-        using storage_iterator = std::conditional_t<has_data_interface<xexpression_type>::value,
-                                                    typename xexpression_type::storage_iterator,
-                                                    typename iterable_base::storage_iterator>;
-        using const_storage_iterator = std::conditional_t<has_data_interface<xexpression_type>::value,
-                                                    typename xexpression_type::const_storage_iterator,
-                                                    typename iterable_base::const_storage_iterator>;
+        using linear_iterator = std::conditional_t<
+            data_interface_expression<xexpression_type> && is_strided_view,
+            std::conditional_t<is_const, typename xexpression_type::const_linear_iterator, typename xexpression_type::linear_iterator>,
+            typename iterable_base::linear_iterator>;
+        using const_linear_iterator = std::conditional_t<
+            data_interface_expression<xexpression_type> && is_strided_view,
+            typename xexpression_type::const_linear_iterator,
+            typename iterable_base::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;
+        static constexpr std::size_t rank = SIZE_MAX;
 
         // The FSL argument prevents the compiler from calling this constructor
         // instead of the copy constructor when sizeof...(SL) == 0.
@@ -414,12 +465,11 @@ namespace xt
         template <class E>
         disable_xexpression<E, self_type>& operator=(const E& e);
 
-        size_type dimension() const noexcept;
-
-        size_type size() const noexcept;
         const inner_shape_type& shape() const noexcept;
         const slice_type& slices() const noexcept;
         layout_type layout() const noexcept;
+        bool is_contiguous() const noexcept;
+        using accessible_base::shape;
 
         template <class T>
         void fill(const T& value);
@@ -427,28 +477,14 @@ namespace xt
         template <class... Args>
         reference operator()(Args... args);
         template <class... Args>
-        reference at(Args... args);
-        template <class... Args>
         reference unchecked(Args... args);
-        template <class OS>
-        disable_integral_t<OS, reference> operator[](const OS& index);
-        template <class I>
-        reference operator[](std::initializer_list<I> index);
-        reference operator[](size_type i);
         template <class It>
         reference element(It first, It last);
 
         template <class... Args>
         const_reference operator()(Args... args) const;
         template <class... Args>
-        const_reference at(Args... args) const;
-        template <class... Args>
         const_reference unchecked(Args... args) const;
-        template <class OS>
-        disable_integral_t<OS, const_reference> operator[](const OS& index) const;
-        template <class I>
-        const_reference operator[](std::initializer_list<I> index) const;
-        const_reference operator[](size_type i) const;
         template <class It>
         const_reference element(It first, It last) const;
 
@@ -461,97 +497,111 @@ namespace xt
         template <class ST>
         bool has_linear_assign(const ST& strides) const;
 
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<!Enable, stepper>
-        stepper_begin(const ST& shape);
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<!Enable, stepper>
-        stepper_end(const ST& shape, layout_type l);
-
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<!Enable, const_stepper>
-        stepper_begin(const ST& shape) const;
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<!Enable, const_stepper>
-        stepper_end(const ST& shape, layout_type l) const;
-
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<Enable, stepper>
-        stepper_begin(const ST& shape);
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<Enable, stepper>
-        stepper_end(const ST& shape, layout_type l);
-
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<Enable, const_stepper>
-        stepper_begin(const ST& shape) const;
-        template <class ST, bool Enable = is_strided_view>
-        std::enable_if_t<Enable, const_stepper>
-        stepper_end(const ST& shape, layout_type l) 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>
+        storage_type& storage()
+            requires(data_interface_expression<T>);
+
+        template <class T = xexpression_type>
+        const storage_type& storage() const
+            requires(data_interface_expression<T>);
+
+        template <class T = xexpression_type>
+        linear_iterator linear_begin()
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
+
+        template <class T = xexpression_type>
+        linear_iterator linear_end()
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
+
+        template <class T = xexpression_type>
+        const_linear_iterator linear_begin() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value, typename T::storage_type&>
-        storage();
+        const_linear_iterator linear_end() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value, const typename T::storage_type&>
-        storage() const;
+        const_linear_iterator linear_cbegin() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, storage_iterator>
-        storage_begin();
+        const_linear_iterator linear_cend() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, storage_iterator>
-        storage_end();
+        reverse_linear_iterator linear_rbegin()
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const_storage_iterator>
-        storage_cbegin() const;
+        reverse_linear_iterator linear_rend()
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const_storage_iterator>
-        storage_cend() const;
+        const_reverse_linear_iterator linear_rbegin() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const inner_strides_type&>
-        strides() const;
+        const_reverse_linear_iterator linear_rend() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const inner_strides_type&>
-        backstrides() const;
+        const_reverse_linear_iterator linear_crbegin() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const_pointer>
-        data() const;
+        const_reverse_linear_iterator linear_crend() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, pointer>
-        data();
+        const inner_strides_type& strides() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, std::size_t>
-        data_offset() const noexcept;
+        const inner_strides_type& backstrides() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
+
+        template <class T = xexpression_type>
+        const_pointer data() const
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
+
+        template <class T = xexpression_type>
+        pointer data()
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
+
+        template <class T = xexpression_type>
+        std::size_t data_offset() const noexcept
+            requires(data_interface_expression<T> and strided_view_concept<CT, S...>);
 
         template <class It>
         inline It data_xbegin_impl(It begin) const noexcept;
 
         template <class It>
-        inline It data_xend_impl(It begin, layout_type l) const noexcept;
+        inline It data_xend_impl(It begin, layout_type l, size_type offset) const noexcept;
         inline container_iterator data_xbegin() noexcept;
         inline const_container_iterator data_xbegin() const noexcept;
-        inline container_iterator data_xend(layout_type l) noexcept;
+        inline container_iterator data_xend(layout_type l, size_type offset) noexcept;
 
-        inline const_container_iterator data_xend(layout_type l) const noexcept;
+        inline const_container_iterator data_xend(layout_type l, size_type offset) const noexcept;
 
         // Conversion operator enabled for statically "scalar" views
-        template <class ST = self_type, class = std::enable_if_t<is_xscalar<std::decay_t<ST>>::value, int>>
+        template <xscalar_concept ST = self_type>
         operator reference()
         {
             return (*this)();
         }
 
-        template <class ST = self_type, class = std::enable_if_t<is_xscalar<std::decay_t<ST>>::value, int>>
+        template <xscalar_concept ST = self_type>
         operator const_reference() const
         {
             return (*this)();
@@ -560,12 +610,12 @@ namespace xt
         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<const self_type&> operator&() const&;
         xtl::xclosure_pointer<self_type> operator&() &&;
 
-        template <class E, class T = xexpression_type,
-                  class = std::enable_if_t<has_data_interface<T>::value && is_contiguous_view, int>>
-        void assign_to(xexpression<E>& e, bool force_resize) const;
+        template <class E, class T = xexpression_type>
+        void assign_to(xexpression<E>& e, bool force_resize) const
+            requires(data_interface_expression<T> and contiguous_view_concept<E, S...>);
 
         template <class E>
         using rebind_t = xview<E, S...>;
@@ -578,24 +628,35 @@ namespace xt
         //
 
         template <class requested_type>
-        using simd_return_type = xsimd::simd_return_type<value_type, requested_type>;
-
-        template <class T, class R>
-        using enable_simd_interface = std::enable_if_t<has_simd_interface<T>::value && is_strided_view, R>;
+        using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
 
         template <class align, class simd, class T = xexpression_type>
-        enable_simd_interface<T, void> store_simd(size_type i, const simd& e);
+        void store_simd(size_type i, const simd& e)
+            requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>);
+
+        template <
+            class align,
+            class requested_type = value_type,
+            std::size_t N = xt_simd::simd_traits<requested_type>::size,
+            class T = xexpression_type>
+        simd_return_type<requested_type> load_simd(size_type i) const
+            requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>);
 
-        template <class align, class requested_type = value_type,
-                  std::size_t N = xsimd::simd_traits<requested_type>::size,
-                  class T = xexpression_type>
-        enable_simd_interface<T, simd_return_type<requested_type>> load_simd(size_type i) const;
+        template <class T = xexpression_type>
+        reference data_element(size_type i)
+            requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>);
+
+        template <class T = xexpression_type>
+        const_reference data_element(size_type i) const
+            requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        enable_simd_interface<T, reference> data_element(size_type i);
+        reference flat(size_type i)
+            requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>);
 
         template <class T = xexpression_type>
-        enable_simd_interface<T, const_reference> data_element(size_type i) const;
+        const_reference flat(size_type i) const
+            requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>);
 
     private:
 
@@ -649,10 +710,7 @@ namespace xt
         const_reference access_impl(std::index_sequence<I...>, Args... args) const;
 
         template <typename std::decay_t<CT>::size_type I, class... Args>
-        std::enable_if_t<lesser_condition<I>::value, size_type> index(Args... args) const;
-
-        template <typename std::decay_t<CT>::size_type I, class... Args>
-        std::enable_if_t<!lesser_condition<I>::value, size_type> index(Args... args) const;
+        size_type index(Args... args) const;
 
         template <typename std::decay_t<CT>::size_type, class T>
         size_type sliced_access(const xslice<T>& slice) const;
@@ -661,7 +719,8 @@ namespace xt
         size_type sliced_access(const xslice<T>& slice, Arg arg, Args... args) const;
 
         template <typename std::decay_t<CT>::size_type I, class T, class... Args>
-        disable_xslice<T, size_type> sliced_access(const T& squeeze, Args...) const;
+        size_type sliced_access(const T& squeeze, Args...) const
+            requires(!is_xslice<T>::value);
 
         using base_index_type = xindex_type_t<typename xexpression_type::shape_type>;
 
@@ -688,6 +747,12 @@ namespace xt
     template <class E, class... S>
     auto view(E&& e, S&&... slices);
 
+    template <class E>
+    auto row(E&& e, std::ptrdiff_t index);
+
+    template <class E>
+    auto col(E&& e, std::ptrdiff_t index);
+
     /*****************************
      * xview_stepper declaration *
      *****************************/
@@ -717,9 +782,7 @@ namespace xt
     {
     public:
 
-        using view_type = std::conditional_t<is_const,
-                                             const xview<CT, S...>,
-                                             xview<CT, S...>>;
+        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;
@@ -731,8 +794,13 @@ namespace xt
         using shape_type = typename substepper_type::shape_type;
 
         xview_stepper() = default;
-        xview_stepper(view_type* view, substepper_type it,
-                      size_type offset, bool end = false, layout_type l = XTENSOR_DEFAULT_LAYOUT);
+        xview_stepper(
+            view_type* view,
+            substepper_type it,
+            size_type offset,
+            bool end = false,
+            layout_type l = XTENSOR_DEFAULT_TRAVERSAL
+        );
 
         reference operator*() const;
 
@@ -786,7 +854,7 @@ namespace xt
     template <std::size_t... I, class... S>
     struct xview_shape_type<fixed_shape<I...>, S...>
     {
-        using type = typename xview_shape_type<std::array<std::size_t, sizeof...(I)>>::type;
+        using type = typename xview_shape_type<std::array<std::size_t, sizeof...(I)>, S...>::type;
     };
 
     /************************
@@ -811,37 +879,38 @@ namespace xt
     template <class CTA, class FSL, class... SL>
     xview<CT, S...>::xview(CTA&& e, FSL&& first_slice, SL&&... slices) noexcept
         : xview(
-            std::integral_constant<bool, is_contiguous_view>{},
+            std::integral_constant<bool, has_trivial_strides>{},
             std::forward<CTA>(e),
             std::forward<FSL>(first_slice),
             std::forward<SL>(slices)...
-          )
+        )
     {
     }
 
-    // contigous initializer
+    // trivial strides initializer
     template <class CT, class... S>
     template <class CTA, class FSL, class... SL>
     xview<CT, S...>::xview(std::true_type, CTA&& e, FSL&& first_slice, SL&&... slices) noexcept
-        : m_e(std::forward<CTA>(e)),
-          m_slices(std::forward<FSL>(first_slice), std::forward<SL>(slices)...),
-          m_shape(compute_shape(detail::is_sequence_view<inner_shape_type>{})),
-          m_strides(m_e.strides()),
-          m_backstrides(m_e.backstrides()),
-          m_data_offset(data_offset_impl(std::make_index_sequence<sizeof...(S)>())),
-          m_strides_computed(true)
+        : m_e(std::forward<CTA>(e))
+        , m_slices(std::forward<FSL>(first_slice), std::forward<SL>(slices)...)
+        , m_shape(compute_shape(detail::is_sequence_view<inner_shape_type>{}))
+        , m_strides(m_e.strides())
+        , m_backstrides(m_e.backstrides())
+        , m_data_offset(data_offset_impl(std::make_index_sequence<sizeof...(S)>()))
+        , m_strides_computed(true)
     {
     }
 
     template <class CT, class... S>
     template <class CTA, class FSL, class... SL>
     xview<CT, S...>::xview(std::false_type, CTA&& e, FSL&& first_slice, SL&&... slices) noexcept
-        : m_e(std::forward<CTA>(e)),
-          m_slices(std::forward<FSL>(first_slice), std::forward<SL>(slices)...),
-          m_shape(compute_shape(std::false_type{})),
-          m_strides_computed(false)
+        : m_e(std::forward<CTA>(e))
+        , m_slices(std::forward<FSL>(first_slice), std::forward<SL>(slices)...)
+        , m_shape(compute_shape(std::false_type{}))
+        , m_strides_computed(false)
     {
     }
+
     //@}
 
     template <class CT, class... S>
@@ -864,6 +933,7 @@ namespace xt
     {
         return semantic_base::operator=(e);
     }
+
     //@}
 
     template <class CT, class... S>
@@ -878,24 +948,6 @@ namespace xt
      * @name Size and shape
      */
     //@{
-    /**
-     * Returns the size of the expression.
-     */
-    template <class CT, class... S>
-    inline auto xview<CT, S...>::size() const noexcept -> size_type
-    {
-        return compute_size(shape());
-    }
-
-    /**
-     * Returns the number of dimensions of the view.
-     */
-    template <class CT, class... S>
-    inline auto xview<CT, S...>::dimension() const noexcept -> size_type
-    {
-        return m_shape.size();
-    }
-
     /**
      * Returns the shape of the view.
      */
@@ -920,7 +972,7 @@ namespace xt
     template <class CT, class... S>
     inline layout_type xview<CT, S...>::layout() const noexcept
     {
-        return xtl::mpl::static_if<is_strided_view>([&](auto self)
+        if constexpr (is_strided_view)
         {
             if (static_layout != layout_type::dynamic)
             {
@@ -928,15 +980,22 @@ namespace xt
             }
             else
             {
-                bool strides_match = do_strides_match(self(this)->shape(), self(this)->strides(), self(this)->m_e.layout());
-                return strides_match ? self(this)->m_e.layout() : layout_type::dynamic;
+                bool strides_match = do_strides_match(shape(), strides(), m_e.layout(), true);
+                return strides_match ? m_e.layout() : layout_type::dynamic;
             }
-        },
-        /* else */ [&](auto /*self*/)
+        }
+        else
         {
             return layout_type::dynamic;
-        });
+        }
+    }
+
+    template <class CT, class... S>
+    inline bool xview<CT, S...>::is_contiguous() const noexcept
+    {
+        return layout() != layout_type::dynamic;
     }
+
     //@}
 
     /**
@@ -952,13 +1011,14 @@ namespace xt
     template <class T>
     inline void xview<CT, S...>::fill(const T& value)
     {
-        xtl::mpl::static_if<static_layout != layout_type::dynamic>([&](auto self)
+        if constexpr (static_layout != layout_type::dynamic)
         {
-            std::fill(self(this)->storage_begin(), self(this)->storage_end(), value);
-        }, /*else*/ [&](auto self)
+            std::fill(linear_begin(), linear_end(), value);
+        }
+        else
         {
-            std::fill(self(this)->begin(), self(this)->end(), value);
-        });
+            std::fill(this->begin(), this->end(), value);
+        }
     }
 
     /**
@@ -978,23 +1038,6 @@ namespace xt
         return access(static_cast<size_type>(args)...);
     }
 
-    /**
-     * Returns a reference to the element at the specified position in the expression,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class CT, class... S>
-    template <class... Args>
-    inline auto xview<CT, S...>::at(Args... args) -> reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
     /**
      * Returns a reference to the element at the specified position in the view.
      * @param args a list of indices specifying the position in the view. Indices
@@ -1003,16 +1046,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.unchecked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class CT, class... S>
     template <class... Args>
@@ -1021,34 +1064,6 @@ namespace xt
         return unchecked_impl(make_index_sequence(args...), static_cast<size_type>(args)...);
     }
 
-    /**
-     * Returns a reference to the element at the specified position in the view.
-     * @param index a sequence of indices specifying the position in the view. Indices
-     * must be unsigned integers, the number of indices in the list should be equal or greater
-     * than the number of dimensions of the view.
-     */
-    template <class CT, class... S>
-    template <class OS>
-    inline auto xview<CT, S...>::operator[](const OS& index)
-        -> disable_integral_t<OS, reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class CT, class... S>
-    template <class I>
-    inline auto xview<CT, S...>::operator[](std::initializer_list<I> index)
-        -> reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class CT, class... S>
-    inline auto xview<CT, S...>::operator[](size_type i) -> reference
-    {
-        return operator()(i);
-    }
-
     template <class CT, class... S>
     template <class It>
     inline auto xview<CT, S...>::element(It first, It last) -> reference
@@ -1076,23 +1091,6 @@ namespace xt
         return access(static_cast<size_type>(args)...);
     }
 
-    /**
-     * Returns a constant reference to the element at the specified position in the view,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class CT, class... S>
-    template <class... Args>
-    inline auto xview<CT, S...>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
     /**
      * Returns a constant reference to the element at the specified position in the view.
      * @param args a list of indices specifying the position in the view. Indices
@@ -1101,16 +1099,16 @@ namespace xt
      *
      * @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 prefered whenever
+     * undefined behavior (see parameters), operator() should be preferred whenever
      * it is possible.
      * @warning This method is NOT compatible with broadcasting, meaning the following
      * code has undefined behavior:
-     * \code{.cpp}
+     * @code{.cpp}
      * xt::xarray<double> a = {{0, 1}, {2, 3}};
      * xt::xarray<double> b = {0, 1};
      * auto fd = a + b;
      * double res = fd.unchecked(0, 1);
-     * \endcode
+     * @endcode
      */
     template <class CT, class... S>
     template <class... Args>
@@ -1119,34 +1117,6 @@ namespace xt
         return unchecked_impl(make_index_sequence(args...), static_cast<size_type>(args)...);
     }
 
-    /**
-     * Returns a constant reference to the element at the specified position in the view.
-     * @param index a sequence of indices specifying the position in the view. Indices
-     * must be unsigned integers, the number of indices in the list should be equal or greater
-     * than the number of dimensions of the view.
-     */
-    template <class CT, class... S>
-    template <class OS>
-    inline auto xview<CT, S...>::operator[](const OS& index) const
-        -> disable_integral_t<OS, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class CT, class... S>
-    template <class I>
-    inline auto xview<CT, S...>::operator[](std::initializer_list<I> index) const
-        -> const_reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class CT, class... S>
-    inline auto xview<CT, S...>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
-    }
-
     template <class CT, class... S>
     template <class It>
     inline auto xview<CT, S...>::element(It first, It last) const -> const_reference
@@ -1181,50 +1151,114 @@ namespace xt
      */
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::storage() ->
-        std::enable_if_t<has_data_interface<T>::value, typename T::storage_type&>
+    inline auto xview<CT, S...>::storage() -> storage_type&
+        requires(data_interface_expression<T>)
     {
         return m_e.storage();
     }
 
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::storage() const ->
-        std::enable_if_t<has_data_interface<T>::value, const typename T::storage_type&>
+    inline auto xview<CT, S...>::storage() const -> const storage_type&
+        requires(data_interface_expression<T>)
     {
         return m_e.storage();
     }
 
     template <class CT, class... S>
     template <class T>
-    auto xview<CT, S...>::storage_begin()
-        -> std::enable_if_t<has_data_interface<T>::value && is_strided_view, storage_iterator>
+    auto xview<CT, S...>::linear_begin() -> linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
     {
-        return m_e.storage_begin() + data_offset();
+        return m_e.storage().begin() + data_offset();
     }
 
     template <class CT, class... S>
     template <class T>
-    auto xview<CT, S...>::storage_end()
-        -> std::enable_if_t<has_data_interface<T>::value && is_strided_view, storage_iterator>
+    auto xview<CT, S...>::linear_end() -> linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
     {
-        return m_e.storage_begin() + data_offset() + size();
+        return m_e.storage().begin() + data_offset() + this->size();
     }
 
     template <class CT, class... S>
     template <class T>
-    auto xview<CT, S...>::storage_cbegin() const
-        -> std::enable_if_t<has_data_interface<T>::value && is_strided_view, const_storage_iterator>
+    auto xview<CT, S...>::linear_begin() const -> const_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
     {
-        return m_e.storage_cbegin() + data_offset();
+        return linear_cbegin();
     }
 
     template <class CT, class... S>
     template <class T>
-    auto xview<CT, S...>::storage_cend() const
-        -> std::enable_if_t<has_data_interface<T>::value && is_strided_view, const_storage_iterator>
+    auto xview<CT, S...>::linear_end() const -> const_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
     {
-        return m_e.storage_cbegin() + data_offset() + size();
+        return linear_cend();
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_cbegin() const -> const_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return m_e.storage().cbegin() + data_offset();
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_cend() const -> const_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return m_e.storage().cbegin() + data_offset() + this->size();
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_rbegin() -> reverse_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return reverse_linear_iterator(linear_end());
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_rend() -> reverse_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return reverse_linear_iterator(linear_begin());
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_rbegin() const -> const_reverse_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return linear_crbegin();
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_rend() const -> const_reverse_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return linear_crend();
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_crbegin() const -> const_reverse_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return const_reverse_linear_iterator(linear_end());
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    auto xview<CT, S...>::linear_crend() const -> const_reverse_linear_iterator
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
+    {
+        return const_reverse_linear_iterator(linear_begin());
     }
 
     /**
@@ -1232,45 +1266,43 @@ namespace xt
      */
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::strides() const ->
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const inner_strides_type&>
-    {
-        if (!m_strides_computed)
-        {
-            compute_strides(std::integral_constant<bool, is_contiguous_view>{});
-            m_strides_computed = true;
+    inline auto xview<CT, S...>::strides() const
+        -> const inner_strides_type& requires(data_interface_expression<T>and strided_view_concept<CT, S...>) {
+            if (!m_strides_computed)
+            {
+                compute_strides(std::integral_constant<bool, has_trivial_strides>{});
+                m_strides_computed = true;
+            }
+            return m_strides;
         }
-        return m_strides;
-    }
 
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::backstrides() const ->
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const inner_strides_type&>
-    {
-        if (!m_strides_computed)
-        {
-            compute_strides(std::integral_constant<bool, is_contiguous_view>{});
-            m_strides_computed = true;
+    inline auto xview<CT, S...>::backstrides() const
+        -> const inner_strides_type& requires(data_interface_expression<T>and strided_view_concept<CT, S...>) {
+            if (!m_strides_computed)
+            {
+                compute_strides(std::integral_constant<bool, has_trivial_strides>{});
+                m_strides_computed = true;
+            }
+            return m_backstrides;
         }
-        return m_backstrides;
-    }
 
     /**
      * Return the pointer to the underlying buffer.
      */
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::data() const ->
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, const_pointer>
+    inline auto xview<CT, S...>::data() const -> const_pointer
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
     {
         return m_e.data();
     }
 
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::data() ->
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, pointer>
+    inline auto xview<CT, S...>::data() -> pointer
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
     {
         return m_e.data();
     }
@@ -1279,12 +1311,17 @@ namespace xt
     template <std::size_t... I>
     inline std::size_t xview<CT, S...>::data_offset_impl(std::index_sequence<I...>) const noexcept
     {
-        auto temp = std::array<std::ptrdiff_t, sizeof...(S)>({
-            (static_cast<ptrdiff_t>(xt::value(std::get<I>(m_slices), 0)) * m_e.strides()[I - newaxis_count_before<S...>(I)])...
-        });
+        auto temp = std::array<std::ptrdiff_t, sizeof...(S)>(
+            {(static_cast<ptrdiff_t>(xt::value(std::get<I>(m_slices), 0)))...}
+        );
 
         std::ptrdiff_t result = 0;
-        for (std::size_t i = 0; i < sizeof...(S); ++i)
+        std::size_t i = 0;
+        for (; i < std::min(sizeof...(S), m_e.strides().size()); ++i)
+        {
+            result += temp[i] * m_e.strides()[i - newaxis_count_before<S...>(i)];
+        }
+        for (; i < sizeof...(S); ++i)
         {
             result += temp[i];
         }
@@ -1296,15 +1333,17 @@ namespace xt
      */
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::data_offset() const noexcept ->
-        std::enable_if_t<has_data_interface<T>::value && is_strided_view, std::size_t>
+    inline std::size_t xview<CT, S...>::data_offset() const noexcept
+        requires(data_interface_expression<T> and strided_view_concept<CT, S...>)
     {
         if (!m_strides_computed)
         {
-            compute_strides(std::integral_constant<bool, is_contiguous_view>{});
+            compute_strides(std::integral_constant<bool, has_trivial_strides>{});
+            m_strides_computed = true;
         }
         return m_data_offset;
     }
+
     //@}
 
     template <class CT, class... S>
@@ -1320,7 +1359,7 @@ namespace xt
     }
 
     template <class CT, class... S>
-    inline auto xview<CT, S...>::operator&() const & -> xtl::xclosure_pointer<const self_type&>
+    inline auto xview<CT, S...>::operator&() const& -> xtl::xclosure_pointer<const self_type&>
     {
         return xtl::closure_pointer(*this);
     }
@@ -1357,15 +1396,16 @@ namespace xt
     template <class ST>
     inline bool xview<CT, S...>::has_linear_assign(const ST& str) const
     {
-        return xtl::mpl::static_if<is_strided_view>([&](auto self)
+        if constexpr (is_strided_view)
+        {
+            return str.size() == strides().size() && std::equal(str.cbegin(), str.cend(), strides().begin());
+        }
+        else
         {
-            return str.size() == self(this)->strides().size() &&
-                std::equal(str.cbegin(), str.cend(), self(this)->strides().begin());
-
-        }, /*else*/ [](auto /*self*/){
             return false;
-        });
+        }
     }
+
     //@}
 
     template <class CT, class... S>
@@ -1377,10 +1417,9 @@ namespace xt
 
     template <class CT, class... S>
     template <class It>
-    inline It xview<CT, S...>::data_xend_impl(It begin, layout_type l) const noexcept
+    inline It xview<CT, S...>::data_xend_impl(It begin, layout_type l, size_type offset) const noexcept
     {
-        std::ptrdiff_t end_offset = static_cast<std::ptrdiff_t>(std::accumulate(backstrides().begin(), backstrides().end(), std::size_t(0)));
-        return strided_data_end(*this, begin + end_offset + 1, l);
+        return strided_data_end(*this, begin, l, offset);
     }
 
     template <class CT, class... S>
@@ -1396,21 +1435,23 @@ namespace xt
     }
 
     template <class CT, class... S>
-    inline auto xview<CT, S...>::data_xend(layout_type l) noexcept -> container_iterator
+    inline auto xview<CT, S...>::data_xend(layout_type l, size_type offset) noexcept -> container_iterator
     {
-        return data_xend_impl(data() + data_offset(), l);
+        return data_xend_impl(data() + data_offset(), l, offset);
     }
 
     template <class CT, class... S>
-    inline auto xview<CT, S...>::data_xend(layout_type l) const noexcept -> const_container_iterator
+    inline auto xview<CT, S...>::data_xend(layout_type l, size_type offset) const noexcept
+        -> const_container_iterator
     {
-        return data_xend_impl(data() + data_offset(), l);
+        return data_xend_impl(data() + data_offset(), l, offset);
     }
 
     // Assign to operator enabled for contigous views
     template <class CT, class... S>
-    template <class E, class T, class>
+    template <class E, class T>
     void xview<CT, S...>::assign_to(xexpression<E>& e, bool force_resize) const
+        requires(data_interface_expression<T> and contiguous_view_concept<E, S...>)
     {
         auto& de = e.derived_cast();
         de.resize(shape(), force_resize);
@@ -1433,55 +1474,82 @@ namespace xt
 
     template <class CT, class... S>
     template <class align, class simd, class T>
-    inline auto xview<CT, S...>::store_simd(size_type i, const simd& e) -> enable_simd_interface<T, void>
+    inline auto xview<CT, S...>::store_simd(size_type i, const simd& e) -> void
+        requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
     {
-        return m_e.template store_simd<xsimd::unaligned_mode>(data_offset() + i, e);
+        return m_e.template store_simd<xt_simd::unaligned_mode>(data_offset() + i, e);
     }
 
     template <class CT, class... S>
     template <class align, class requested_type, std::size_t N, class T>
-    inline auto xview<CT, S...>::load_simd(size_type i) const -> enable_simd_interface<T, simd_return_type<requested_type>>
+    inline auto 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...>)
     {
-        return m_e.template load_simd<xsimd::unaligned_mode, requested_type>(data_offset() + i);
+        return m_e.template load_simd<xt_simd::unaligned_mode, requested_type>(data_offset() + i);
     }
 
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::data_element(size_type i) -> enable_simd_interface<T, reference>
+    inline auto xview<CT, S...>::data_element(size_type i) -> reference
+        requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
     {
         return m_e.data_element(data_offset() + i);
     }
 
     template <class CT, class... S>
     template <class T>
-    inline auto xview<CT, S...>::data_element(size_type i) const -> enable_simd_interface<T, const_reference>
+    inline auto xview<CT, S...>::data_element(size_type i) const -> const_reference
+        requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
     {
         return m_e.data_element(data_offset() + i);
     }
 
+    template <class CT, class... S>
+    template <class T>
+    inline auto xview<CT, S...>::flat(size_type i) -> reference
+        requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
+    {
+        XTENSOR_ASSERT(is_contiguous());
+        return m_e.flat(data_offset() + i);
+    }
+
+    template <class CT, class... S>
+    template <class T>
+    inline auto xview<CT, S...>::flat(size_type i) const -> const_reference
+        requires(has_simd_interface_concept<T> and strided_view_concept<CT, S...>)
+    {
+        XTENSOR_ASSERT(is_contiguous());
+        return m_e.flat(data_offset() + i);
+    }
+
     template <class CT, class... S>
     template <class... Args>
     inline auto xview<CT, S...>::make_index_sequence(Args...) const noexcept
     {
-        return std::make_index_sequence<(sizeof...(Args)+integral_count<S...>() > newaxis_count<S...>() ?
-                                         sizeof...(Args)+integral_count<S...>() - newaxis_count<S...>() :
-                                         0)>();
+        return std::make_index_sequence<
+            (sizeof...(Args) + integral_count<S...>() > newaxis_count<S...>()
+                 ? sizeof...(Args) + integral_count<S...>() - newaxis_count<S...>()
+                 : 0)>();
     }
 
     template <class CT, class... S>
     template <std::size_t... I>
     inline auto xview<CT, S...>::compute_strides_impl(std::index_sequence<I...>) const noexcept
     {
-        return std::array<std::ptrdiff_t, sizeof...(I)>({
-            (static_cast<std::ptrdiff_t>(xt::step_size(std::get<integral_skip<S...>(I)>(m_slices), 1)) * m_e.strides()[integral_skip<S...>(I) - newaxis_count_before<S...>(integral_skip<S...>(I))])...
-        });
+        std::size_t original_dim = m_e.dimension();
+        return std::array<std::ptrdiff_t, sizeof...(I)>(
+            {(static_cast<std::ptrdiff_t>(xt::step_size(std::get<integral_skip<S...>(I)>(m_slices), 1))
+              * ((integral_skip<S...>(I) - newaxis_count_before<S...>(integral_skip<S...>(I))) < original_dim
+                     ? m_e.strides()[integral_skip<S...>(I) - newaxis_count_before<S...>(integral_skip<S...>(I))]
+                     : 1))...}
+        );
     }
 
     template <class CT, class... S>
     inline void xview<CT, S...>::compute_strides(std::false_type) const
     {
-        m_strides = xtl::make_sequence<inner_strides_type>(dimension(), 0);
-        m_backstrides = xtl::make_sequence<inner_strides_type>(dimension(), 0);
+        m_strides = xtl::make_sequence<inner_strides_type>(this->dimension(), 0);
+        m_backstrides = xtl::make_sequence<inner_strides_type>(this->dimension(), 0);
 
         constexpr std::size_t n_strides = sizeof...(S) - integral_count<S...>();
 
@@ -1493,7 +1561,7 @@ namespace xt
             // adapt strides for shape[i] == 1 to make consistent with rest of xtensor
             detail::adapt_strides(shape(), m_strides, &m_backstrides, i);
         }
-        for (std::size_t i = n_strides; i < dimension(); ++i)
+        for (std::size_t i = n_strides; i < this->dimension(); ++i)
         {
             m_strides[i] = m_e.strides()[i + integral_count<S...>() - newaxis_count<S...>()];
             detail::adapt_strides(shape(), m_strides, &m_backstrides, i);
@@ -1517,7 +1585,7 @@ namespace xt
     template <class Arg, class... Args>
     inline auto xview<CT, S...>::access(Arg arg, Args... args) -> reference
     {
-        if (sizeof...(Args) >= dimension())
+        if (sizeof...(Args) >= this->dimension())
         {
             return access(args...);
         }
@@ -1534,7 +1602,7 @@ namespace xt
     template <class Arg, class... Args>
     inline auto xview<CT, S...>::access(Arg arg, Args... args) const -> const_reference
     {
-        if (sizeof...(Args) >= dimension())
+        if (sizeof...(Args) >= this->dimension())
         {
             return access(args...);
         }
@@ -1550,7 +1618,8 @@ namespace xt
 
     template <class CT, class... S>
     template <typename std::decay_t<CT>::size_type... I, class... Args>
-    inline auto xview<CT, S...>::unchecked_impl(std::index_sequence<I...>, Args... args) const -> const_reference
+    inline auto xview<CT, S...>::unchecked_impl(std::index_sequence<I...>, Args... args) const
+        -> const_reference
     {
         return m_e.unchecked(index<I>(args...)...);
     }
@@ -1571,17 +1640,20 @@ namespace xt
 
     template <class CT, class... S>
     template <typename std::decay_t<CT>::size_type I, class... Args>
-    inline auto xview<CT, S...>::index(Args... args) const -> std::enable_if_t<lesser_condition<I>::value, size_type>
-    {
-        return sliced_access<I - integral_count_before<S...>(I) + newaxis_count_before<S...>(I + 1)>
-            (std::get<I + newaxis_count_before<S...>(I + 1)>(m_slices), args...);
-    }
-
-    template <class CT, class... S>
-    template <typename std::decay_t<CT>::size_type I, class... Args>
-    inline auto xview<CT, S...>::index(Args... args) const -> std::enable_if_t<!lesser_condition<I>::value, size_type>
+    inline auto xview<CT, S...>::index(Args... args) const -> size_type
     {
-        return argument<I - integral_count<S...>() + newaxis_count<S...>()>(args...);
+        if constexpr (lesser_condition<I>::value)
+        {
+            constexpr size_type slice_index = newaxis_skip<S...>(I);
+            return sliced_access<slice_index - integral_count_before<S...>(slice_index)>(
+                std::get<slice_index>(m_slices),
+                args...
+            );
+        }
+        else
+        {
+            return argument<I - integral_count<S...>() + newaxis_count<S...>()>(args...);
+        }
     }
 
     template <class CT, class... S>
@@ -1596,12 +1668,15 @@ namespace xt
     inline auto xview<CT, S...>::sliced_access(const xslice<T>& slice, Arg arg, Args... args) const -> size_type
     {
         using ST = typename T::size_type;
-        return static_cast<size_type>(slice.derived_cast()(argument<I>(static_cast<ST>(arg), static_cast<ST>(args)...)));
+        return static_cast<size_type>(
+            slice.derived_cast()(argument<I>(static_cast<ST>(arg), static_cast<ST>(args)...))
+        );
     }
 
     template <class CT, class... S>
     template <typename std::decay_t<CT>::size_type I, class T, class... Args>
-    inline auto xview<CT, S...>::sliced_access(const T& squeeze, Args...) const -> disable_xslice<T, size_type>
+    inline auto xview<CT, S...>::sliced_access(const T& squeeze, Args...) const -> size_type
+        requires(!is_xslice<T>::value)
     {
         return static_cast<size_type>(squeeze);
     }
@@ -1611,25 +1686,37 @@ namespace xt
     inline auto xview<CT, S...>::make_index(It first, It last) const -> base_index_type
     {
         auto index = xtl::make_sequence<base_index_type>(m_e.dimension(), 0);
-        auto func1 = [&first](const auto& s) {
+        using diff_type = typename std::iterator_traits<It>::difference_type;
+        using ivalue_type = typename base_index_type::value_type;
+        auto func1 = [&first](const auto& s) noexcept
+        {
             return get_slice_value(s, first);
         };
-        auto func2 = [](const auto& s) {
+        auto func2 = [](const auto& s) noexcept
+        {
             return xt::value(s, 0);
         };
+
+        auto s = static_cast<diff_type>(
+            (std::min)(static_cast<size_type>(std::distance(first, last)), this->dimension())
+        );
+        auto first_copy = last - s;
         for (size_type i = 0; i != m_e.dimension(); ++i)
         {
             size_type k = newaxis_skip<S...>(i);
-            std::advance(first, k - i);
-            if (first != last)
+
+            // need to advance captured `first`
+            first = first_copy;
+            std::advance(first, static_cast<diff_type>(k - xt::integral_count_before<S...>(i)));
+
+            if (first < last)
             {
-                index[i] = k < sizeof...(S) ?
-                    apply<size_type>(k, func1, m_slices) : *first++;
+                index[i] = k < sizeof...(S) ? apply<size_type>(k, func1, m_slices)
+                                            : static_cast<ivalue_type>(*first);
             }
             else
             {
-                index[i] = k < sizeof...(S) ?
-                    apply<size_type>(k, func2, m_slices) : 0;
+                index[i] = k < sizeof...(S) ? apply<size_type>(k, func2, m_slices) : ivalue_type(0);
             }
         }
         return index;
@@ -1646,12 +1733,15 @@ namespace xt
     {
         std::size_t dim = m_e.dimension() - integral_count<S...>() + newaxis_count<S...>();
         auto shape = xtl::make_sequence<inner_shape_type>(dim, 0);
-        auto func = [](const auto& s) noexcept { return get_size(s); };
+        auto func = [](const auto& s) noexcept
+        {
+            return get_size(s);
+        };
         for (size_type i = 0; i != dim; ++i)
         {
             size_type index = integral_skip<S...>(i);
-            shape[i] = index < sizeof...(S) ?
-                apply<size_type>(index, func, m_slices) : m_e.shape()[index - newaxis_count_before<S...>(index)];
+            shape[i] = index < sizeof...(S) ? apply<size_type>(index, func, m_slices)
+                                            : m_e.shape()[index - newaxis_count_before<S...>(index)];
         }
         return shape;
     }
@@ -1665,7 +1755,8 @@ namespace xt
         }
 
         template <class V, class T>
-        inline void run_assign_temporary_impl(V& v, const T& t, std::false_type /* fallback to iterator assign */)
+        inline void
+        run_assign_temporary_impl(V& v, const T& t, std::false_type /* fallback to iterator assign */)
         {
             std::copy(t.cbegin(), t.cend(), v.begin());
         }
@@ -1674,8 +1765,8 @@ namespace xt
     template <class CT, class... S>
     inline void xview<CT, S...>::assign_temporary_impl(temporary_type&& tmp)
     {
-        constexpr bool fast_assign = detail::is_strided_view<xexpression_type, S...>::value && \
-                                     xassign_traits<xview<CT, S...>, temporary_type>::simd_strided_loop();
+        constexpr bool fast_assign = detail::is_strided_view<xexpression_type, S...>::value
+                                     && xassign_traits<xview<CT, S...>, temporary_type>::simd_strided_assign();
         xview_detail::run_assign_temporary_impl(*this, tmp, std::integral_constant<bool, fast_assign>{});
     }
 
@@ -1708,8 +1799,13 @@ namespace xt
         {
             // Checks that no ellipsis slice is used
             using view_type = xview<xtl::closure_type_t<E>, get_slice_type<std::decay_t<E>, S>...>;
-            return view_type(std::forward<E>(e),
-                get_slice_implementation(e, std::forward<S>(slices), get_underlying_shape_index<std::decay_t<E>, S...>(I))...
+            return view_type(
+                std::forward<E>(e),
+                get_slice_implementation(
+                    e,
+                    std::forward<S>(slices),
+                    get_underlying_shape_index<std::decay_t<E>, S...>(I)
+                )...
             );
         }
     }
@@ -1719,83 +1815,183 @@ namespace xt
      * should not directly construct the slices but call helper functions
      * instead.
      * @param e the xexpression to adapt
-     * @param slices the slices list describing the view
+     * @param slices the slices list describing the view. \c view accepts negative
+     * indices, in that case indexing is done in reverse order.
      * @sa range, all, newaxis
      */
     template <class E, class... S>
     inline auto view(E&& e, S&&... slices)
     {
-        return detail::make_view_impl(std::forward<E>(e), std::make_index_sequence<sizeof...(S)>(), std::forward<S>(slices)...);
+        return detail::make_view_impl(
+            std::forward<E>(e),
+            std::make_index_sequence<sizeof...(S)>(),
+            std::forward<S>(slices)...
+        );
     }
 
-    /***************
-     * stepper api *
-     ***************/
-
-    template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_begin(const ST& shape) -> std::enable_if_t<!Enable, stepper>
+    namespace detail
     {
-        size_type offset = shape.size() - dimension();
-        return stepper(this, m_e.stepper_begin(m_e.shape()), offset);
-    }
+        class row_impl
+        {
+        public:
 
-    template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_end(const ST& shape, layout_type l) -> std::enable_if_t<!Enable, stepper>
-    {
-        size_type offset = shape.size() - dimension();
-        return stepper(this, m_e.stepper_end(m_e.shape(), l), offset, true, l);
+            template <class E>
+            inline static auto make(E&& e, const std::ptrdiff_t index)
+            {
+                const auto shape = e.shape();
+                check_dimension(shape);
+                return view(e, index, xt::all());
+            }
+
+        private:
+
+            template <class S>
+            inline static void check_dimension(const S& shape)
+            {
+                if (shape.size() != 2)
+                {
+                    XTENSOR_THROW(
+                        std::invalid_argument,
+                        "A row can only be accessed on an expression with exact two dimensions"
+                    );
+                }
+            }
+
+            template <class T, std::size_t N>
+            inline static void check_dimension(const std::array<T, N>&)
+            {
+                static_assert(N == 2, "A row can only be accessed on an expression with exact two dimensions");
+            }
+        };
+
+        class column_impl
+        {
+        public:
+
+            template <class E>
+            inline static auto make(E&& e, const std::ptrdiff_t index)
+            {
+                const auto shape = e.shape();
+                check_dimension(shape);
+                return view(e, xt::all(), index);
+            }
+
+        private:
+
+            template <class S>
+            inline static void check_dimension(const S& shape)
+            {
+                if (shape.size() != 2)
+                {
+                    XTENSOR_THROW(
+                        std::invalid_argument,
+                        "A column can only be accessed on an expression with exact two dimensions"
+                    );
+                }
+            }
+
+            template <class T, std::size_t N>
+            inline static void check_dimension(const std::array<T, N>&)
+            {
+                static_assert(N == 2, "A column can only be accessed on an expression with exact two dimensions");
+            }
+        };
     }
 
-    template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_begin(const ST& shape) const -> std::enable_if_t<!Enable, const_stepper>
+    /**
+     * Constructs and returns a row (sliced view) on the specified expression.
+     * Users should not directly construct the slices but call helper functions
+     * instead. This function is only allowed on expressions with two dimensions.
+     * @param e the xexpression to adapt
+     * @param index 0-based index of the row, negative indices will return the
+     * last rows in reverse order.
+     * @throws std::invalid_argument if the expression has more than 2 dimensions.
+     */
+    template <class E>
+    inline auto row(E&& e, std::ptrdiff_t index)
     {
-        size_type offset = shape.size() - dimension();
-        const xexpression_type& e = m_e;
-        return const_stepper(this, e.stepper_begin(m_e.shape()), offset);
+        return detail::row_impl::make(e, index);
     }
 
-    template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_end(const ST& shape, layout_type l) const -> std::enable_if_t<!Enable, const_stepper>
+    /**
+     * Constructs and returns a column (sliced view) on the specified expression.
+     * Users should not directly construct the slices but call helper functions
+     * instead. This function is only allowed on expressions with two dimensions.
+     * @param e the xexpression to adapt
+     * @param index 0-based index of the column, negative indices will return the
+     * last columns in reverse order.
+     * @throws std::invalid_argument if the expression has more than 2 dimensions.
+     */
+    template <class E>
+    inline auto col(E&& e, std::ptrdiff_t index)
     {
-        size_type offset = shape.size() - dimension();
-        const xexpression_type& e = m_e;
-        return const_stepper(this, e.stepper_end(m_e.shape(), l), offset, true, l);
+        return detail::column_impl::make(e, index);
     }
 
+    /***************
+     * stepper api *
+     ***************/
+
     template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_begin(const ST& shape) -> std::enable_if_t<Enable, stepper>
+    template <class ST>
+    inline auto xview<CT, S...>::stepper_begin(const ST& shape) -> stepper
     {
-        size_type offset = shape.size() - dimension();
-        return stepper(this, data_xbegin(), offset);
+        const size_type offset = shape.size() - this->dimension();
+        if constexpr (is_strided_view)
+        {
+            return stepper(this, data_xbegin(), offset);
+        }
+        else
+        {
+            return stepper(this, m_e.stepper_begin(m_e.shape()), offset);
+        }
     }
 
     template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_end(const ST& shape, layout_type l) -> std::enable_if_t<Enable, stepper>
+    template <class ST>
+    inline auto xview<CT, S...>::stepper_end(const ST& shape, layout_type l) -> stepper
     {
-        size_type offset = shape.size() - dimension();
-        return stepper(this, data_xend(l), offset);
+        const size_type offset = shape.size() - this->dimension();
+        if constexpr (is_strided_view)
+        {
+            return stepper(this, data_xend(l, offset), offset);
+        }
+        else
+        {
+            return stepper(this, m_e.stepper_end(m_e.shape(), l), offset, true, l);
+        }
     }
 
     template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_begin(const ST& shape) const -> std::enable_if_t<Enable, const_stepper>
+    template <class ST>
+    inline auto xview<CT, S...>::stepper_begin(const ST& shape) const -> const_stepper
     {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(this, data_xbegin(), offset);
+        const size_type offset = shape.size() - this->dimension();
+        if constexpr (is_strided_view)
+        {
+            return const_stepper(this, data_xbegin(), offset);
+        }
+        else
+        {
+            const xexpression_type& e = m_e;
+            return const_stepper(this, e.stepper_begin(m_e.shape()), offset);
+        }
     }
 
     template <class CT, class... S>
-    template <class ST, bool Enable>
-    inline auto xview<CT, S...>::stepper_end(const ST& shape, layout_type l) const-> std::enable_if_t<Enable, const_stepper>
+    template <class ST>
+    inline auto xview<CT, S...>::stepper_end(const ST& shape, layout_type l) const -> const_stepper
     {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(this, data_xend(l), offset);
+        const size_type offset = shape.size() - this->dimension();
+        if constexpr (is_strided_view)
+        {
+            return const_stepper(this, data_xend(l, offset), offset);
+        }
+        else
+        {
+            const xexpression_type& e = m_e;
+            return const_stepper(this, e.stepper_end(m_e.shape(), l), offset, true, l);
+        }
     }
 
     /********************************
@@ -1803,14 +1999,24 @@ namespace xt
      ********************************/
 
     template <bool is_const, class CT, class... S>
-    inline xview_stepper<is_const, CT, S...>::xview_stepper(view_type* view, substepper_type it,
-                                                            size_type offset, bool end, layout_type l)
-        : p_view(view), m_it(it), m_offset(offset)
+    inline xview_stepper<is_const, CT, S...>::xview_stepper(
+        view_type* view,
+        substepper_type it,
+        size_type offset,
+        bool end,
+        layout_type l
+    )
+        : p_view(view)
+        , m_it(it)
+        , m_offset(offset)
     {
         if (!end)
         {
             std::fill(m_index_keeper.begin(), m_index_keeper.end(), 0);
-            auto func = [](const auto& s) { return xt::value(s, 0); };
+            auto func = [](const auto& s) noexcept
+            {
+                return xt::value(s, 0);
+            };
             for (size_type i = 0; i < sizeof...(S); ++i)
             {
                 if (!is_newaxis_slice(i))
@@ -1836,14 +2042,18 @@ namespace xt
     template <bool is_const, class CT, class... S>
     inline void xview_stepper<is_const, CT, S...>::step(size_type dim)
     {
-        auto func = [this](size_type index, size_type offset) { m_it.step(index, offset); };
+        auto func = [this](size_type index, size_type offset)
+        {
+            m_it.step(index, offset);
+        };
         common_step_forward(dim, func);
     }
 
     template <bool is_const, class CT, class... S>
     inline void xview_stepper<is_const, CT, S...>::step_back(size_type dim)
     {
-        auto func = [this](size_type index, size_type offset) {
+        auto func = [this](size_type index, size_type offset)
+        {
             m_it.step_back(index, offset);
         };
         common_step_backward(dim, func);
@@ -1852,14 +2062,18 @@ namespace xt
     template <bool is_const, class CT, class... S>
     inline void xview_stepper<is_const, CT, S...>::step(size_type dim, size_type n)
     {
-        auto func = [this](size_type index, size_type offset) { m_it.step(index, offset); };
+        auto func = [this](size_type index, size_type offset)
+        {
+            m_it.step(index, offset);
+        };
         common_step_forward(dim, n, func);
     }
 
     template <bool is_const, class CT, class... S>
     inline void xview_stepper<is_const, CT, S...>::step_back(size_type dim, size_type n)
     {
-        auto func = [this](size_type index, size_type offset) {
+        auto func = [this](size_type index, size_type offset)
+        {
             m_it.step_back(index, offset);
         };
         common_step_backward(dim, n, func);
@@ -1868,14 +2082,20 @@ namespace xt
     template <bool is_const, class CT, class... S>
     inline void xview_stepper<is_const, CT, S...>::reset(size_type dim)
     {
-        auto func = [this](size_type index, size_type offset) { m_it.step_back(index, offset); };
+        auto func = [this](size_type index, size_type offset)
+        {
+            m_it.step_back(index, offset);
+        };
         common_reset(dim, func, false);
     }
 
     template <bool is_const, class CT, class... S>
     inline void xview_stepper<is_const, CT, S...>::reset_back(size_type dim)
     {
-        auto func = [this](size_type index, size_type offset) { m_it.step(index, offset); };
+        auto func = [this](size_type index, size_type offset)
+        {
+            m_it.step(index, offset);
+        };
         common_reset(dim, func, true);
     }
 
@@ -1903,10 +2123,12 @@ namespace xt
     template <bool is_const, class CT, class... S>
     inline void xview_stepper<is_const, CT, S...>::to_end_impl(layout_type l)
     {
-        auto func = [](const auto& s) {
+        auto func = [](const auto& s) noexcept
+        {
             return xt::value(s, get_size(s) - 1);
         };
-        auto size_func = [](const auto& s) {
+        auto size_func = [](const auto& s) noexcept
+        {
             return get_size(s);
         };
 
@@ -1916,7 +2138,7 @@ namespace xt
             {
                 size_type s = apply<size_type>(i, func, p_view->slices());
                 size_type ix = apply<size_type>(i, size_func, p_view->slices());
-                m_index_keeper[i] = ix;
+                m_index_keeper[i] = ix - size_type(1);
                 size_type index = i - newaxis_count_before<S...>(i);
                 s = p_view->underlying_size(index) - 1 - s;
                 m_it.step_back(index, s);
@@ -1946,7 +2168,7 @@ namespace xt
         }
         else
         {
-            throw std::runtime_error("Iteration only allowed in row or column major.");
+            XTENSOR_THROW(std::runtime_error, "Iteration only allowed in row or column major.");
         }
     }
 
@@ -1956,19 +2178,15 @@ namespace xt
     {
         if (dim >= m_offset)
         {
-            auto func = [&dim, this](const auto& s) noexcept {
-                this->m_index_keeper[dim]++;
-                // index_keeper tracks index+1, this should be refactored
-                // there are some pitfalls in to_end_impl and common_reset
-                // methods
-                auto idx = this->m_index_keeper[dim] - 1;
-                return step_size(s, idx, 1);
+            auto func = [&dim, this](const auto& s) noexcept
+            {
+                return step_size(s, this->m_index_keeper[dim]++, 1);
             };
             size_type index = integral_skip<S...>(dim);
             if (!is_newaxis_slice(index))
             {
-                size_type step_size = index < sizeof...(S) ?
-                    apply<size_type>(index, func, p_view->slices()) : 1;
+                size_type step_size = index < sizeof...(S) ? apply<size_type>(index, func, p_view->slices())
+                                                           : 1;
                 index -= newaxis_count_before<S...>(index);
                 f(index, step_size);
             }
@@ -1981,17 +2199,18 @@ namespace xt
     {
         if (dim >= m_offset)
         {
-            auto func = [&dim, &n, this](const auto& s) noexcept {
+            auto func = [&dim, &n, this](const auto& s) noexcept
+            {
+                auto st_size = step_size(s, this->m_index_keeper[dim], n);
                 this->m_index_keeper[dim] += n;
-                auto idx = this->m_index_keeper[dim] - 1;
-                return step_size(s, idx, n);
+                return size_type(st_size);
             };
 
             size_type index = integral_skip<S...>(dim);
             if (!is_newaxis_slice(index))
             {
-                size_type step_size = index < sizeof...(S) ?
-                    apply<size_type>(index, func, p_view->slices()) : n;
+                size_type step_size = index < sizeof...(S) ? apply<size_type>(index, func, p_view->slices())
+                                                           : n;
                 index -= newaxis_count_before<S...>(index);
                 f(index, step_size);
             }
@@ -2004,19 +2223,16 @@ namespace xt
     {
         if (dim >= m_offset)
         {
-            auto func = [&dim, this](const auto& s) noexcept {
+            auto func = [&dim, this](const auto& s) noexcept
+            {
                 this->m_index_keeper[dim]--;
-                // index_keeper tracks index+1, this should be refactored
-                // there are some pitfalls in to_end_impl and common_reset
-                // methods
-                auto idx = this->m_index_keeper[dim] - 1;
-                return step_size(s, idx, 1);
+                return step_size(s, this->m_index_keeper[dim], 1);
             };
             size_type index = integral_skip<S...>(dim);
             if (!is_newaxis_slice(index))
             {
-                size_type step_size = index < sizeof...(S) ?
-                    apply<size_type>(index, func, p_view->slices()) : 1;
+                size_type step_size = index < sizeof...(S) ? apply<size_type>(index, func, p_view->slices())
+                                                           : 1;
                 index -= newaxis_count_before<S...>(index);
                 f(index, step_size);
             }
@@ -2029,20 +2245,17 @@ namespace xt
     {
         if (dim >= m_offset)
         {
-            auto func = [&dim, &n, this](const auto& s) noexcept {
+            auto func = [&dim, &n, this](const auto& s) noexcept
+            {
                 this->m_index_keeper[dim] -= n;
-                // index_keeper tracks index+1, this should be refactored
-                // there are some pitfalls in to_end_impl and common_reset
-                // methods
-                auto idx = this->m_index_keeper[dim] - 1;
-                return step_size(s, idx, n);
+                return step_size(s, this->m_index_keeper[dim], n);
             };
 
             size_type index = integral_skip<S...>(dim);
             if (!is_newaxis_slice(index))
             {
-                size_type step_size = index < sizeof...(S) ?
-                    apply<size_type>(index, func, p_view->slices()) : n;
+                size_type step_size = index < sizeof...(S) ? apply<size_type>(index, func, p_view->slices())
+                                                           : n;
                 index -= newaxis_count_before<S...>(index);
                 f(index, step_size);
             }
@@ -2053,26 +2266,27 @@ namespace xt
     template <class F>
     void xview_stepper<is_const, CT, S...>::common_reset(size_type dim, F f, bool backwards)
     {
-        auto size_func = [](const auto& s) noexcept { return get_size(s); };
-        auto end_func = [](const auto& s) noexcept { return xt::value(s, get_size(s) - 1) - xt::value(s, 0); };
+        auto size_func = [](const auto& s) noexcept
+        {
+            return get_size(s);
+        };
+        auto end_func = [](const auto& s) noexcept
+        {
+            return xt::value(s, get_size(s) - 1) - xt::value(s, 0);
+        };
 
         size_type index = integral_skip<S...>(dim);
         if (!is_newaxis_slice(index))
         {
-            size_type size = index < sizeof...(S) ? apply<size_type>(index, size_func, p_view->slices()) : p_view->shape()[dim];
-            if (size != 0)
-            {
-                size = size - 1;
-            }
-
-            size_type sz = index < sizeof...(S) ? apply<size_type>(index, size_func, p_view->slices()) : p_view->shape()[dim];
             if (dim < m_index_keeper.size())
             {
-                m_index_keeper[dim] = backwards ? sz : 0;
+                size_type size = index < sizeof...(S) ? apply<size_type>(index, size_func, p_view->slices())
+                                                      : p_view->shape()[dim];
+                m_index_keeper[dim] = backwards ? size - 1 : 0;
             }
 
-            auto ss = index < sizeof...(S) ? apply<size_type>(index, end_func, p_view->slices()) : p_view->shape()[dim];
-            size_type reset_n = index < sizeof...(S) ? ss : size;
+            size_type reset_n = index < sizeof...(S) ? apply<size_type>(index, end_func, p_view->slices())
+                                                     : p_view->shape()[dim] - 1;
             index -= newaxis_count_before<S...>(index);
             f(index, reset_n);
         }
diff --git a/include/xtensor/xview_utils.hpp b/include/xtensor/views/xview_utils.hpp
similarity index 66%
rename from include/xtensor/xview_utils.hpp
rename to include/xtensor/views/xview_utils.hpp
index fc05f9ec1..696fa8762 100644
--- a/include/xtensor/xview_utils.hpp
+++ b/include/xtensor/views/xview_utils.hpp
@@ -1,17 +1,20 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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_VIEW_UTILS_HPP
 #define XTENSOR_VIEW_UTILS_HPP
 
 #include <array>
 
-#include "xslice.hpp"
+#include "../core/xlayout.hpp"
+#include "../core/xtensor_forward.hpp"
+#include "../views/xslice.hpp"
 
 namespace xt
 {
@@ -36,7 +39,7 @@ namespace xt
     template <class... S>
     constexpr std::size_t newaxis_count();
 
-// number of newaxis types in the specified sequence of types before specified index
+    // number of newaxis types in the specified sequence of types before specified index
     template <class... S>
     constexpr std::size_t newaxis_count_before(std::size_t i);
 
@@ -44,17 +47,17 @@ namespace xt
     template <class... S>
     constexpr std::size_t newaxis_skip(std::size_t i);
 
-    // return slice evaluation and increment iterator
     template <class S, class It>
-    inline disable_xslice<S, std::size_t> get_slice_value(const S& s, It&) noexcept
+    inline auto get_slice_value(const S& slice, It& it) noexcept
     {
-        return static_cast<std::size_t>(s);
-    }
-
-    template <class S, class It>
-    inline auto get_slice_value(const xslice<S>& slice, It& it) noexcept
-    {
-        return slice.derived_cast()(typename S::size_type(*it++));
+        if constexpr (is_xslice<S>::value)
+        {
+            return slice(typename S::size_type(*it));
+        }
+        else
+        {
+            return static_cast<std::size_t>(slice);
+        }
     }
 
     /***********************
@@ -66,32 +69,32 @@ namespace xt
         template <class T, class S, layout_type L, class... SL>
         struct view_temporary_type_impl
         {
-            using type = xarray<T, L>;
+            using type = xt::xarray<T, L>;
         };
 
         template <class T, class I, std::size_t N, layout_type L, class... SL>
         struct view_temporary_type_impl<T, std::array<I, N>, L, SL...>
         {
-            using type = xtensor<T, N + newaxis_count<SL...>() - integral_count<SL...>(), L>;
+            using type = xt::xtensor<T, N + newaxis_count<SL...>() - integral_count<SL...>(), L>;
         };
     }
 
     template <class E, class... SL>
     struct view_temporary_type
     {
-        using type = typename detail::view_temporary_type_impl<std::decay_t<typename E::value_type>,
-                                                               typename E::shape_type,
-                                                               E::static_layout,
-                                                               SL...>::type;
+        using type = typename detail::view_temporary_type_impl<
+            std::decay_t<typename E::value_type>,
+            typename E::shape_type,
+            E::static_layout,
+            SL...>::type;
     };
 
     template <class E, class... SL>
     using view_temporary_type_t = typename view_temporary_type<E, SL...>::type;
 
-
     /************************
-    * count integral types *
-    ************************/
+     * count integral types *
+     ************************/
 
     namespace detail
     {
@@ -101,7 +104,10 @@ namespace xt
         {
             static constexpr std::size_t count(std::size_t i) noexcept
             {
-                return i ? (integral_count_impl<S...>::count(i - 1) + (std::is_integral<std::remove_reference_t<T>>::value ? 1 : 0)) : 0;
+                return i
+                           ? (integral_count_impl<S...>::count(i - 1)
+                              + (xtl::is_integral<std::remove_reference_t<T>>::value ? 1 : 0))
+                           : 0;
             }
         };
 
@@ -128,8 +134,8 @@ namespace xt
     }
 
     /***********************
-    * count newaxis types *
-    ***********************/
+     * count newaxis types *
+     ***********************/
 
     namespace detail
     {
@@ -143,12 +149,18 @@ namespace xt
         {
         };
 
+        template <class T>
+        constexpr bool is_newaxis_v = is_newaxis<T>::value;
+
         template <class T, class... S>
         struct newaxis_count_impl
         {
             static constexpr std::size_t count(std::size_t i) noexcept
             {
-                return i ? (newaxis_count_impl<S...>::count(i - 1) + (is_newaxis<std::remove_reference_t<T>>::value ? 1 : 0)) : 0;
+                return i
+                           ? (newaxis_count_impl<S...>::count(i - 1)
+                              + (is_newaxis<std::remove_reference_t<T>>::value ? 1 : 0))
+                           : 0;
             }
         };
 
@@ -175,8 +187,8 @@ namespace xt
     }
 
     /**********************************
-    * index of ith non-integral type *
-    **********************************/
+     * index of ith non-integral type *
+     **********************************/
 
     namespace detail
     {
@@ -193,16 +205,17 @@ namespace xt
 
             static constexpr std::size_t count_impl(std::size_t i) noexcept
             {
-                return 1 + (
-                    std::is_integral<std::remove_reference_t<T>>::value ?
-                    integral_skip_impl<S...>::count(i) :
-                    integral_skip_impl<S...>::count(i - 1)
-                    );
+                return 1
+                       + (xtl::is_integral<std::remove_reference_t<T>>::value
+                              ? integral_skip_impl<S...>::count(i)
+                              : integral_skip_impl<S...>::count(i - 1));
             }
 
             static constexpr std::size_t count_impl() noexcept
             {
-                return std::is_integral<std::remove_reference_t<T>>::value ? 1 + integral_skip_impl<S...>::count(0) : 0;
+                return xtl::is_integral<std::remove_reference_t<T>>::value
+                           ? 1 + integral_skip_impl<S...>::count(0)
+                           : 0;
             }
         };
 
@@ -223,8 +236,8 @@ namespace xt
     }
 
     /*********************************
-    * index of ith non-newaxis type *
-    *********************************/
+     * index of ith non-newaxis type *
+     *********************************/
 
     namespace detail
     {
@@ -241,16 +254,16 @@ namespace xt
 
             static constexpr std::size_t count_impl(std::size_t i) noexcept
             {
-                return 1 + (
-                    is_newaxis<std::remove_reference_t<T>>::value ?
-                    newaxis_skip_impl<S...>::count(i) :
-                    newaxis_skip_impl<S...>::count(i - 1)
-                    );
+                return 1
+                       + (is_newaxis<std::remove_reference_t<T>>::value
+                              ? newaxis_skip_impl<S...>::count(i)
+                              : newaxis_skip_impl<S...>::count(i - 1));
             }
 
             static constexpr std::size_t count_impl() noexcept
             {
-                return is_newaxis<std::remove_reference_t<T>>::value ? 1 + newaxis_skip_impl<S...>::count(0) : 0;
+                return is_newaxis<std::remove_reference_t<T>>::value ? 1 + newaxis_skip_impl<S...>::count(0)
+                                                                     : 0;
             }
         };
 
diff --git a/include/xtensor/xadapt.hpp b/include/xtensor/xadapt.hpp
deleted file mode 100644
index c9cec7f12..000000000
--- a/include/xtensor/xadapt.hpp
+++ /dev/null
@@ -1,416 +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 XTENSOR_ADAPT_HPP
-#define XTENSOR_ADAPT_HPP
-
-#include <array>
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-
-#include <xtl/xsequence.hpp>
-
-#include "xarray.hpp"
-#include "xtensor.hpp"
-#include "xfixed.hpp"
-
-namespace xt
-{
-    namespace detail
-    {
-        template <class>
-        struct array_size_impl;
-
-        template <class T, std::size_t N>
-        struct array_size_impl<std::array<T, N>>
-        {
-            static constexpr std::size_t value = N;
-        };
-
-        template <class C>
-        using array_size = array_size_impl<std::decay_t<C>>;
-
-        template <class P>
-        struct default_allocator_for_ptr
-        {
-            using type = std::allocator<std::remove_const_t<std::remove_pointer_t<std::remove_reference_t<P>>>>;
-        };
-
-        template <class P>
-        using default_allocator_for_ptr_t = typename default_allocator_for_ptr<P>::type;
-    }
-
-    /**************************
-     * xarray_adaptor builder *
-     **************************/
-
-    /**
-     * Constructs an xarray_adaptor of the given stl-like container,
-     * with the specified shape and layout.
-     * @param container the container to adapt
-     * @param shape the shape of the xarray_adaptor
-     * @param l the layout_type of the xarray_adaptor
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class SC,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<!std::is_pointer<C>::value, int> = 0>
-    xarray_adaptor<xtl::closure_type_t<C>, L, std::decay_t<SC>>
-    adapt(C&& container, const SC& shape, layout_type l = L);
-
-    /**
-     * Constructs an non-owning xarray_adaptor from a pointer with the specified shape and layout.
-     * @param pointer the container to adapt
-     * @param shape the shape of the xarray_adaptor
-     * @param l the layout_type of the xarray_adaptor
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class SC,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<std::is_pointer<C>::value, int> = 0>
-    inline auto adapt(C&& pointer, const SC& shape, layout_type l = L);
-
-    /**
-     * Constructs an xarray_adaptor of the given stl-like container,
-     * with the specified shape and strides.
-     * @param container the container to adapt
-     * @param shape the shape of the xarray_adaptor
-     * @param strides the strides of the xarray_adaptor
-     */
-    template <class C, class SC, class SS,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int> = 0>
-    xarray_adaptor<xtl::closure_type_t<C>, layout_type::dynamic, std::decay_t<SC>>
-    adapt(C&& container, SC&& shape, SS&& strides);
-
-    /**
-     * Constructs an xarray_adaptor of the given dynamically allocated C array,
-     * with the specified shape and layout.
-     * @param pointer the pointer to the beginning of the dynamic array
-     * @param size the size of the dynamic array
-     * @param ownership indicates whether the adaptor takes ownership of the array.
-     *        Possible values are ``no_ownerhsip()`` or ``acquire_ownership()``
-     * @param shape the shape of the xarray_adaptor
-     * @param l the layout_type of the xarray_adaptor
-     * @param alloc the allocator used for allocating / deallocating the dynamic array
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class O, class SC, class A = detail::default_allocator_for_ptr_t<P>,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int> = 0>
-    xarray_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, L, SC>
-    adapt(P&& pointer, typename A::size_type size, O ownership, const SC& shape, layout_type l = L, const A& alloc = A());
-
-    /**
-     * Constructs an xarray_adaptor of the given dynamically allocated C array,
-     * with the specified shape and layout.
-     * @param pointer the pointer to the beginning of the dynamic array
-     * @param size the size of the dynamic array
-     * @param ownership indicates whether the adaptor takes ownership of the array.
-     *        Possible values are ``no_ownerhsip()`` or ``acquire_ownership()``
-     * @param shape the shape of the xarray_adaptor
-     * @param strides the strides of the xarray_adaptor
-     * @param alloc the allocator used for allocating / deallocating the dynamic array
-     */
-    template <class P, class O, class SC, class SS, class A = detail::default_allocator_for_ptr_t<P>,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int> = 0>
-    xarray_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, layout_type::dynamic, std::decay_t<SC>>
-    adapt(P&& pointer, typename A::size_type size, O ownership, SC&& shape, SS&& strides, const A& alloc = A());
-
-    /***************************
-     * xtensor_adaptor builder *
-     ***************************/
-
-    /**
-     * Constructs a 1-D xtensor_adaptor of the given stl-like container,
-     * with the specified layout_type.
-     * @param container the container to adapt
-     * @param l the layout_type of the xtensor_adaptor
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C>
-    xtensor_adaptor<C, 1, L>
-    adapt(C&& container, layout_type l = L);
-
-    /**
-     * Constructs an xtensor_adaptor of the given stl-like container,
-     * with the specified shape and layout_type.
-     * @param container the container to adapt
-     * @param shape the shape of the xtensor_adaptor
-     * @param l the layout_type of the xtensor_adaptor
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class SC,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<!std::is_pointer<C>::value, int> = 0>
-    xtensor_adaptor<C, detail::array_size<SC>::value, L>
-    adapt(C&& container, const SC& shape, layout_type l = L);
-
-    /**
-     * Constructs an non-owning xtensor_adaptor from a pointer with the specified shape and layout.
-     * @param pointer the pointer to adapt
-     * @param shape the shape of the xtensor_adaptor
-     * @param l the layout_type of the xtensor_adaptor
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class SC,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<std::is_pointer<C>::value, int> = 0>
-    auto adapt(C&& pointer, const SC& shape, layout_type l = L);
-
-    /**
-     * Constructs an xtensor_adaptor of the given stl-like container,
-     * with the specified shape and strides.
-     * @param container the container to adapt
-     * @param shape the shape of the xtensor_adaptor
-     * @param strides the strides of the xtensor_adaptor
-     */
-    template <class C, class SC, class SS,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int> = 0>
-    xtensor_adaptor<C, detail::array_size<SC>::value, layout_type::dynamic>
-    adapt(C&& container, SC&& shape, SS&& strides);
-
-    /**
-     * Constructs a 1-D xtensor_adaptor of the given dynamically allocated C array,
-     * with the specified layout.
-     * @param pointer the pointer to the beginning of the dynamic array
-     * @param size the size of the dynamic array
-     * @param ownership indicates whether the adaptor takes ownership of the array.
-     *        Possible values are ``no_ownerhsip()`` or ``acquire_ownership()``
-     * @param l the layout_type of the xtensor_adaptor
-     * @param alloc the allocator used for allocating / deallocating the dynamic array
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class O, class A = detail::default_allocator_for_ptr_t<P>>
-    xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, 1, L>
-    adapt(P&& pointer, typename A::size_type size, O ownership, layout_type l = L, const A& alloc = A());
-
-    /**
-     * Constructs an xtensor_adaptor of the given dynamically allocated C array,
-     * with the specified shape and layout.
-     * @param pointer the pointer to the beginning of the dynamic array
-     * @param size the size of the dynamic array
-     * @param ownership indicates whether the adaptor takes ownership of the array.
-     *        Possible values are ``no_ownerhsip()`` or ``acquire_ownership()``
-     * @param shape the shape of the xtensor_adaptor
-     * @param l the layout_type of the xtensor_adaptor
-     * @param alloc the allocator used for allocating / deallocating the dynamic array
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class P, class O, class SC, class A = detail::default_allocator_for_ptr_t<P>,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int> = 0>
-    xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, detail::array_size<SC>::value, L>
-    adapt(P&& pointer, typename A::size_type size, O ownership, const SC& shape, layout_type l = L, const A& alloc = A());
-
-    /**
-     * Constructs an xtensor_adaptor of the given dynamically allocated C array,
-     * with the specified shape and strides.
-     * @param pointer the pointer to the beginning of the dynamic array
-     * @param size the size of the dynamic array
-     * @param ownership indicates whether the adaptor takes ownership of the array.
-     *        Possible values are ``no_ownerhsip()`` or ``acquire_ownership()``
-     * @param shape the shape of the xtensor_adaptor
-     * @param strides the strides of the xtensor_adaptor
-     * @param alloc the allocator used for allocating / deallocating the dynamic array
-     */
-    template <class P, class O, class SC, class SS, class A = detail::default_allocator_for_ptr_t<P>,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int> = 0,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int> = 0>
-    xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, detail::array_size<SC>::value, layout_type::dynamic>
-    adapt(P&& pointer, typename A::size_type size, O ownership, SC&& shape, SS&& strides, const A& alloc = A());
-
-    /**
-     * Constructs an non-owning xtensor_fixed_adaptor from a pointer with the
-     * specified shape and layout.
-     * @param pointer the pointer to adapt
-     * @param shape the shape of the xtensor_fixed_adaptor
-     * @param l the layout_type of the xtensor_fixed_adaptor
-     */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, std::size_t... X,
-              typename std::enable_if_t<std::is_pointer<C>::value, int> = 0>
-    inline auto adapt(C&& ptr, const fixed_shape<X...>& /*shape*/);
-
-    /*****************************************
-     * xarray_adaptor builder implementation *
-     *****************************************/
-
-    // shape only - container version
-    template <layout_type L, class C, class SC,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<!std::is_pointer<C>::value, int>>
-    inline xarray_adaptor<xtl::closure_type_t<C>, L, std::decay_t<SC>>
-    adapt(C&& container, const SC& shape, layout_type l)
-    {
-        using return_type = xarray_adaptor<xtl::closure_type_t<C>, L, std::decay_t<SC>>;
-        return return_type(std::forward<C>(container), shape, l);
-    }
-
-    template <layout_type L, class C, class SC,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<std::is_pointer<C>::value, int>>
-    inline auto adapt(C&& pointer, const SC& shape, layout_type l)
-    {
-        using buffer_type = xbuffer_adaptor<C, xt::no_ownership, detail::default_allocator_for_ptr_t<C>>;
-        using return_type = xarray_adaptor<buffer_type, L, std::decay_t<SC>>;
-        std::size_t size = compute_size(shape);
-        return return_type(buffer_type(pointer, size), shape, l);
-    }
-
-    // shape and strides - container version
-    template <class C, class SC, class SS,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int>>
-    inline xarray_adaptor<xtl::closure_type_t<C>, layout_type::dynamic, std::decay_t<SC>>
-    adapt(C&& container, SC&& shape, SS&& strides)
-    {
-        using return_type = xarray_adaptor<xtl::closure_type_t<C>, layout_type::dynamic, std::decay_t<SC>>;
-        return return_type(std::forward<C>(container),
-                           xtl::forward_sequence<typename return_type::inner_shape_type>(shape),
-                           xtl::forward_sequence<typename return_type::inner_strides_type>(strides));
-    }
-
-    // shape only - buffer version
-    template <layout_type L, class P, class O, class SC, class A,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int>>
-    inline xarray_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, L, SC>
-    adapt(P&& pointer, typename A::size_type size, O, const SC& shape, layout_type l, const A& alloc)
-    {
-        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
-        using return_type = xarray_adaptor<buffer_type, L, SC>;
-        buffer_type buf(std::forward<P>(pointer), size, alloc);
-        return return_type(std::move(buf), shape, l);
-    }
-
-    // shape and strides - buffer version
-    template <class P, class O, class SC, class SS, class A,
-              typename std::enable_if_t<!detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int>>
-    inline xarray_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, layout_type::dynamic, std::decay_t<SC>>
-    adapt(P&& pointer, typename A::size_type size, O, SC&& shape, SS&& strides, const A& alloc)
-    {
-        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
-        using return_type = xarray_adaptor<buffer_type, layout_type::dynamic, std::decay_t<SC>>;
-        buffer_type buf(std::forward<P>(pointer), size, alloc);
-        return return_type(std::move(buf),
-                           xtl::forward_sequence<typename return_type::inner_shape_type>(shape),
-                           xtl::forward_sequence<typename return_type::inner_strides_type>(strides));
-    }
-
-    /******************************************
-     * xtensor_adaptor builder implementation *
-     ******************************************/
-
-    // 1-D case - container version
-    template <layout_type L, class C>
-    inline xtensor_adaptor<C, 1, L>
-    adapt(C&& container, layout_type l)
-    {
-        const std::array<typename std::decay_t<C>::size_type, 1> shape{container.size()};
-        using return_type = xtensor_adaptor<xtl::closure_type_t<C>, 1, L>;
-        return return_type(std::forward<C>(container), shape, l);
-    }
-
-    // shape only - container version
-    template <layout_type L, class C, class SC,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<!std::is_pointer<C>::value, int>>
-    inline xtensor_adaptor<C, detail::array_size<SC>::value, L>
-    adapt(C&& container, const SC& shape, layout_type l)
-    {
-        constexpr std::size_t N = detail::array_size<SC>::value;
-        using return_type = xtensor_adaptor<xtl::closure_type_t<C>, N, L>;
-        return return_type(std::forward<C>(container), shape, l);
-    }
-
-    template <layout_type L, class C, class SC,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<std::is_pointer<C>::value, int>>
-    inline auto adapt(C&& ptr, const SC& shape, layout_type l)
-    {
-        using buffer_type = xbuffer_adaptor<C, xt::no_ownership, detail::default_allocator_for_ptr_t<C>>;
-        constexpr std::size_t N = detail::array_size<SC>::value;
-        using return_type = xtensor_adaptor<buffer_type, N, L>;
-        return return_type(buffer_type(ptr, compute_size(shape)), shape, l);
-    }
-
-    template <layout_type L, class C, std::size_t... X,
-              typename std::enable_if_t<std::is_pointer<C>::value, int>>
-    inline auto adapt(C&& ptr, const fixed_shape<X...>& /*shape*/)
-    {
-        using buffer_type = xbuffer_adaptor<C, xt::no_ownership, detail::default_allocator_for_ptr_t<C>>;
-        using return_type = xfixed_adaptor<buffer_type, fixed_shape<X...>, L>;
-        return return_type(buffer_type(ptr, detail::fixed_compute_size<fixed_shape<X...>>::value));
-    }
-
-#ifndef X_OLD_CLANG
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class T,  std::size_t N>
-    inline auto adapt(C&& ptr, const T(&shape)[N])
-    {
-        using shape_type = std::array<std::size_t, N>;
-        return adapt(std::forward<C>(ptr), xtl::forward_sequence<shape_type>(shape));
-    }
-#else
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C>
-    inline auto adapt(C&& ptr, std::initializer_list<std::size_t> shape)
-    {
-        using shape_type = xt::dynamic_shape<std::size_t>;
-        return adapt(std::forward<C>(ptr), xtl::forward_sequence<shape_type>(shape));
-    }
-#endif
-
-    // shape and strides - container version
-    template <class C, class SC, class SS,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int>>
-    inline xtensor_adaptor<C, detail::array_size<SC>::value, layout_type::dynamic>
-    adapt(C&& container, SC&& shape, SS&& strides)
-    {
-        constexpr std::size_t N = detail::array_size<SC>::value;
-        using return_type = xtensor_adaptor<xtl::closure_type_t<C>, N, layout_type::dynamic>;
-        return return_type(std::forward<C>(container),
-                           xtl::forward_sequence<typename return_type::inner_shape_type>(shape),
-                           xtl::forward_sequence<typename return_type::inner_strides_type>(strides));
-    }
-
-    // 1-D case - buffer version
-    template <layout_type L, class P, class O, class A>
-    inline xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, 1, L>
-    adapt(P&& pointer, typename A::size_type size, O, layout_type l, const A& alloc)
-    {
-        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
-        using return_type = xtensor_adaptor<buffer_type, 1, L>;
-        buffer_type buf(std::forward<P>(pointer), size, alloc);
-        const std::array<typename A::size_type, 1> shape{size};
-        return return_type(std::move(buf), shape, l);
-    }
-
-    // shape only - buffer version
-    template <layout_type L, class P, class O, class SC, class A,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int>>
-    inline xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, detail::array_size<SC>::value, L>
-    adapt(P&& pointer, typename A::size_type size, O, const SC& shape, layout_type l, const A& alloc)
-    {
-        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
-        constexpr std::size_t N = detail::array_size<SC>::value;
-        using return_type = xtensor_adaptor<buffer_type, N, L>;
-        buffer_type buf(std::forward<P>(pointer), size, alloc);
-        return return_type(std::move(buf), shape, l);
-    }
-
-    // shape and strides - buffer version
-    template <class P, class O, class SC, class SS, class A,
-              typename std::enable_if_t<detail::is_array<std::decay_t<SC>>::value, int>,
-              typename std::enable_if_t<!std::is_same<layout_type, std::decay_t<SS>>::value, int>>
-    inline xtensor_adaptor<xbuffer_adaptor<xtl::closure_type_t<P>, O, A>, detail::array_size<SC>::value, layout_type::dynamic>
-    adapt(P&& pointer, typename A::size_type size, O, SC&& shape, SS&& strides, const A& alloc)
-    {
-        using buffer_type = xbuffer_adaptor<xtl::closure_type_t<P>, O, A>;
-        constexpr std::size_t N = detail::array_size<SC>::value;
-        using return_type = xtensor_adaptor<buffer_type, N, layout_type::dynamic>;
-        buffer_type buf(std::forward<P>(pointer), size, alloc);
-        return return_type(std::move(buf),
-                           xtl::forward_sequence<typename return_type::inner_shape_type>(shape),
-                           xtl::forward_sequence<typename return_type::inner_strides_type>(strides));
-    }
-}
-
-#endif
diff --git a/include/xtensor/xassign.hpp b/include/xtensor/xassign.hpp
deleted file mode 100644
index c1a77546f..000000000
--- a/include/xtensor/xassign.hpp
+++ /dev/null
@@ -1,846 +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 XTENSOR_ASSIGN_HPP
-#define XTENSOR_ASSIGN_HPP
-
-#include <algorithm>
-#include <type_traits>
-#include <utility>
-
-#include <xtl/xsequence.hpp>
-
-#include "xconcepts.hpp"
-#include "xexpression.hpp"
-#include "xiterator.hpp"
-#include "xstrides.hpp"
-#include "xtensor_forward.hpp"
-#include "xutils.hpp"
-#include "xfunction.hpp"
-
-#if defined(XTENSOR_USE_TBB)
-#include <tbb/tbb.h>
-#endif
-
-namespace xt
-{
-
-    /********************
-     * Assign functions *
-     ********************/
-
-    template <class E1, class E2>
-    void assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial);
-
-    template <class E1, class E2>
-    void assign_xexpression(xexpression<E1>& e1, const xexpression<E2>& e2);
-
-    template <class E1, class E2>
-    void computed_assign(xexpression<E1>& e1, const xexpression<E2>& e2);
-
-    template <class E1, class E2, class F>
-    void scalar_computed_assign(xexpression<E1>& e1, const E2& e2, F&& f);
-
-    template <class E1, class E2>
-    void assert_compatible_shape(const xexpression<E1>& e1, const xexpression<E2>& e2);
-
-    template <class E1, class E2>
-    void strided_assign(E1& e1, const E2& e2, std::false_type /*disable*/);
-
-    template <class E1, class E2>
-    void strided_assign(E1& e1, const E2& e2, std::true_type /*enable*/);
-
-    /************************
-     * xexpression_assigner *
-     ************************/
-
-    template <class Tag>
-    class xexpression_assigner_base;
-
-    template <>
-    class xexpression_assigner_base<xtensor_expression_tag>
-    {
-    public:
-
-        template <class E1, class E2>
-        static void assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial);
-    };
-
-    template <class Tag>
-    class xexpression_assigner : public xexpression_assigner_base<Tag>
-    {
-    public:
-
-        using base_type = xexpression_assigner_base<Tag>;
-
-        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);
-
-    private:
-
-        template <class E1, class E2>
-        static bool resize(E1& e1, const E2& e2);
-
-        template <class E1, class F, class... CT>
-        static bool resize(E1& e1, const xfunction<F, CT...>& e2);
-
-    };
-
-    /********************
-     * stepper_assigner *
-     ********************/
-
-    template <class E1, class E2, layout_type L>
-    class stepper_assigner
-    {
-    public:
-
-        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;
-
-        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);
-
-    private:
-
-        E1& m_e1;
-
-        lhs_iterator m_lhs;
-        rhs_iterator m_rhs;
-
-        index_type m_index;
-    };
-
-    /*******************
-     * linear_assigner *
-     *******************/
-
-    template <bool simd_assign>
-    class linear_assigner
-    {
-    public:
-
-        template <class E1, class E2>
-        static void run(E1& e1, const E2& e2);
-    };
-
-    template <>
-    class linear_assigner<false>
-    {
-    public:
-
-        template <class E1, class E2>
-        static void run(E1& e1, const E2& e2);
-
-    private:
-
-        template <class E1, class E2>
-        static void run_impl(E1& e1, const E2& e2, std::true_type);
-
-        template <class E1, class E2>
-        static void run_impl(E1& e1, const E2& e2, std::false_type);
-    };
-
-    /*************************
-     * strided_loop_assigner *
-     *************************/
-
-    template <bool simd>
-    class strided_loop_assigner
-    {
-    public:
-
-        template <class E1, class E2>
-        static void run(E1& e1, const E2& e2);
-    };
-
-    /***********************************
-     * Assign functions implementation *
-     ***********************************/
-
-    template <class E1, class E2>
-    inline void assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
-    {
-        using tag = xexpression_tag_t<E1, E2>;
-        xexpression_assigner<tag>::assign_data(e1, e2, trivial);
-    }
-
-    template <class E1, class E2>
-    inline void assign_xexpression(xexpression<E1>& e1, const xexpression<E2>& e2)
-    {
-        xtl::mpl::static_if<has_assign_to<E1, E2>::value>([&](auto self)
-        {
-            self(e2).derived_cast().assign_to(e1);
-        }, /*else*/ [&](auto /*self*/)
-        {
-            using tag = xexpression_tag_t<E1, E2>;
-            xexpression_assigner<tag>::assign_xexpression(e1, e2);
-        });
-    }
-
-    template <class E1, class E2>
-    inline void computed_assign(xexpression<E1>& e1, const xexpression<E2>& e2)
-    {
-        using tag = xexpression_tag_t<E1, E2>;
-        xexpression_assigner<tag>::computed_assign(e1, e2);
-    }
-
-    template <class E1, class E2, class F>
-    inline void scalar_computed_assign(xexpression<E1>& e1, const E2& e2, F&& f)
-    {
-        using tag = xexpression_tag_t<E1, E2>;
-        xexpression_assigner<tag>::scalar_computed_assign(e1, e2, std::forward<F>(f));
-    }
-
-    template <class E1, class E2>
-    inline void assert_compatible_shape(const xexpression<E1>& e1, const xexpression<E2>& e2)
-    {
-        using tag = xexpression_tag_t<E1, E2>;
-        xexpression_assigner<tag>::assert_compatible_shape(e1, e2);
-    }
-
-    /***************************************
-     * xexpression_assigner implementation *
-     ***************************************/
-
-    namespace detail
-    {
-        template <class E1, class E2>
-        constexpr bool linear_static_layout()
-        {
-            // A row_major or column_major container with a dimension <= 1 is computed as
-            // layout any, leading to some performance improvements, for example when
-            // assigning a col-major vector to a row-major vector etc
-            return compute_layout(select_layout<E1::static_layout, typename E1::shape_type>::value,
-                                  select_layout<E2::static_layout, typename E2::shape_type>::value) != layout_type::dynamic;
-        }
-
-        template <class E1, class E2>
-        inline bool is_linear_assign(const E1& e1, const E2& e2)
-        {
-            return (E1::contiguous_layout && E2::contiguous_layout && linear_static_layout<E1, E2>()) ||
-                   (e1.layout() != layout_type::dynamic && e2.has_linear_assign(e1.strides()));
-        }
-
-        template <class E, class = void>
-        struct has_step_leading : std::false_type
-        {
-        };
-
-        template <class E>
-        struct has_step_leading<E, void_t<decltype(std::declval<E>().step_leading())>>
-            : std::true_type
-        {
-        };
-
-        template <class T>
-        struct use_strided_loop
-        {
-            static constexpr bool stepper_deref() { return std::is_reference<typename T::stepper::reference>::value; }
-            static constexpr bool value = has_strides<T>::value && has_step_leading<typename T::stepper>::value && stepper_deref();
-        };
-
-        template <class T>
-        struct use_strided_loop<xscalar<T>>
-        {
-            static constexpr bool value = true;
-        };
-
-        template <class F, class... CT>
-        struct use_strided_loop<xfunction<F, CT...>>
-        {
-            using simd_arg_type = typename xfunction<F, CT...>::simd_argument_type;
-            static constexpr bool value = xtl::conjunction<use_strided_loop<std::decay_t<CT>>...>::value &&
-                                          xfunction<F, CT...>::has_simd_interface::value;
-        };
-    }
-
-    template <class E1, class E2>
-    struct xassign_traits
-    {
-        // constexpr methods instead of constexpr data members avoid the need of difinitions at namespace
-        // scope of these data members (since they are odr-used).
-        static constexpr bool contiguous_layout() { return E1::contiguous_layout && E2::contiguous_layout; }
-        static constexpr bool convertible_types() { return std::is_convertible<typename E2::value_type, typename E1::value_type>::value; }
-        static constexpr bool lhs_simd_size() { return xsimd::simd_traits<typename E1::value_type>::size > 1; }
-        static constexpr bool rhs_simd_size() { return xsimd::simd_traits<typename E2::value_type>::size > 1; }
-        static constexpr bool simd_size() { return lhs_simd_size() && rhs_simd_size(); }
-        static constexpr bool forbid_simd() { return !has_simd_interface<E2>::value; }
-        static constexpr bool simd_assign() { return contiguous_layout() && convertible_types() && simd_size() && has_simd_interface<E2>::value; }
-        static constexpr bool simd_strided_loop() { return convertible_types() && simd_size() &&
-                                                           detail::use_strided_loop<E2>::value &&
-                                                           detail::use_strided_loop<E1>::value; }
-    };
-
-    template <class E1, class E2>
-    inline void xexpression_assigner_base<xtensor_expression_tag>::assign_data(xexpression<E1>& e1, const xexpression<E2>& e2, bool trivial)
-    {
-        E1& de1 = e1.derived_cast();
-        const E2& de2 = e2.derived_cast();
-
-        bool linear_assign = trivial && detail::is_linear_assign(de1, de2);
-        constexpr bool simd_assign = xassign_traits<E1, E2>::simd_assign();
-        constexpr bool strided_simd_assign = xassign_traits<E1, E2>::simd_strided_loop();
-        if (linear_assign)
-        {
-            linear_assigner<simd_assign>::run(de1, de2);
-        }
-        else if (strided_simd_assign)
-        {
-            strided_loop_assigner<strided_simd_assign>::run(de1, de2);
-        }
-        else
-        {
-            stepper_assigner<E1, E2, default_assignable_layout(E1::static_layout)> assigner(de1, de2);
-            assigner.run();
-        }
-    }
-
-    template <class Tag>
-    template <class E1, class E2>
-    inline void xexpression_assigner<Tag>::assign_xexpression(E1& e1, const E2& e2)
-    {
-        bool trivial_broadcast = resize(e1.derived_cast(), e2.derived_cast());
-        base_type::assign_data(e1, e2, trivial_broadcast);
-    }
-
-    template <class Tag>
-    template <class E1, class E2>
-    inline void xexpression_assigner<Tag>::computed_assign(xexpression<E1>& e1, const xexpression<E2>& e2)
-    {
-        using shape_type = typename E1::shape_type;
-        using size_type = typename E1::size_type;
-
-        E1& de1 = e1.derived_cast();
-        const E2& de2 = e2.derived_cast();
-
-        size_type dim = de2.dimension();
-        shape_type shape = xtl::make_sequence<shape_type>(dim, size_type(0));
-        bool trivial_broadcast = de2.broadcast_shape(shape, true);
-
-        if (dim > de1.dimension() || shape > de1.shape())
-        {
-            typename E1::temporary_type tmp(shape);
-            base_type::assign_data(tmp, e2, trivial_broadcast);
-            de1.assign_temporary(std::move(tmp));
-        }
-        else
-        {
-            base_type::assign_data(e1, e2, trivial_broadcast);
-        }
-    }
-
-    template <class Tag>
-    template <class E1, class E2, class F>
-    inline void xexpression_assigner<Tag>::scalar_computed_assign(xexpression<E1>& e1, const E2& e2, F&& f)
-    {
-        E1& d = e1.derived_cast();
-        using size_type = typename E1::size_type;
-        auto dst = d.storage().begin();
-        for (size_type i = d.size(); i > 0; --i)
-        {
-            *dst = f(*dst, e2);
-            ++dst;
-        }
-    }
-
-    template <class Tag>
-    template <class E1, class E2>
-    inline void xexpression_assigner<Tag>::assert_compatible_shape(const xexpression<E1>& e1, const xexpression<E2>& e2)
-    {
-        const E1& de1 = e1.derived_cast();
-        const E2& de2 = e2.derived_cast();
-        if (!broadcastable(de2.shape(), de1.shape()))
-        {
-            throw_broadcast_error(de2.shape(), de1.shape());
-        }
-    }
-
-    namespace detail
-    {
-        template <bool B, class... CT>
-        struct static_trivial_broadcast;
-
-        template <class... CT>
-        struct static_trivial_broadcast<true, CT...>
-        {
-            static constexpr bool value = detail::promote_index<typename std::decay_t<CT>::shape_type...>::value;
-        };
-
-        template <class... CT>
-        struct static_trivial_broadcast<false, CT...>
-        {
-            static constexpr bool value = false;
-        };
-    }
-
-    template <class Tag>
-    template <class E1, class E2>
-    inline bool xexpression_assigner<Tag>::resize(E1& e1, const E2& e2)
-    {
-        // If our RHS is not a xfunction, we know that the RHS is at least potentially trivial
-        // We check the strides of the RHS in detail::is_trivial_broadcast to see if they match up!
-        // So we can skip a shape copy and a call to broadcast_shape(...)
-        e1.resize(e2.shape());
-        return true;
-    }
-
-    template <class Tag>
-    template <class E1, class F, class... CT>
-    inline bool xexpression_assigner<Tag>::resize(E1& e1, const xfunction<F, CT...>& e2)
-    {
-        return xtl::mpl::static_if<detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value>(
-            [&](auto /*self*/) {
-                /*
-                 * If the shape of the xfunction is statically known, we can compute the broadcast triviality
-                 * at compile time plus we can resize right away.
-                 */
-                // resize in case LHS is not a fixed size container. If it is, this is a NOP
-                e1.resize(typename xfunction<F, CT...>::shape_type{});
-                return detail::static_trivial_broadcast<detail::is_fixed<typename xfunction<F, CT...>::shape_type>::value, CT...>::value;
-            },
-            /* else */ [&](auto /*self*/)
-            {
-                using index_type = xindex_type_t<typename E1::shape_type>;
-                using size_type = typename E1::size_type;
-                size_type size = e2.dimension();
-                index_type shape = xtl::make_sequence<index_type>(size, size_type(0));
-                bool trivial_broadcast = e2.broadcast_shape(shape, true);
-                e1.resize(std::move(shape));
-                return trivial_broadcast;
-            }
-        );
-    }
-
-    /***********************************
-     * stepper_assigner implementation *
-     ***********************************/
-
-    template <class E1, class E2, layout_type L>
-    inline stepper_assigner<E1, E2, L>::stepper_assigner(E1& e1, const E2& e2)
-        : m_e1(e1), m_lhs(e1.stepper_begin(e1.shape())),
-          m_rhs(e2.stepper_begin(e1.shape())),
-          m_index(xtl::make_sequence<index_type>(e1.shape().size(), size_type(0)))
-    {
-    }
-
-    template <class E1, class E2, layout_type L>
-    inline void stepper_assigner<E1, E2, L>::run()
-    {
-        using size_type = typename E1::size_type;
-        using argument_type = std::decay_t<decltype(*m_rhs)>;
-        using result_type = std::decay_t<decltype(*m_lhs)>;
-        constexpr bool is_narrowing = is_narrowing_conversion<argument_type, result_type>::value;
-
-        size_type s = m_e1.size();
-        for (size_type i = 0; i < s; ++i)
-        {
-            *m_lhs = conditional_cast<is_narrowing, result_type>(*m_rhs);
-            stepper_tools<L>::increment_stepper(*this, m_index, m_e1.shape());
-        }
-    }
-
-    template <class E1, class E2, layout_type L>
-    inline void stepper_assigner<E1, E2, L>::step(size_type i)
-    {
-        m_lhs.step(i);
-        m_rhs.step(i);
-    }
-
-    template <class E1, class E2, layout_type L>
-    inline void stepper_assigner<E1, E2, L>::step(size_type i, size_type n)
-    {
-        m_lhs.step(i, n);
-        m_rhs.step(i, n);
-    }
-
-    template <class E1, class E2, layout_type L>
-    inline void stepper_assigner<E1, E2, L>::reset(size_type i)
-    {
-        m_lhs.reset(i);
-        m_rhs.reset(i);
-    }
-
-    template <class E1, class E2, layout_type L>
-    inline void stepper_assigner<E1, E2, L>::to_end(layout_type l)
-    {
-        m_lhs.to_end(l);
-        m_rhs.to_end(l);
-    }
-
-    /**********************************
-     * linear_assigner implementation *
-     **********************************/
-
-    template <bool simd_assign>
-    template <class E1, class E2>
-    inline void linear_assigner<simd_assign>::run(E1& e1, const E2& e2)
-    {
-        using lhs_align_mode = xsimd::container_alignment_t<E1>;
-        constexpr bool is_aligned = std::is_same<lhs_align_mode, aligned_mode>::value;
-        using rhs_align_mode = std::conditional_t<is_aligned, inner_aligned_mode, unaligned_mode>;
-        using value_type = std::common_type_t<typename E1::value_type, typename E2::value_type>;
-        using simd_type = xsimd::simd_type<value_type>;
-        using size_type = typename E1::size_type;
-        size_type size = e1.size();
-        constexpr size_type simd_size = simd_type::size;
-
-        size_type align_begin = is_aligned ? 0 : xsimd::get_alignment_offset(e1.data(), size, simd_size);
-        size_type align_end = align_begin + ((size - align_begin) & ~(simd_size - 1));
-
-        for (size_type i = 0; i < align_begin; ++i)
-        {
-            e1.data_element(i) = e2.data_element(i);
-        }
-
-        #if defined(XTENSOR_USE_TBB)
-        tbb::parallel_for(align_begin, align_end, simd_size, [&](size_t i)
-        {
-            e1.template store_simd<lhs_align_mode>(i, e2.template load_simd<rhs_align_mode, value_type>(i));
-        });
-        #else
-        for (size_type i = align_begin; i < align_end; i += simd_size)
-        {
-            e1.template store_simd<lhs_align_mode>(i, e2.template load_simd<rhs_align_mode, value_type>(i));
-        }
-        #endif
-        for (size_type i = align_end; i < size; ++i)
-        {
-            e1.data_element(i) = e2.data_element(i);
-        }
-    }
-
-    template <class E1, class E2>
-    inline void linear_assigner<false>::run(E1& e1, const E2& e2)
-    {
-        using is_convertible = std::is_convertible<typename std::decay_t<E2>::value_type,
-                                                   typename std::decay_t<E1>::value_type>;
-        // If the types are not compatible, this function is still instantiated but never called.
-        // To avoid compilation problems in effectively unused code trivial_assigner_run_impl is
-        // empty in this case.
-        run_impl(e1, e2, is_convertible());
-    }
-
-    template <class E1, class E2>
-    inline void linear_assigner<false>::run_impl(E1& e1, const E2& e2, std::true_type /*is_convertible*/)
-    {
-        using value_type = typename E1::value_type;
-        using size_type = typename E1::size_type;
-        auto src = detail::linear_begin(e2);
-        auto dst = detail::linear_begin(e1);
-        size_type n = e1.size();
-
-#if defined(XTENSOR_USE_TBB)
-        tbb::parallel_for(std::ptrdiff_t(0), static_cast<std::ptrdiff_t>(n), [&](std::ptrdiff_t i)
-        {
-            *(dst + i) = static_cast<value_type>(*(src + i));
-        });
-#else
-        for (; n > size_type(0); --n)
-        {
-            *dst = static_cast<value_type>(*src);
-            ++src;
-            ++dst;
-        }
-#endif
-    }
-
-    template <class E1, class E2>
-    inline void linear_assigner<false>::run_impl(E1&, const E2&, std::false_type /*is_convertible*/)
-    {
-        XTENSOR_PRECONDITION(false,
-            "Internal error: linear_assigner called with unrelated types.");
-
-    }
-
-    /****************************************
-     * strided_loop_assigner implementation *
-     ****************************************/
-
-    namespace strided_assign_detail
-    {
-        template <layout_type layout>
-        struct idx_tools;
-
-        template <>
-        struct idx_tools<layout_type::row_major>
-        {
-            template <class T>
-            static void next_idx(T& outer_index, T& outer_shape)
-            {
-                auto i = outer_index.size();
-                for (; i > 0; --i)
-                {
-                    if (outer_index[i - 1] + 1 >= outer_shape[i - 1])
-                    {
-                        outer_index[i - 1] = 0;
-                    }
-                    else
-                    {
-                        outer_index[i - 1]++;
-                        break;
-                    }
-                }
-            }
-        };
-
-        template <>
-        struct idx_tools<layout_type::column_major>
-        {
-            template <class T>
-            static void next_idx(T& outer_index, T& outer_shape)
-            {
-                using size_type = typename T::size_type;
-                size_type i = 0;
-                auto sz = outer_index.size();
-                for (; i < sz; ++i)
-                {
-                    if (outer_index[i] + 1 >= outer_shape[i])
-                    {
-                        outer_index[i] = 0;
-                    }
-                    else
-                    {
-                        outer_index[i]++;
-                        break;
-                    }
-                }
-            }
-        };
-
-        template <layout_type L, class S>
-        struct check_strides_functor
-        {
-            using strides_type = S;
-
-            check_strides_functor(const S& strides)
-                : m_cut(L == layout_type::row_major ? 0 : strides.size()),
-                  m_strides(strides)
-            {
-            }
-
-            template <class T, layout_type LE = L>
-            std::enable_if_t<LE == layout_type::row_major, std::size_t>
-            operator()(const T& el)
-            {
-                auto var = check_strides_overlap<layout_type::row_major>::get(m_strides, el.strides());
-                if (var > m_cut)
-                {
-                    m_cut = var;
-                }
-                return m_cut;
-            }
-
-            template <class T, layout_type LE = L>
-            std::enable_if_t<LE == layout_type::column_major, std::size_t>
-            operator()(const T& el)
-            {
-                auto var = check_strides_overlap<layout_type::column_major>::get(m_strides, el.strides());
-                if (var < m_cut)
-                {
-                    m_cut = var;
-                }
-                return m_cut;
-            }
-
-            template <class T>
-            std::size_t operator()(const xt::xscalar<T>& /*el*/)
-            {
-                return m_cut;
-            }
-
-            template <class F, class... CT>
-            std::size_t operator()(const xt::xfunction<F, CT...>& xf)
-            {
-                xt::for_each(*this, xf.arguments());
-                return m_cut;
-            }
-
-        private:
-
-            std::size_t m_cut;
-            const strides_type& m_strides;
-        };
-
-        template <class E1, class E2>
-        auto get_loop_sizes(const E1& e1, const E2& e2, bool is_row_major)
-        {
-            std::size_t cut = 0;
-
-            // TODO! if E1 is !contiguous --> initialize cut to sensible value!
-            if (E1::static_layout == layout_type::row_major || is_row_major)
-            {
-                auto csf = check_strides_functor<layout_type::row_major, decltype(e1.strides())>(e1.strides());
-                cut = csf(e2);
-            }
-            else if (E1::static_layout == layout_type::column_major || !is_row_major)
-            {
-                auto csf = check_strides_functor<layout_type::column_major, decltype(e1.strides())>(e1.strides());
-                cut = csf(e2);
-            } // can't reach here because this would have already triggered the fallback
-
-            using shape_value_type = typename E1::shape_type::value_type;
-            std::size_t outer_loop_size = static_cast<std::size_t>(
-                            std::accumulate(e1.shape().begin(), e1.shape().begin() + static_cast<std::ptrdiff_t>(cut),
-                                shape_value_type(1), std::multiplies<shape_value_type>{}));
-            std::size_t inner_loop_size = static_cast<std::size_t>(
-                            std::accumulate(e1.shape().begin() + static_cast<std::ptrdiff_t>(cut), e1.shape().end(),
-                                shape_value_type(1), std::multiplies<shape_value_type>{}));
-
-            if (E1::static_layout == layout_type::column_major || !is_row_major)
-            {
-                std::swap(outer_loop_size, inner_loop_size);
-            }
-
-            return std::make_tuple(inner_loop_size, outer_loop_size, cut);
-        }
-    }
-
-    template <bool simd>
-    template <class E1, class E2>
-    inline void strided_loop_assigner<simd>::run(E1& e1, const E2& e2)
-    {
-        bool is_row_major = true;
-        using fallback_assigner = stepper_assigner<E1, E2, default_assignable_layout(E1::static_layout)>;
-
-        if (E1::static_layout == layout_type::dynamic)
-        {
-            layout_type dynamic_layout = e1.layout();
-            switch (dynamic_layout)
-            {
-                case layout_type::row_major:
-                    is_row_major = true;
-                    break;
-                case layout_type::column_major:
-                    is_row_major = false;
-                    break;
-                default:
-                    return fallback_assigner(e1, e2).run();
-            }
-        }
-        else if (E1::static_layout == layout_type::row_major)
-        {
-            is_row_major = true;
-        }
-        else if (E1::static_layout == layout_type::column_major)
-        {
-            is_row_major = false;
-        }
-        else
-        {
-            throw std::runtime_error("Illegal layout set (layout_type::any?).");
-        }
-
-        std::size_t inner_loop_size, outer_loop_size, cut;
-        std::tie(inner_loop_size, outer_loop_size, cut) = strided_assign_detail::get_loop_sizes(e1, e2, is_row_major);
-
-        if ((is_row_major && cut == e1.dimension()) || (!is_row_major && cut == 0)) 
-        {
-            return fallback_assigner(e1, e2).run();
-        }
-
-        // TODO can we get rid of this and use `shape_type`?
-        dynamic_shape<std::size_t> idx, max_shape;
-
-        if (is_row_major)
-        {
-            xt::resize_container(idx, cut);
-            max_shape.assign(e1.shape().begin(), e1.shape().begin() + static_cast<std::ptrdiff_t>(cut));
-        }
-        else
-        {
-            xt::resize_container(idx, e1.shape().size() - cut);
-            max_shape.assign(e1.shape().begin() + static_cast<std::ptrdiff_t>(cut), e1.shape().end());
-        }
-
-        // add this when we have std::array index!
-        // std::fill(idx.begin(), idx.end(), 0);
-        using value_type = std::common_type_t<typename E1::value_type, typename E2::value_type>;
-        using simd_type = xsimd::simd_type<value_type>;
-
-        std::size_t simd_size = inner_loop_size / simd_type::size;
-        std::size_t simd_rest = inner_loop_size % simd_type::size;
-
-        auto fct_stepper = e2.stepper_begin(e1.shape());
-        auto res_stepper = e1.stepper_begin(e1.shape());
-
-        // TODO in 1D case this is ambigous -- could be RM or CM.
-        //      Use default layout to make decision
-        std::size_t step_dim = 0;
-        if (!is_row_major) // row major case
-        {
-            step_dim = cut;
-        }
-
-        for (std::size_t ox = 0; ox < outer_loop_size; ++ox)
-        {
-            for (std::size_t i = 0; i < simd_size; ++i)
-            {
-                res_stepper.template store_simd<simd_type>(fct_stepper.template step_simd<simd_type>());
-            }
-            for (std::size_t i = 0; i < simd_rest; ++i)
-            {
-                *(res_stepper) = *(fct_stepper);
-                res_stepper.step_leading();
-                fct_stepper.step_leading();
-            }
-
-            is_row_major ?
-                strided_assign_detail::idx_tools<layout_type::row_major>::next_idx(idx, max_shape) :
-                strided_assign_detail::idx_tools<layout_type::column_major>::next_idx(idx, max_shape);
-
-            fct_stepper.to_begin();
-
-            // need to step E1 as well if not contigous assign (e.g. view)
-            if (!E1::contiguous_layout)
-            {
-                res_stepper.to_begin();
-                for (std::size_t i = 0; i < idx.size(); ++i)
-                {
-                    fct_stepper.step(i + step_dim, idx[i]);
-                    res_stepper.step(i + step_dim, idx[i]);
-                }
-            }
-            else
-            {
-                for (std::size_t i = 0; i < idx.size(); ++i)
-                {
-                    fct_stepper.step(i + step_dim, idx[i]);
-                }
-            }
-        }
-    }
-
-    template <>
-    template <class E1, class E2>
-    inline void strided_loop_assigner<false>::run(E1& /*e1*/, const E2& /*e2*/)
-    {
-    }
-}
-
-#endif
diff --git a/include/xtensor/xaxis_iterator.hpp b/include/xtensor/xaxis_iterator.hpp
deleted file mode 100644
index e544791b8..000000000
--- a/include/xtensor/xaxis_iterator.hpp
+++ /dev/null
@@ -1,197 +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 XTENSOR_AXIS_ITERATOR_HPP
-#define XTENSOR_AXIS_ITERATOR_HPP
-
-#include <xtl/xclosure.hpp>
-
-#include "xview.hpp"
-
-namespace xt
-{
-
-    /******************
-     * xaxis_iterator *
-     ******************/
-
-    template <class CT>
-    class xaxis_iterator
-    {
-    public:
-
-        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 value_type = xview<CT, size_type>;
-        using reference = std::remove_reference_t<apply_cv_t<CT, value_type>>;
-        using pointer = xtl::xclosure_pointer<std::remove_reference_t<apply_cv_t<CT, value_type>>>;
-
-        using iterator_category = std::forward_iterator_tag;
-
-        xaxis_iterator();
-        template <class CTA>
-        xaxis_iterator(CTA&& e, size_type index);
-
-        self_type& operator++();
-        self_type operator++(int);
-
-        reference operator*() const;
-        pointer operator->() const;
-
-        bool equal(const self_type& rhs) const;
-
-    private:
-
-        using storing_type = xtl::ptr_closure_type_t<CT>;
-        mutable storing_type p_expression;
-        size_type m_index;
-
-        template <class T>
-        std::enable_if_t<std::is_pointer<T>::value, std::add_lvalue_reference_t<std::remove_pointer_t<T>>>
-        deref(T val) const;
-
-        template <class T>
-        std::enable_if_t<!std::is_pointer<T>::value, T>
-        deref(T& val) const;
-
-        template <class T, class CTA>
-        std::enable_if_t<std::is_pointer<T>::value, T>
-        get_storage_init(CTA&& e) const;
-
-        template <class T, class CTA>
-        std::enable_if_t<!std::is_pointer<T>::value, T>
-        get_storage_init(CTA&& e) const;
-    };
-
-    template <class CT>
-    bool operator==(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs);
-
-    template <class CT>
-    bool operator!=(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs);
-
-    template <class E>
-    auto axis_begin(E&& e);
-
-    template <class E>
-    auto axis_end(E&& e);
-
-    /*********************************
-     * xaxis_iterator implementation *
-     *********************************/
-
-    template <class CT>
-    template <class T>
-    inline std::enable_if_t<std::is_pointer<T>::value, std::add_lvalue_reference_t<std::remove_pointer_t<T>>>
-    xaxis_iterator<CT>::deref(T val) const
-    {
-        return *val;
-    }
-
-    template <class CT>
-    template <class T>
-    inline std::enable_if_t<!std::is_pointer<T>::value, T>
-    xaxis_iterator<CT>::deref(T& val) const
-    {
-        return val;
-    }
-
-    template <class CT>
-    template <class T, class CTA>
-    inline std::enable_if_t<std::is_pointer<T>::value, T>
-    xaxis_iterator<CT>::get_storage_init(CTA&& e) const
-    {
-        return &e;
-    }
-
-    template <class CT>
-    template <class T, class CTA>
-    inline std::enable_if_t<!std::is_pointer<T>::value, T>
-    xaxis_iterator<CT>::get_storage_init(CTA&& e) const
-    {
-        return e;
-    }
-
-    template <class CT>
-    inline xaxis_iterator<CT>::xaxis_iterator()
-        : p_expression(nullptr), m_index(0)
-    {
-    }
-
-    template <class CT>
-    template <class CTA>
-    inline xaxis_iterator<CT>::xaxis_iterator(CTA&& e, size_type index)
-        : p_expression(get_storage_init<storing_type>(std::forward<CTA>(e))), m_index(index)
-    {
-    }
-
-    template <class CT>
-    inline auto xaxis_iterator<CT>::operator++() -> self_type&
-    {
-        ++m_index;
-        return *this;
-    }
-
-    template <class CT>
-    inline auto xaxis_iterator<CT>::operator++(int) -> self_type
-    {
-        self_type tmp(*this);
-        ++(*this);
-        return tmp;
-    }
-
-    template <class CT>
-    inline auto xaxis_iterator<CT>::operator*() const -> reference
-    {
-        return view(deref(p_expression), size_type(m_index));
-    }
-
-    template <class CT>
-    inline auto xaxis_iterator<CT>::operator->() const -> pointer
-    {
-        return xtl::closure_pointer(operator*());
-    }
-
-    template <class CT>
-    inline bool xaxis_iterator<CT>::equal(const self_type& rhs) const
-    {
-        return p_expression == rhs.p_expression && m_index == rhs.m_index;
-    }
-
-    template <class CT>
-    inline bool operator==(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs)
-    {
-        return lhs.equal(rhs);
-    }
-
-    template <class CT>
-    inline bool operator!=(const xaxis_iterator<CT>& lhs, const xaxis_iterator<CT>& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-    template <class E>
-    inline auto axis_begin(E&& e)
-    {
-        using return_type = xaxis_iterator<xtl::closure_type_t<E>>;
-        using size_type = typename std::decay_t<E>::size_type;
-        return return_type(std::forward<E>(e), size_type(0));
-    }
-
-    template <class E>
-    inline auto axis_end(E&& e)
-    {
-        using return_type = xaxis_iterator<xtl::closure_type_t<E>>;
-        using size_type = typename std::decay_t<E>::size_type;
-        return return_type(std::forward<E>(e), size_type(e.shape()[0]));
-    }
-}
-
-#endif
diff --git a/include/xtensor/xbuffer_adaptor.hpp b/include/xtensor/xbuffer_adaptor.hpp
deleted file mode 100644
index 081567ee4..000000000
--- a/include/xtensor/xbuffer_adaptor.hpp
+++ /dev/null
@@ -1,622 +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 XTENSOR_BUFFER_ADAPTOR_HPP
-#define XTENSOR_BUFFER_ADAPTOR_HPP
-
-#include <algorithm>
-#include <functional>
-#include <iterator>
-#include <memory>
-#include <stdexcept>
-
-#include <xtl/xclosure.hpp>
-
-#include "xstorage.hpp"
-
-namespace xt
-{
-    /******************************
-     * xbuffer_adator declaration *
-     ******************************/
-
-    struct no_ownership
-    {
-    };
-
-    struct acquire_ownership
-    {
-    };
-
-    template <class CP, class O = no_ownership, class A = std::allocator<std::remove_pointer_t<std::remove_reference_t<CP>>>>
-    class xbuffer_adaptor;
-
-    /*********************************
-     * xbuffer_adator implementation *
-     *********************************/
-
-    namespace detail
-    {
-        template <class CP, class A>
-        class xbuffer_storage
-        {
-        public:
-
-            using self_type = xbuffer_storage<CP, A>;
-            using allocator_type = A;
-            using value_type = typename allocator_type::value_type;
-            using reference = std::conditional_t<std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
-                                  typename allocator_type::const_reference,
-                                  typename allocator_type::reference>;
-            using const_reference = typename allocator_type::const_reference;
-            using pointer = std::conditional_t<std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
-                                  typename allocator_type::const_pointer,
-                                  typename allocator_type::pointer>;
-            using const_pointer = typename allocator_type::const_pointer;
-            using size_type = typename allocator_type::size_type;
-            using difference_type = typename allocator_type::difference_type;
-
-            xbuffer_storage();
-
-            template <class P>
-            xbuffer_storage(P&& data, size_type size, const allocator_type& alloc = allocator_type());
-
-            size_type size() const noexcept;
-            void resize(size_type size);
-
-            pointer data() noexcept;
-            const_pointer data() const noexcept;
-
-            void swap(self_type& rhs) noexcept;
-
-        private:
-
-            pointer p_data;
-            size_type m_size;
-        };
-
-        template <class CP, class A>
-        class xbuffer_owner_storage
-        {
-        public:
-
-            using self_type = xbuffer_owner_storage<CP, A>;
-            using allocator_type = A;
-            using value_type = typename allocator_type::value_type;
-            using reference = std::conditional_t<std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
-                                  typename allocator_type::const_reference,
-                                  typename allocator_type::reference>;
-            using const_reference = typename allocator_type::const_reference;
-            using pointer = std::conditional_t<std::is_const<std::remove_pointer_t<std::remove_reference_t<CP>>>::value,
-                                  typename allocator_type::const_pointer,
-                                  typename allocator_type::pointer>;
-            using const_pointer = typename allocator_type::const_pointer;
-            using size_type = typename allocator_type::size_type;
-            using difference_type = typename allocator_type::difference_type;
-
-            xbuffer_owner_storage() = default;
-
-            template <class P>
-            xbuffer_owner_storage(P&& data, size_type size, const allocator_type& alloc = allocator_type());
-
-            ~xbuffer_owner_storage();
-
-            xbuffer_owner_storage(const self_type&) = delete;
-            self_type& operator=(const self_type&);
-
-            xbuffer_owner_storage(self_type&&);
-            self_type& operator=(self_type&&);
-
-            size_type size() const noexcept;
-            void resize(size_type size);
-
-            pointer data() noexcept;
-            const_pointer data() const noexcept;
-
-            allocator_type get_allocator() const noexcept;
-
-            void swap(self_type& rhs) noexcept;
-
-        private:
-
-            xtl::xclosure_wrapper<CP> m_data;
-            size_type m_size;
-            bool m_moved_from;
-            allocator_type m_allocator;
-        };
-
-        template <class CP, class A, class O>
-        struct get_buffer_storage
-        {
-            using type = xbuffer_storage<CP, A>;
-        };
-
-        template <class CP, class A>
-        struct get_buffer_storage<CP, A, acquire_ownership>
-        {
-            using type = xbuffer_owner_storage<CP, A>;
-        };
-
-        template <class CP, class A, class O>
-        using buffer_storage_t = typename get_buffer_storage<CP, A, O>::type;
-    }
-
-    template <class CP, class O, class A>
-    class xbuffer_adaptor : private detail::buffer_storage_t<CP, A, O>
-    {
-    public:
-
-        using base_type = detail::buffer_storage_t<CP, A, O>;
-        using self_type = xbuffer_adaptor<CP, O, A>;
-        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 temporary_type = uvector<value_type, allocator_type>;
-
-        using size_type = typename base_type::size_type;
-        using difference_type = typename base_type::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>;
-
-        xbuffer_adaptor() = default;
-
-        template <class P>
-        xbuffer_adaptor(P&& data, size_type size, const allocator_type& alloc = allocator_type());
-
-        ~xbuffer_adaptor() = default;
-
-        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&&);
-
-        bool empty() const noexcept;
-        using base_type::size;
-        using base_type::resize;
-
-        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();
-        iterator end();
-
-        const_iterator begin() const;
-        const_iterator end() const;
-        const_iterator cbegin() const;
-        const_iterator cend() const;
-
-        reverse_iterator rbegin();
-        reverse_iterator rend();
-
-        const_reverse_iterator rbegin() const;
-        const_reverse_iterator rend() const;
-        const_reverse_iterator crbegin() const;
-        const_reverse_iterator crend() const;
-
-        using base_type::data;
-        using base_type::swap;
-    };
-
-    template <class CP, class O, class A>
-    bool operator==(const xbuffer_adaptor<CP, O, A>& lhs,
-                    const xbuffer_adaptor<CP, O, A>& rhs);
-
-    template <class CP, class O, class A>
-    bool operator!=(const xbuffer_adaptor<CP, O, A>& lhs,
-                    const xbuffer_adaptor<CP, O, A>& rhs);
-
-    template <class CP, class O, class A>
-    bool operator<(const xbuffer_adaptor<CP, O, A>& lhs,
-                   const xbuffer_adaptor<CP, O, A>& rhs);
-
-    template <class CP, class O, class A>
-    bool operator<=(const xbuffer_adaptor<CP, O, A>& lhs,
-                    const xbuffer_adaptor<CP, O, A>& rhs);
-
-    template <class CP, class O, class A>
-    bool operator>(const xbuffer_adaptor<CP, O, A>& lhs,
-                   const xbuffer_adaptor<CP, O, A>& rhs);
-
-    template <class CP, class O, class A>
-    bool operator>=(const xbuffer_adaptor<CP, O, A>& lhs,
-                    const xbuffer_adaptor<CP, O, A>& rhs);
-
-    template <class CP, class O, class A>
-    void swap(xbuffer_adaptor<CP, O, A>& lhs,
-              xbuffer_adaptor<CP, O, A>& rhs) noexcept;
-
-    /************************************
-     * temporary_container metafunction *
-     ************************************/
-
-    template <class C>
-    struct temporary_container
-    {
-        using type = C;
-    };
-
-    template <class CP, class O, class A>
-    struct temporary_container<xbuffer_adaptor<CP, O, A>>
-    {
-        using type = typename xbuffer_adaptor<CP, O, A>::temporary_type;
-    };
-
-    template <class C>
-    using temporary_container_t = typename temporary_container<C>::type;
-
-    /**********************************
-     * xbuffer_storage implementation *
-     **********************************/
-
-    namespace detail
-    {
-        template <class CP, class A>
-        inline xbuffer_storage<CP, A>::xbuffer_storage()
-            : p_data(nullptr), m_size(0)
-        {
-        }
-
-        template <class CP, class A>
-        template <class P>
-        inline xbuffer_storage<CP, A>::xbuffer_storage(P&& data, size_type size, const allocator_type&)
-            : p_data(std::forward<P>(data)), m_size(size)
-        {
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_storage<CP, A>::size() const noexcept -> size_type
-        {
-            return m_size;
-        }
-
-        template <class CP, class A>
-        inline void xbuffer_storage<CP, A>::resize(size_type size)
-        {
-            if (size != m_size)
-            {
-                throw std::runtime_error("xbuffer_storage not resizable");
-            }
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_storage<CP, A>::data() noexcept -> pointer
-        {
-            return p_data;
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_storage<CP, A>::data() const noexcept -> const_pointer
-        {
-            return p_data;
-        }
-
-        template <class CP, class A>
-        inline void xbuffer_storage<CP, A>::swap(self_type& rhs) noexcept
-        {
-            using std::swap;
-            swap(p_data, rhs.p_data);
-            swap(m_size, rhs.m_size);
-        }
-    }
-
-    /****************************************
-     * xbuffer_owner_storage implementation *
-     ****************************************/
-
-    namespace detail
-    {
-        template <class CP, class A>
-        template <class P>
-        inline xbuffer_owner_storage<CP, A>::xbuffer_owner_storage(P&& data, size_type size, const allocator_type& alloc)
-            : m_data(std::forward<P>(data)), m_size(size), m_moved_from(false), m_allocator(alloc)
-        {
-        }
-
-        template <class CP, class A>
-        inline xbuffer_owner_storage<CP, A>::~xbuffer_owner_storage()
-        {
-            if (!m_moved_from)
-            {
-                safe_destroy_deallocate(m_allocator, m_data.get(), m_size);
-                m_size = 0;
-            }
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_owner_storage<CP, A>::operator=(const self_type& rhs) -> self_type&
-        {
-            using std::swap;
-            if (this != &rhs)
-            {
-                allocator_type al = std::allocator_traits<allocator_type>::select_on_container_copy_construction(rhs.get_allocator());
-                pointer tmp = safe_init_allocate(al, rhs.m_size);
-                if (xtrivially_default_constructible<value_type>::value)
-                {
-                    std::uninitialized_copy(rhs.m_data.get(), rhs.m_data.get() + rhs.m_size, tmp);
-                }
-                else
-                {
-                    std::copy(rhs.m_data.get(), rhs.m_data.get() + rhs.m_size, tmp);
-                }
-                swap(m_data.get(), tmp);
-                m_size = rhs.m_size;
-                swap(m_allocator, al);
-                safe_destroy_deallocate(al, tmp, m_size);
-            }
-            return *this;
-        }
-
-        template <class CP, class A>
-        inline xbuffer_owner_storage<CP, A>::xbuffer_owner_storage(self_type&& rhs)
-            : m_data(std::move(rhs.m_data)), m_size(std::move(rhs.m_size)), m_moved_from(std::move(rhs.m_moved_from)), m_allocator(std::move(rhs.m_allocator))
-        {
-            rhs.m_moved_from = true;
-            rhs.m_size = 0;
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_owner_storage<CP, A>::operator=(self_type&& rhs) -> self_type&
-        {
-            swap(rhs);
-            return *this;
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_owner_storage<CP, A>::size() const noexcept -> size_type
-        {
-            return m_size;
-        }
-
-        template <class CP, class A>
-        void xbuffer_owner_storage<CP, A>::resize(size_type size)
-        {
-            using std::swap;
-            if (size != m_size)
-            {
-                pointer tmp = safe_init_allocate(m_allocator, size);
-                swap(m_data.get(), tmp);
-                swap(m_size, size);
-                safe_destroy_deallocate(m_allocator, tmp, size);
-            }
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_owner_storage<CP, A>::data() noexcept -> pointer
-        {
-            return m_data.get();
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_owner_storage<CP, A>::data() const noexcept -> const_pointer
-        {
-            return m_data.get();
-        }
-
-        template <class CP, class A>
-        inline auto xbuffer_owner_storage<CP, A>::get_allocator() const noexcept -> allocator_type
-        {
-            return allocator_type(m_allocator);
-        }
-
-        template <class CP, class A>
-        inline void xbuffer_owner_storage<CP, A>::swap(self_type& rhs) noexcept
-        {
-            using std::swap;
-            swap(m_data, rhs.m_data);
-            swap(m_size, rhs.m_size);
-            swap(m_allocator, rhs.m_allocator);
-        }
-    }
-
-    /**********************************
-     * xbuffer_adaptor implementation *
-     **********************************/
-
-    template <class CP, class O, class A>
-    template <class P>
-    inline xbuffer_adaptor<CP, O, A>::xbuffer_adaptor(P&& data, size_type size, const allocator_type& alloc)
-        : base_type(std::forward<P>(data), size, alloc)
-    {
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::operator=(temporary_type&& tmp) -> self_type&
-    {
-        base_type::resize(tmp.size());
-        std::copy(tmp.cbegin(), tmp.cend(), begin());
-        return *this;
-    }
-
-    template <class CP, class O, class A>
-    bool xbuffer_adaptor<CP, O, A>::empty() const noexcept
-    {
-        return size() == 0;
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::operator[](size_type i) -> reference
-    {
-        return data()[i];
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::operator[](size_type i) const -> const_reference
-    {
-        return data()[i];
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::front() -> reference
-    {
-        return data()[0];
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::front() const -> const_reference
-    {
-        return data()[0];
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::back() -> reference
-    {
-        return data()[size() - 1];
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::back() const -> const_reference
-    {
-        return data()[size() - 1];
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::begin() -> iterator
-    {
-        return data();
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::end() -> iterator
-    {
-        return data() + size();
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::begin() const -> const_iterator
-    {
-        return data();
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::end() const -> const_iterator
-    {
-        return data() + size();
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::cbegin() const -> const_iterator
-    {
-        return begin();
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::cend() const -> const_iterator
-    {
-        return end();
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::rbegin() -> reverse_iterator
-    {
-        return reverse_iterator(end());
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::rend() -> reverse_iterator
-    {
-        return reverse_iterator(begin());
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::rbegin() const -> const_reverse_iterator
-    {
-        return const_reverse_iterator(end());
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::rend() const -> const_reverse_iterator
-    {
-        return const_reverse_iterator(begin());
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::crbegin() const -> const_reverse_iterator
-    {
-        return rbegin();
-    }
-
-    template <class CP, class O, class A>
-    inline auto xbuffer_adaptor<CP, O, A>::crend() const -> const_reverse_iterator
-    {
-        return rend();
-    }
-
-    template <class CP, class O, class A>
-    inline bool operator==(const xbuffer_adaptor<CP, O, A>& lhs,
-                           const xbuffer_adaptor<CP, O, A>& rhs)
-    {
-        return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
-    }
-
-    template <class CP, class O, class A>
-    inline bool operator!=(const xbuffer_adaptor<CP, O, A>& lhs,
-                           const xbuffer_adaptor<CP, O, A>& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-    template <class CP, class O, class A>
-    inline bool operator<(const xbuffer_adaptor<CP, O, A>& lhs,
-                          const xbuffer_adaptor<CP, O, A>& rhs)
-    {
-        return std::lexicographical_compare(lhs.begin(), lhs.end(),
-                                            rhs.begin(), rhs.end(),
-                                            std::less<typename A::value_type>());
-    }
-
-    template <class CP, class O, class A>
-    inline bool operator<=(const xbuffer_adaptor<CP, O, A>& lhs,
-                           const xbuffer_adaptor<CP, O, A>& rhs)
-    {
-        return std::lexicographical_compare(lhs.begin(), lhs.end(),
-                                            rhs.begin(), rhs.end(),
-                                            std::less_equal<typename A::value_type>());
-    }
-
-    template <class CP, class O, class A>
-    inline bool operator>(const xbuffer_adaptor<CP, O, A>& lhs,
-                          const xbuffer_adaptor<CP, O, A>& rhs)
-    {
-        return std::lexicographical_compare(lhs.begin(), lhs.end(),
-                                            rhs.begin(), rhs.end(),
-                                            std::greater<typename A::value_type>());
-    }
-
-    template <class CP, class O, class A>
-    inline bool operator>=(const xbuffer_adaptor<CP, O, A>& lhs,
-                           const xbuffer_adaptor<CP, O, A>& rhs)
-    {
-        return std::lexicographical_compare(lhs.begin(), lhs.end(),
-                                            rhs.begin(), rhs.end(),
-                                            std::greater_equal<typename A::value_type>());
-    }
-
-    template <class CP, class O, class A>
-    inline void swap(xbuffer_adaptor<CP, O, A>& lhs,
-                     xbuffer_adaptor<CP, O, A>& rhs) noexcept
-    {
-        lhs.swap(rhs);
-    }
-}
-
-#endif
diff --git a/include/xtensor/xconcepts.hpp b/include/xtensor/xconcepts.hpp
deleted file mode 100644
index 1845c6b03..000000000
--- a/include/xtensor/xconcepts.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/***************************************************************************
-* Copyright (c) 2017, Ullrich Koethe                                       *
-*                                                                          *
-* Distributed under the terms of the BSD 3-Clause License.                 *
-*                                                                          *
-* The full license is in the file LICENSE, distributed with this software. *
-****************************************************************************/
-
-#ifndef XTENSOR_CONCEPTS_HPP
-#define XTENSOR_CONCEPTS_HPP
-
-#include <type_traits>
-
-/*****************************************************
- * concept checking and type inference functionality *
- *****************************************************/
-
-namespace xt
-{
-
-    /******************************************
-     * XTENSOR_REQUIRE concept checking macro *
-     ******************************************/
-
-    struct concept_check_successful
-    {
-    };
-
-    template <bool CONCEPTS>
-    using concept_check = typename std::enable_if<CONCEPTS, concept_check_successful>::type;
-
-        /** @brief Concept checking macro (more readable than sfinae).
-
-            The macro is used as the last argument in a template declaration.
-            It must be followed by a static boolean expression in angle brackets.
-            The template will only be included in overload resolution when
-            this expression evaluates to 'true'.
-
-            Example:
-            \code
-            template <class T,
-                      XTENSOR_REQUIRE<std::is_arithmetic<T>::value>>
-            T foo(T t)
-            {...}
-            \endcode
-        */
-    #define XTENSOR_REQUIRE typename = concept_check
-
-    /********************
-     * iterator_concept *
-     ********************/
-
-        /** @brief Traits class to check if a type is an iterator.
-
-            This is useful in concept checking to make sure that a given template
-            is only instantiated when the argument is an iterator.
-            Currently, we apply the simple rule that class @tparam T
-            is either a pointer or a C-array or has an embedded typedef
-            'iterator_category'. More sophisticated checks can easily
-            be added when needed.
-
-            If @tparam T is indeed an iterator, the class' <tt>value</tt> member
-            is <tt>true</tt>:
-            \code
-            template <class T,
-                      XTENSOR_REQUIRE<iterator_concept<T>::value>>
-            T foo(T t)
-            {...}
-            \endcode
-        */
-    template <class T>
-    struct iterator_concept
-    {
-        using V = std::decay_t<T>;
-
-        static char test(...);
-
-        template <class U>
-        static int test(U*, typename U::iterator_category* = 0);
-
-        static const bool value =
-            std::is_array<T>::value ||
-            std::is_pointer<T>::value ||
-            std::is_same<decltype(test(std::declval<V*>())), int>::value;
-    };
-
-        /** @brief Check if a conversion may loose information.
-
-            @tparam FROM source type
-            @tparam TO target type
-
-            When data is converted from a big type (e.g. <tt>int64_t</tt> or <tt>double</tt>)
-            to a smaller type (e.g. <tt>int32_t</tt>), most compilers issue a 'possible loss of data'
-            warning. This metafunction allows you to detect these situations and take appropriate
-            actions.
-
-            If loss of data may occur, member <tt>is_narrowing_conversion::value</tt> is true. Currently,
-            the check is only implemented for built-in types, i.e. types where <tt>std::is_arithmetic</tt>
-            is true.
-        */
-    template <class FROM, class TO>
-    struct is_narrowing_conversion
-    {
-        using argument_type = std::decay_t<FROM>;
-        using result_type = std::decay_t<TO>;
-
-        static const bool value = std::is_arithmetic<result_type>::value &&
-            (sizeof(result_type) < sizeof(argument_type) ||
-             (std::is_integral<result_type>::value && std::is_floating_point<argument_type>::value));
-    };
-}  // namespace xt
-
-#endif  // XCONCEPTS_HPP
diff --git a/include/xtensor/xcsv.hpp b/include/xtensor/xcsv.hpp
deleted file mode 100644
index 4a2716d40..000000000
--- a/include/xtensor/xcsv.hpp
+++ /dev/null
@@ -1,169 +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 XTENSOR_CSV_HPP
-#define XTENSOR_CSV_HPP
-
-#include <exception>
-#include <istream>
-#include <iterator>
-#include <sstream>
-#include <string>
-#include <utility>
-
-#include "xtensor.hpp"
-
-namespace xt
-{
-
-    /**************************************
-     * load_csv and dump_csv declarations *
-     **************************************/
-
-    template <class T, class A = std::allocator<T>>
-    using xcsv_tensor = xtensor_container<std::vector<T, A>, 2, layout_type::row_major>;
-
-    template <class T, class A = std::allocator<T>>
-    xcsv_tensor<T, A> load_csv(std::istream& stream);
-
-    template <class E>
-    void dump_csv(std::ostream& stream, const xexpression<E>& e);
-
-    /*****************************************
-     * load_csv and dump_csv implementations *
-     *****************************************/
-
-    namespace detail
-    {
-        template <class T>
-        inline T lexical_cast(const std::string& cell)
-        {
-            T res;
-            std::istringstream iss(cell);
-            iss >> res;
-            return res;
-        }
-
-        template <>
-        inline float lexical_cast<float>(const std::string& cell) { return std::stof(cell); }
-
-        template <>
-        inline double lexical_cast<double>(const std::string& cell) { return std::stod(cell); }
-
-        template <>
-        inline long double lexical_cast<long double>(const std::string& cell) { return std::stold(cell); }
-
-        template <>
-        inline int lexical_cast<int>(const std::string& cell) { return std::stoi(cell); }
-
-        template <>
-        inline long lexical_cast<long>(const std::string& cell) { return std::stol(cell); }
-
-        template <>
-        inline long long lexical_cast<long long>(const std::string& cell) { return std::stoll(cell); }
-
-        template <>
-        inline unsigned int lexical_cast<unsigned int>(const std::string& cell) { return static_cast<unsigned int>(std::stoul(cell)); }
-
-        template <>
-        inline unsigned long lexical_cast<unsigned long>(const std::string& cell) { return std::stoul(cell); }
-
-        template <>
-        inline unsigned long long lexical_cast<unsigned long long>(const std::string& cell) { return std::stoull(cell); }
-
-        template <class ST, class T, class OI>
-        ST load_csv_row(std::istream& row_stream, OI output, std::string cell)
-        {
-            ST length = 0;
-            while (std::getline(row_stream, cell, ','))
-            {
-                *output++ = lexical_cast<T>(cell);
-                ++length;
-            }
-            return length;
-        }
-    }
-
-    /**
-     * @brief Load tensor from CSV.
-     * 
-     * Returns an \ref xexpression for the parsed CSV
-     * @param stream the input stream containing the CSV encoded values
-     */
-    template <class T, class A>
-    xcsv_tensor<T, A> load_csv(std::istream& stream)
-    {
-        using tensor_type = xcsv_tensor<T, A>;
-        using storage_type = typename tensor_type::storage_type;
-        using size_type = typename tensor_type::size_type;
-        using inner_shape_type = typename tensor_type::inner_shape_type;
-        using inner_strides_type = typename tensor_type::inner_strides_type;
-        using output_iterator = std::back_insert_iterator<storage_type>;
-
-        storage_type data;
-        size_type nbrow = 0, nbcol = 0;
-        {
-            output_iterator output(data);
-            std::string row, cell;
-            while (std::getline(stream, row))
-            {
-                std::stringstream row_stream(row);
-                nbcol = detail::load_csv_row<size_type, T, output_iterator>(row_stream, output, cell);
-                ++nbrow;
-            }
-        }
-        inner_shape_type shape = {nbrow, nbcol};
-        inner_strides_type strides;  // no need for initializer list for stack-allocated strides_type
-        size_type data_size = compute_strides(shape, layout_type::row_major, strides);
-        // Sanity check for data size.
-        if (data.size() != data_size)
-        {
-            throw std::runtime_error("Inconsistent row lengths in CSV");
-        }
-        return tensor_type(std::move(data), std::move(shape), std::move(strides));
-    }
-
-    /**
-     * @brief Dump tensor to CSV.
-     * 
-     * @param stream the output stream to write the CSV encoded values
-     * @param e the tensor expression to serialize
-     */
-    template <class E>
-    void dump_csv(std::ostream& stream, const xexpression<E>& e)
-    {
-        using size_type = typename E::size_type;
-        const E& ex = e.derived_cast();
-        if (ex.dimension() != 2)
-        {
-            throw std::runtime_error("Only 2-D expressions can be serialized to CSV");
-        }
-        size_type nbrows = ex.shape()[0], nbcols = ex.shape()[1];
-        auto st = ex.stepper_begin(ex.shape());
-        for (size_type r = 0; r != nbrows; ++r)
-        {
-            for (size_type c = 0; c != nbcols; ++c)
-            {
-                stream << *st;
-                if (c != nbcols - 1)
-                {
-                    st.step(1);
-                    stream << ',';
-                }
-                else
-                {
-                    st.reset(1);
-                    st.step(0);
-                    stream << std::endl;
-                }
-            }
-        }
-    }
-}
-
-#endif
diff --git a/include/xtensor/xeval.hpp b/include/xtensor/xeval.hpp
deleted file mode 100644
index 48e7d2967..000000000
--- a/include/xtensor/xeval.hpp
+++ /dev/null
@@ -1,65 +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 XTENSOR_EVAL_HPP
-#define XTENSOR_EVAL_HPP
-
-#include "xtensor_forward.hpp"
-
-namespace xt
-{
-
-    namespace detail
-    {
-        template <class T>
-        using is_container = std::is_base_of<xcontainer<std::remove_const_t<T>>, T>;
-    }
-
-    /**
-     * Force evaluation of xexpression.
-     * @return xarray or xtensor depending on shape type
-     *
-     * \code{.cpp}
-     * xarray<double> a = {1,2,3,4};
-     * auto&& b = xt::eval(a); // b is a reference to a, no copy!
-     * auto&& c = xt::eval(a + b); // c is xarray<double>, not an xexpression
-     * \endcode
-     */
-    template <class T>
-    inline auto eval(T&& t)
-        -> std::enable_if_t<detail::is_container<std::decay_t<T>>::value, T&&>
-    {
-        return std::forward<T>(t);
-    }
-
-    /// @cond DOXYGEN_INCLUDE_SFINAE
-    template <class T, class I = std::decay_t<T>>
-    inline auto eval(T&& t)
-        -> std::enable_if_t<!detail::is_container<I>::value && detail::is_array<typename I::shape_type>::value && !detail::is_fixed<typename I::shape_type>::value, xtensor<typename I::value_type, std::tuple_size<typename I::shape_type>::value>>
-    {
-        return xtensor<typename I::value_type, std::tuple_size<typename I::shape_type>::value>(std::forward<T>(t));
-    }
-
-    template <class T, class I = std::decay_t<T>>
-    inline auto eval(T&& t)
-        -> std::enable_if_t<!detail::is_container<I>::value && !detail::is_array<typename I::shape_type>::value && !detail::is_fixed<typename I::shape_type>::value, xt::xarray<typename I::value_type>>
-    {
-        return xarray<typename I::value_type>(std::forward<T>(t));
-    }
-
-    template <class T, class I = std::decay_t<T>>
-    inline auto eval(T&& t)
-        -> std::enable_if_t<!detail::is_container<I>::value && detail::is_fixed<typename I::shape_type>::value && !detail::is_array<typename I::shape_type>::value,
-                            xt::xtensor_fixed<typename I::value_type, typename I::shape_type>>
-    {
-        return xtensor_fixed<typename I::value_type, typename I::shape_type>(std::forward<T>(t));
-    }
-    /// @endcond
-}
-
-#endif
diff --git a/include/xtensor/xexception.hpp b/include/xtensor/xexception.hpp
deleted file mode 100644
index 51d2520a3..000000000
--- a/include/xtensor/xexception.hpp
+++ /dev/null
@@ -1,219 +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 XTENSOR_EXCEPTION_HPP
-#define XTENSOR_EXCEPTION_HPP
-
-#include <iterator>
-#include <sstream>
-#include <stdexcept>
-#include <string>
-
-namespace xt
-{
-
-    /*******************
-     * broadcast_error *
-     *******************/
-
-    class broadcast_error : public std::runtime_error
-    {
-    public:
-
-        explicit broadcast_error(const char* msg)
-            : std::runtime_error(msg)
-        {
-        }
-    };
-
-    template <class S1, class S2>
-    [[noreturn]] void throw_broadcast_error(const S1& lhs, const S2& rhs);
-
-    /**********************************
-     * broadcast_error implementation *
-     **********************************/
-
-#ifdef NDEBUG
-    // Do not inline this function
-    template <class S1, class S2>
-    [[noreturn]] void throw_broadcast_error(const S1&, const S2&)
-    {
-        throw broadcast_error("Incompatible dimension of arrays, compile in DEBUG for more info");
-    }
-#else
-    template <class S1, class S2>
-    [[noreturn]] void throw_broadcast_error(const S1& lhs, const S2& rhs)
-    {
-        std::ostringstream buf("Incompatible dimension of arrays:", std::ios_base::ate);
-
-        buf << "\n LHS shape = (";
-        using size_type1 = typename S1::value_type;
-        std::ostream_iterator<size_type1> iter1(buf, ", ");
-        std::copy(lhs.cbegin(), lhs.cend(), iter1);
-
-        buf << ")\n RHS shape = (";
-        using size_type2 = typename S2::value_type;
-        std::ostream_iterator<size_type2> iter2(buf, ", ");
-        std::copy(rhs.cbegin(), rhs.cend(), iter2);
-        buf << ")";
-
-        throw broadcast_error(buf.str().c_str());
-    }
-#endif
-
-    /*******************
-     * transpose_error *
-     *******************/
-
-    class transpose_error : public std::runtime_error
-    {
-    public:
-
-        explicit transpose_error(const char* msg)
-            : std::runtime_error(msg)
-        {
-        }
-    };
-
-    /***************
-     * check_index *
-     ***************/
-
-    template <class S, class... Args>
-    void check_index(const S& shape, Args... args);
-
-    template <class S, class It>
-    void check_element_index(const S& shape, It first, It last);
-
-    namespace detail
-    {
-        template <class S, std::size_t dim>
-        inline void check_index_impl(const S&)
-        {
-        }
-
-        template <class S, std::size_t dim, class T, class... Args>
-        inline void check_index_impl(const S& shape, T arg, Args... args)
-        {
-            if (sizeof...(Args) + 1 > shape.size())
-            {
-                check_index_impl<S, dim>(shape, args...);
-            }
-            else
-            {
-                if (std::size_t(arg) >= std::size_t(shape[dim]) && shape[dim] != 1)
-                {
-                    throw std::out_of_range("index " + std::to_string(arg) + " is out of bounds for axis "
-                        + std::to_string(dim) + " with size " + std::to_string(shape[dim]));
-                }
-                check_index_impl<S, dim + 1>(shape, args...);
-            }
-        }
-    }
-
-    template <class S, class... Args>
-    inline void check_index(const S& shape, Args... args)
-    {
-        using value_type = typename S::value_type;
-        detail::check_index_impl<S, 0>(shape, static_cast<value_type>(args)...);
-    }
-
-    template <class S, class It>
-    inline void check_element_index(const S& shape, It first, It last)
-    {
-        using value_type = typename std::iterator_traits<It>::value_type;
-        auto dst = static_cast<typename S::size_type>(last - first);
-        It efirst = last - static_cast<std::ptrdiff_t>((std::min)(shape.size(), dst));
-        std::size_t axis = 0;
-        while (efirst != last)
-        {
-            if (*efirst >= value_type(shape[axis]) && shape[axis] != 1)
-            {
-                throw std::out_of_range("index " + std::to_string(*efirst) + " is out of bounds for axis "
-                    + std::to_string(axis) + " with size " + std::to_string(shape[axis]));
-            }
-            ++efirst, ++axis;
-        }
-    }
-
-    /*******************
-     * check_dimension *
-     *******************/
-
-    template <class S, class... Args>
-    inline void check_dimension(const S& shape, Args...)
-    {
-        if (sizeof...(Args) > shape.size())
-        {
-            throw std::out_of_range("Number of arguments (" + std::to_string(sizeof...(Args)) + ") us greater "
-                + "than the number of dimensions (" + std::to_string(shape.size()) + ")");
-        }
-    }
-
-    /****************
-     * check_access *
-     ****************/
-
-    template <class S, class... Args>
-    inline void check_access(const S& shape, Args... args)
-    {
-        check_dimension(shape, args...);
-        check_index(shape, args...);
-    }
-
-#ifdef XTENSOR_ENABLE_ASSERT
-#define XTENSOR_TRY(expr) XTENSOR_TRY_IMPL(expr, __FILE__, __LINE__)
-#define XTENSOR_TRY_IMPL(expr, file, line)                                                                                       \
-    try                                                                                                                          \
-    {                                                                                                                            \
-        expr;                                                                                                                    \
-    }                                                                                                                            \
-    catch (std::exception& e)                                                                                                    \
-    {                                                                                                                            \
-        throw std::runtime_error(std::string(file) + ':' + std::to_string(line) + ": check failed\n\t" + std::string(e.what())); \
-    }
-#else
-#define XTENSOR_TRY(expr)
-#endif
-
-#ifdef XTENSOR_ENABLE_ASSERT
-#define XTENSOR_ASSERT(expr) XTENSOR_ASSERT_IMPL(expr, __FILE__, __LINE__)
-#define XTENSOR_ASSERT_IMPL(expr, file, line)                                                                                    \
-    if (!(expr))                                                                                                                 \
-    {                                                                                                                            \
-        throw std::runtime_error(std::string(file) + ':' + std::to_string(line) + ": assertion failed (" #expr ") \n\t");        \
-    }
-#else
-#define XTENSOR_ASSERT(expr)
-#endif
-
-#ifdef XTENSOR_ENABLE_CHECK_DIMENSION
-#define XTENSOR_CHECK_DIMENSION(S, ARGS) XTENSOR_TRY(check_dimension(S, ARGS))
-#else
-#define XTENSOR_CHECK_DIMENSION(S, ARGS)
-#endif
-
-#ifdef XTENSOR_ENABLE_ASSERT
-#define XTENSOR_ASSERT_MSG(expr, msg)                                                         \
-    if (!(expr))                                                                              \
-    {                                                                                         \
-        throw std::runtime_error(std::string("Assertion error!\n") + msg +                    \
-                                 "\n  " + __FILE__ + '(' + std::to_string(__LINE__) + ")\n"); \
-    }
-#else
-#define XTENSOR_ASSERT_MSG(expr, msg)
-#endif
-
-#define XTENSOR_PRECONDITION(expr, msg)                                                       \
-    if (!(expr))                                                                              \
-    {                                                                                         \
-        throw std::runtime_error(std::string("Precondition violation!\n") + msg +             \
-                                 "\n  " + __FILE__ + '(' + std::to_string(__LINE__) + ")\n"); \
-    }
-}
-#endif  // XEXCEPTION_HPP
diff --git a/include/xtensor/xexpression.hpp b/include/xtensor/xexpression.hpp
deleted file mode 100644
index 0ac7c2b2e..000000000
--- a/include/xtensor/xexpression.hpp
+++ /dev/null
@@ -1,604 +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 XTENSOR_EXPRESSION_HPP
-#define XTENSOR_EXPRESSION_HPP
-
-#include <cstddef>
-#include <type_traits>
-#include <vector>
-
-#include <xtl/xclosure.hpp>
-#include <xtl/xmeta_utils.hpp>
-#include <xtl/xtype_traits.hpp>
-
-#include "xlayout.hpp"
-#include "xshape.hpp"
-#include "xutils.hpp"
-
-namespace xt
-{
-
-    template <class E>
-    class xshared_expression;
-
-    /***************************
-     * xexpression declaration *
-     ***************************/
-
-    /**
-     * @class xexpression
-     * @brief 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.
-     *
-     * \tparam E The derived type.
-     *
-     */
-    template <class D>
-    class xexpression
-    {
-    public:
-
-        using derived_type = D;
-
-        derived_type& derived_cast() & noexcept;
-        const derived_type& derived_cast() const & noexcept;
-        derived_type derived_cast() && noexcept;
-
-    protected:
-
-        xexpression() = default;
-        ~xexpression() = default;
-
-        xexpression(const xexpression&) = default;
-        xexpression& operator=(const xexpression&) = default;
-
-        xexpression(xexpression&&) = default;
-        xexpression& operator=(xexpression&&) = default;
-    };
-
-    /******************************
-     * xexpression implementation *
-     ******************************/
-
-    /**
-     * @name Downcast functions
-     */
-    //@{
-    /**
-     * Returns a reference to the actual derived type of the xexpression.
-     */
-    template <class D>
-    inline auto xexpression<D>::derived_cast() & noexcept -> derived_type&
-    {
-        return *static_cast<derived_type*>(this);
-    }
-
-    /**
-     * Returns a constant reference to the actual derived type of the xexpression.
-     */
-    template <class D>
-    inline auto xexpression<D>::derived_cast() const & noexcept -> const derived_type&
-    {
-        return *static_cast<const derived_type*>(this);
-    }
-
-    /**
-     * Returns a constant reference to the actual derived type of the xexpression.
-     */
-    template <class D>
-    inline auto xexpression<D>::derived_cast() && noexcept -> derived_type
-    {
-        return *static_cast<derived_type*>(this);
-    }
-    //@}
-
-    /* is_crtp_base_of<B, E>
-    * Resembles std::is_base_of, but adresses the problem of whether _some_ instantiation
-    * of a CRTP templated class B is a base of class E. A CRTP templated class is correctly
-    * templated with the most derived type in the CRTP hierarchy. Using this assumption,
-    * this implementation deals with either CRTP final classes (checks for inheritance
-    * with E as the CRTP parameter of B) or CRTP base classes (which are singly templated
-    * by the most derived class, and that's pulled out to use as a templete parameter for B).
-    */
-
-    namespace detail
-    {
-        template <template <class> class B, class E>
-        struct is_crtp_base_of_impl : std::is_base_of<B<E>, E> {};
-
-        template <template <class> class B, class E, template <class> class F>
-        struct is_crtp_base_of_impl<B, F<E>> :
-        xtl::disjunction< std::is_base_of<B<E>, F<E>>, std::is_base_of<B<F<E>>, F<E>>> {};
-    }
-
-    template <template <class> class B, class E>
-    using is_crtp_base_of = detail::is_crtp_base_of_impl<B, std::decay_t<E>>;
-
-    template <class E>
-    using is_xexpression = is_crtp_base_of<xexpression, E>;
-
-    template <class E, class R = void>
-    using enable_xexpression = typename std::enable_if<is_xexpression<E>::value, R>::type;
-
-    template <class E, class R = void>
-    using disable_xexpression = typename std::enable_if<!is_xexpression<E>::value, R>::type;
-
-    template <class... E>
-    using has_xexpression = xtl::disjunction<is_xexpression<E>...>;
-
-    /************
-     * xclosure *
-     ************/
-
-    template <class T>
-    class xscalar;
-
-    template <class E, class EN = void>
-    struct xclosure
-    {
-        using type = xtl::closure_type_t<E>;
-    };
-
-    template <class E>
-    struct xclosure<xshared_expression<E>, std::enable_if_t<true>>
-    {
-        using type = xshared_expression<E>; // force copy
-    };
-
-    template <class E>
-    struct xclosure<E, disable_xexpression<std::decay_t<E>>>
-    {
-        using type = xscalar<xtl::closure_type_t<E>>;
-    };
-
-    template <class E>
-    using xclosure_t = typename xclosure<E>::type;
-
-    template <class E, class EN = void>
-    struct const_xclosure
-    {
-        using type = xtl::const_closure_type_t<E>;
-    };
-
-    template <class E>
-    struct const_xclosure<E, disable_xexpression<std::decay_t<E>>>
-    {
-        using type = xscalar<xtl::const_closure_type_t<E>>;
-    };
-
-    template <class E>
-    struct const_xclosure<xshared_expression<E>&, std::enable_if_t<true>>
-    {
-        using type = xshared_expression<E>; // force copy
-    };
-
-    template <class E>
-    using const_xclosure_t = typename const_xclosure<E>::type;
-
-    /***************
-     * xvalue_type *
-     ***************/
-
-    namespace detail
-    {
-        template <class E, class enable = void>
-        struct xvalue_type_impl
-        {
-            using type = E;
-        };
-
-        template <class E>
-        struct xvalue_type_impl<E, std::enable_if_t<is_xexpression<E>::value>>
-        {
-            using type = typename E::value_type;
-        };
-    }
-
-    template <class E>
-    using xvalue_type = detail::xvalue_type_impl<E>;
-
-    template <class E>
-    using xvalue_type_t = typename xvalue_type<E>::type;
-
-    /*************************
-     * expression tag system *
-     *************************/
-
-    struct xtensor_expression_tag
-    {
-    };
-
-    struct xoptional_expression_tag
-    {
-    };
-
-    namespace extension
-    {
-        template <class E, class = void_t<int>>
-        struct get_expression_tag_impl
-        {
-            using type = xtensor_expression_tag;
-        };
-
-        template <class E>
-        struct get_expression_tag_impl<E, void_t<typename std::decay_t<E>::expression_tag>>
-        {
-            using type = typename std::decay_t<E>::expression_tag;
-        };
-
-        template <class E>
-        struct get_expression_tag : get_expression_tag_impl<E>
-        {
-        };
-
-        template <class E>
-        using get_expression_tag_t = typename get_expression_tag<E>::type;
-
-        template <class... T>
-        struct expression_tag_and;
-
-        template <>
-        struct expression_tag_and<>
-        {
-            using type = xtensor_expression_tag;
-        };
-
-        template <class T>
-        struct expression_tag_and<T>
-        {
-            using type = T;
-        };
-
-        template <class T>
-        struct expression_tag_and<T, T>
-        {
-            using type = T;
-        };
-
-        template <class T>
-        struct expression_tag_and<xtensor_expression_tag, T>
-        {
-            using type = T;
-        };
-
-        template <class T>
-        struct expression_tag_and<T, xtensor_expression_tag>
-            : expression_tag_and<xtensor_expression_tag, T>
-        {
-        };
-
-        template <>
-        struct expression_tag_and<xtensor_expression_tag, xtensor_expression_tag>
-        {
-            using type = xtensor_expression_tag;
-        };
-
-        template <class T1, class... T>
-        struct expression_tag_and<T1, T...>
-            : expression_tag_and<T1, typename expression_tag_and<T...>::type>
-        {
-        };
-
-        template <class... T>
-        using expression_tag_and_t = typename expression_tag_and<T...>::type;
-
-        struct xtensor_empty_base
-        {
-            using expression_tag = xtensor_expression_tag;
-        };
-    }
-
-    template <class... T>
-    struct xexpression_tag
-    {
-        using type = extension::expression_tag_and_t<extension::get_expression_tag_t<std::decay_t<const_xclosure_t<T>>>...>;
-    };
-
-    template <class... T>
-    using xexpression_tag_t = typename xexpression_tag<T...>::type;
-
-    template <class E>
-    struct is_xtensor_expression : std::is_same<xexpression_tag_t<E>, xtensor_expression_tag>
-    {
-    };
-
-    template <class E>
-    struct is_xoptional_expression : std::is_same<xexpression_tag_t<E>, xoptional_expression_tag>
-    {
-    };
-
-    /********************************
-     * xoptional_comparable concept *
-     ********************************/
-
-    template <class... E>
-    struct xoptional_comparable : xtl::conjunction<xtl::disjunction<is_xtensor_expression<E>,
-                                                                    is_xoptional_expression<E>
-                                                                   >...
-                                                  >
-    {
-    };
-
-#define XTENSOR_FORWARD_METHOD(name)           \
-    auto name() const                          \
-        -> decltype(std::declval<E>().name())  \
-    {                                          \
-        return m_ptr->name();                  \
-    }
-
-    namespace detail
-    {
-        template <class E>
-        struct expr_strides_type
-        {
-            using type = typename E::strides_type;
-        };
-
-        template <class E>
-        struct expr_inner_strides_type
-        {
-            using type = typename E::inner_strides_type;
-        };
-
-        template <class E>
-        struct expr_backstrides_type
-        {
-            using type = typename E::backstrides_type;
-        };
-
-        template <class E>
-        struct expr_inner_backstrides_type
-        {
-            using type = typename E::inner_backstrides_type;
-        };
-
-        template <class E>
-        struct expr_storage_type
-        {
-            using type = typename E::storage_type;
-        };
-    }
-
-    /**
-     * @class xshared_expression
-     * @brief 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:
-     *
-     * \code{.cpp}
-     * 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.
-     * }
-     * \endcode
-     */
-    template <class E>
-    class xshared_expression
-        : public xexpression<xshared_expression<E>>
-    {
-    public:
-
-        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 = xtl::mpl::eval_if_t<has_strides<E>,
-                                                 detail::expr_strides_type<E>,
-                                                 get_strides_type<shape_type>>;
-        using backstrides_type = xtl::mpl::eval_if_t<has_strides<E>,
-                                                     detail::expr_backstrides_type<E>,
-                                                     get_strides_type<shape_type>>;
-        using inner_strides_type = xtl::mpl::eval_if_t<has_strides<E>,
-                                                       detail::expr_inner_strides_type<E>,
-                                                       get_strides_type<shape_type>>;
-        using inner_backstrides_type = xtl::mpl::eval_if_t<has_strides<E>,
-                                                           detail::expr_inner_backstrides_type<E>,
-                                                           get_strides_type<shape_type>>;
-        using storage_type = xtl::mpl::eval_if_t<has_data_interface<E>,
-                                                 detail::expr_storage_type<E>,
-                                                 make_invalid_type<>>;
-
-        using stepper = typename E::stepper;
-        using const_stepper = typename E::const_stepper;
-
-        using storage_iterator = typename E::storage_iterator;
-        using const_storage_iterator = typename E::const_storage_iterator;
-
-        static constexpr layout_type static_layout = E::static_layout;
-        static constexpr bool contiguous_layout = static_layout != layout_type::dynamic;
-
-        explicit xshared_expression(std::shared_ptr<E>&& ptr);
-        long use_count() const noexcept;
-
-        template <class... Args>
-        auto operator()(Args... args)
-            -> decltype(std::declval<E>()(args...))
-        {
-            return m_ptr->operator()(args...);
-        }
-
-        XTENSOR_FORWARD_METHOD(shape);
-        XTENSOR_FORWARD_METHOD(dimension);
-        XTENSOR_FORWARD_METHOD(size);
-        XTENSOR_FORWARD_METHOD(begin);
-        XTENSOR_FORWARD_METHOD(cbegin);
-        XTENSOR_FORWARD_METHOD(storage_begin);
-        XTENSOR_FORWARD_METHOD(storage_cbegin);
-        XTENSOR_FORWARD_METHOD(storage_end);
-        XTENSOR_FORWARD_METHOD(storage_cend);
-        XTENSOR_FORWARD_METHOD(layout);
-
-        template <class T = E>
-        std::enable_if_t<has_strides<T>::value, const inner_strides_type&>
-        strides() const
-        {
-            return m_ptr->strides();
-        }
-
-        template <class T = E>
-        std::enable_if_t<has_strides<T>::value, const inner_strides_type&>
-        backstrides() const
-        {
-            return m_ptr->backstrides();
-        }
-
-        template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, pointer>
-        data() noexcept
-        {
-            return m_ptr->data();
-        }
-
-        template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, pointer>
-        data() const noexcept
-        {
-            return m_ptr->data();
-        }
-
-        template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, size_type>
-        data_offset() const noexcept
-        {
-            return m_ptr->data_offset();
-        }
-
-        template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, typename T::storage_type&>
-        storage() noexcept
-        {
-            return m_ptr->storage();
-        }
-
-        template <class T = E>
-        std::enable_if_t<has_data_interface<T>::value, const typename T::storage_type&>
-        storage() const noexcept
-        {
-            return m_ptr->storage();
-        }
-
-        template <class It>
-        auto element(It first, It last) {
-            return m_ptr->element(first, last);
-        }
-
-        template <class It>
-        auto element(It first, It last) const {
-            return m_ptr->element(first, last);
-        }
-
-        template <class S>
-        bool broadcast_shape(S& shape, bool reuse_cache = false) const
-        {
-            return m_ptr->broadcast_shape(shape, reuse_cache);
-        }
-
-        template <class S>
-        bool has_linear_assign(const S& strides) const noexcept
-        {
-            return m_ptr->has_linear_assign(strides);
-        }
-
-        template <class S>
-        auto stepper_begin(const S& shape) noexcept
-            -> decltype(std::declval<E>().stepper_begin(shape))
-        {
-            return m_ptr->stepper_begin(shape);
-        }
-
-        template <class S>
-        auto stepper_end(const S& shape, layout_type l) noexcept
-            -> decltype(std::declval<E>().stepper_end(shape, l))
-        {
-            return m_ptr->stepper_end(shape, l);
-        }
-
-        template <class S>
-        auto stepper_begin(const S& shape) const noexcept
-            -> decltype(std::declval<const E>().stepper_begin(shape))
-        {
-            return static_cast<const E*>(m_ptr.get())->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))
-        {
-            return static_cast<const E*>(m_ptr.get())->stepper_end(shape, l);
-        }
-
-    private:
-
-        std::shared_ptr<E> m_ptr;
-    };
-
-    /**
-     * Constructor for xshared expression (note: usually the free function
-     * `make_xshared` is recommended).
-     *
-     * @param ptr shared ptr that contains the expression
-     * @sa make_xshared
-     */
-    template <class E>
-    inline xshared_expression<E>::xshared_expression(std::shared_ptr<E>&& ptr)
-        : m_ptr(std::move(ptr))
-    {
-    }
-
-    /**
-     * Return the number of times this expression is referenced.
-     * Internally calls the use_count() function of the std::shared_ptr.
-     */
-    template <class E>
-    inline long xshared_expression<E>::use_count() const noexcept
-    {
-        return m_ptr.use_count();
-    }
-
-    /**
-     * Helper function to create shared expression from any xexpression
-     *
-     * @param expr rvalue expression that will be shared
-     * @return xshared expression
-     */
-    template <class E>
-    auto make_xshared(xexpression<E>&& expr)
-    {
-        return xshared_expression<E>(std::make_shared<E>(std::move(expr).derived_cast()));
-    }
-
-#undef XTENSOR_FORWARD_METHOD
-
-}
-
-#endif
diff --git a/include/xtensor/xfunctor_view.hpp b/include/xtensor/xfunctor_view.hpp
deleted file mode 100644
index 387918ba8..000000000
--- a/include/xtensor/xfunctor_view.hpp
+++ /dev/null
@@ -1,1389 +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 XTENSOR_FUNCTOR_VIEW_HPP
-#define XTENSOR_FUNCTOR_VIEW_HPP
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-
-#include <xtl/xproxy_wrapper.hpp>
-
-#include "xtensor/xexpression.hpp"
-#include "xtensor/xiterator.hpp"
-#include "xtensor/xsemantic.hpp"
-#include "xtensor/xutils.hpp"
-
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-
-namespace xt
-{
-
-    /*****************************
-     * xfunctor_view declaration *
-     *****************************/
-
-    template <class F, class IT>
-    class xfunctor_iterator;
-
-    template <class F, class ST>
-    class xfunctor_stepper;
-
-    template <class F, class CT>
-    class xfunctor_view;
-
-    /***************************
-     * xfunctor_view extension *
-     ***************************/
-
-    namespace extension
-    {
-        template <class Tag, class F, class CT>
-        struct xfunctor_view_base_impl;
-
-        template <class F, class CT>
-        struct xfunctor_view_base_impl<xtensor_expression_tag, F, CT>
-        {
-            using type = xtensor_empty_base;
-        };
-
-        template <class F, class CT>
-        struct xfunctor_view_base
-            : xfunctor_view_base_impl<xexpression_tag_t<CT>, F, CT>
-        {
-        };
-
-        template <class F, class CT>
-        using xfunctor_view_base_t = typename xfunctor_view_base<F, CT>::type;
-    }
-
-    /********************************
-     * xfunctor_view_temporary_type *
-     ********************************/
-
-    namespace detail
-    {
-        template <class F, class S, layout_type L>
-        struct functorview_temporary_type_impl
-        {
-            using type = xarray<typename F::value_type, L>;
-        };
-
-        template <class F, class T, std::size_t N, layout_type L>
-        struct functorview_temporary_type_impl<F, std::array<T, N>, L>
-        {
-            using type = xtensor<typename F::value_type, N, L>;
-        };
-    }
-
-    template <class F, class E>
-    struct xfunctor_view_temporary_type
-    {
-        using type = typename detail::functorview_temporary_type_impl<F, typename E::shape_type, E::static_layout>::type;
-    };
-
-    template <class F, class CT>
-    struct xcontainer_inner_types<xfunctor_view<F, CT>>
-    {
-        using xexpression_type = std::decay_t<CT>;
-        using temporary_type = typename xfunctor_view_temporary_type<F, xexpression_type>::type;
-    };
-
-#define DL XTENSOR_DEFAULT_LAYOUT
-    /**
-     * @class xfunctor_view
-     * @brief View of an xexpression .
-     *
-     * The 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 xfunctor_view is
-     * an lvalue. It is used e.g. to access real and imaginary parts of complex expressions.
-     *
-     * xfunctor_view is not meant to be used directly, but through helper functions such
-     * as \ref real or \ref imag.
-     *
-     * @tparam F the functor type to be applied to the elements of specified expression.
-     * @tparam CT the closure type of the \ref xexpression type underlying this view
-     *
-     * @sa real, imag
-     */
-    template <class F, class CT>
-    class xfunctor_view : public xview_semantic<xfunctor_view<F, CT>>,
-                          public extension::xfunctor_view_base_t<F, CT>
-    {
-    public:
-
-        using self_type = xfunctor_view<F, CT>;
-        using xexpression_type = std::decay_t<CT>;
-        using semantic_base = xview_semantic<self_type>;
-        using functor_type = typename std::decay_t<F>;
-
-        using extension_base = extension::xfunctor_view_base_t<F, CT>;
-        using expression_tag = typename extension_base::expression_tag;
-
-        using value_type = typename functor_type::value_type;
-        using reference = typename functor_type::reference;
-        using const_reference = typename functor_type::const_reference;
-        using pointer = typename functor_type::pointer;
-        using const_pointer = typename functor_type::const_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;
-
-        static constexpr layout_type static_layout = xexpression_type::static_layout;
-        static constexpr bool contiguous_layout = false;
-
-        using stepper = xfunctor_stepper<functor_type, typename xexpression_type::stepper>;
-        using const_stepper = xfunctor_stepper<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 = xfunctor_iterator<functor_type, typename xexpression_type::template const_layout_iterator<L>>;
-
-        template <layout_type L>
-        using reverse_layout_iterator = xfunctor_iterator<functor_type, typename xexpression_type::template reverse_layout_iterator<L>>;
-        template <layout_type L>
-        using const_reverse_layout_iterator = xfunctor_iterator<functor_type, typename xexpression_type::template const_reverse_layout_iterator<L>>;
-
-        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 = xfunctor_iterator<functor_type, xiterator<typename xexpression_type::const_stepper, S, L>>;
-
-        template <class S, layout_type L>
-        using reverse_broadcast_iterator = xfunctor_iterator<functor_type, typename xexpression_type::template reverse_broadcast_iterator<S, L>>;
-        template <class S, layout_type L>
-        using const_reverse_broadcast_iterator = xfunctor_iterator<functor_type, typename xexpression_type::template const_reverse_broadcast_iterator<S, L>>;
-
-        using storage_iterator = xfunctor_iterator<functor_type, typename xexpression_type::storage_iterator>;
-        using const_storage_iterator = xfunctor_iterator<functor_type, typename xexpression_type::const_storage_iterator>;
-        using reverse_storage_iterator = xfunctor_iterator<functor_type, typename xexpression_type::reverse_storage_iterator>;
-        using const_reverse_storage_iterator = xfunctor_iterator<functor_type, typename xexpression_type::const_reverse_storage_iterator>;
-
-        using iterator = xfunctor_iterator<functor_type, typename xexpression_type::iterator>;
-        using const_iterator = xfunctor_iterator<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<functor_type, typename xexpression_type::const_reverse_iterator>;
-
-        explicit xfunctor_view(CT) noexcept;
-
-        template <class Func, class E>
-        xfunctor_view(Func&&, E&&) noexcept;
-
-        template <class E>
-        self_type& operator=(const xexpression<E>& e);
-
-        template <class E>
-        disable_xexpression<E, self_type>& operator=(const E& e);
-
-        size_type size() const noexcept;
-        size_type dimension() const noexcept;
-        const shape_type& shape() const noexcept;
-        layout_type layout() const noexcept;
-
-        template <class... Args>
-        reference operator()(Args... args);
-
-        template <class... Args>
-        reference at(Args... args);
-
-        template <class... Args>
-        reference unchecked(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 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... 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 IT>
-        const_reference element(IT first, IT last) const;
-
-        xexpression_type& expression() noexcept;
-        const xexpression_type& expression() const noexcept;
-
-        template <class S>
-        bool broadcast_shape(S& shape, bool reuse_cache = false) const;
-
-        template <class S>
-        bool has_linear_assign(const S& strides) const;
-
-        template <layout_type L = DL>
-        auto begin() noexcept;
-        template <layout_type L = DL>
-        auto end() noexcept;
-
-        template <layout_type L = DL>
-        auto begin() const noexcept;
-        template <layout_type L = DL>
-        auto end() const noexcept;
-        template <layout_type L = DL>
-        auto cbegin() const noexcept;
-        template <layout_type L = DL>
-        auto cend() const noexcept;
-
-        template <layout_type L = DL>
-        auto rbegin() noexcept;
-        template <layout_type L = DL>
-        auto rend() noexcept;
-
-        template <layout_type L = DL>
-        auto rbegin() const noexcept;
-        template <layout_type L = DL>
-        auto rend() const noexcept;
-        template <layout_type L = DL>
-        auto crbegin() const noexcept;
-        template <layout_type L = DL>
-        auto crend() const noexcept;
-
-        template <class S, layout_type L = DL>
-        broadcast_iterator<S, L> begin(const S& shape) noexcept;
-        template <class S, layout_type L = DL>
-        broadcast_iterator<S, L> end(const S& shape) noexcept;
-
-        template <class S, layout_type L = DL>
-        const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
-        const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
-        const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
-        const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
-
-        template <class S, layout_type L = DL>
-        reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
-        template <class S, layout_type L = DL>
-        reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
-
-        template <class S, layout_type L = DL>
-        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
-        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
-        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
-        template <class S, layout_type L = DL>
-        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
-
-        storage_iterator storage_begin() noexcept;
-        storage_iterator storage_end() noexcept;
-
-        const_storage_iterator storage_begin() const noexcept;
-        const_storage_iterator storage_end() const noexcept;
-        const_storage_iterator storage_cbegin() const noexcept;
-        const_storage_iterator storage_cend() const noexcept;
-
-        reverse_storage_iterator storage_rbegin() noexcept;
-        reverse_storage_iterator storage_rend() noexcept;
-
-        const_reverse_storage_iterator storage_rbegin() const noexcept;
-        const_reverse_storage_iterator storage_rend() const noexcept;
-        const_reverse_storage_iterator storage_crbegin() const noexcept;
-        const_reverse_storage_iterator storage_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;
-
-        template <class E>
-        using rebind_t = xfunctor_view<F, E>;
-
-        template <class E>
-        rebind_t<E> build_functor_view(E&& e) const;
-
-    private:
-
-        CT m_e;
-        functor_type m_functor;
-
-        using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type;
-        void assign_temporary_impl(temporary_type&& tmp);
-        friend class xview_semantic<xfunctor_view<F, CT>>;
-    };
-
-#undef DL
-
-    /*********************************
-     * xfunctor_iterator declaration *
-     *********************************/
-
-    template <class F, class IT>
-    class xfunctor_iterator : public xtl::xrandom_access_iterator_base<xfunctor_iterator<F, IT>,
-                                                                       typename F::value_type,
-                                                                       typename std::iterator_traits<IT>::difference_type,
-                                                                       typename xtl::xproxy_wrapper<decltype(std::declval<F>()(*(IT())))>::pointer,
-                                                                       xtl::xproxy_wrapper<decltype(std::declval<F>()(*(IT())))>>
-    {
-    public:
-
-        using functor_type = std::decay_t<F>;
-        using subiterator_traits = std::iterator_traits<IT>;
-
-        using value_type = typename functor_type::value_type;
-        using reference = xtl::xproxy_wrapper<decltype(std::declval<functor_type>()(*(IT())))>;
-        using pointer = typename reference::pointer;
-        using difference_type = typename subiterator_traits::difference_type;
-        using iterator_category = typename subiterator_traits::iterator_category;
-
-        using self_type = xfunctor_iterator<F, IT>;
-
-        xfunctor_iterator(const IT&, const 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;
-
-    private:
-
-        IT m_it;
-        const functor_type* p_functor;
-    };
-
-    template <class F, class IT>
-    bool operator==(const xfunctor_iterator<F, IT>& lhs,
-                    const xfunctor_iterator<F, IT>& rhs);
-
-    template <class F, class IT>
-    bool operator<(const xfunctor_iterator<F, IT>& lhs,
-                   const xfunctor_iterator<F, IT>& rhs);
-
-    /********************************
-     * xfunctor_stepper declaration *
-     ********************************/
-
-    template <class F, class ST>
-    class xfunctor_stepper
-    {
-    public:
-
-        using functor_type = std::decay_t<F>;
-
-        using value_type = typename functor_type::value_type;
-        using reference = apply_cv_t<typename ST::reference, value_type>;
-        using pointer = std::remove_reference_t<reference>*;
-        using size_type = typename ST::size_type;
-        using difference_type = typename ST::difference_type;
-
-        xfunctor_stepper() = default;
-        xfunctor_stepper(const ST&, const 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);
-
-    private:
-
-        ST m_stepper;
-        const functor_type* p_functor;
-    };
-
-    /********************************
-     * xfunctor_view implementation *
-     ********************************/
-
-    /**
-     * @name Constructors
-     */
-    //@{
-
-    /**
-     * Constructs an xfunctor_view expression wrappering the specified \ref xexpression.
-     *
-     * @param e the underlying expression
-     */
-    template <class F, class CT>
-    inline xfunctor_view<F, CT>::xfunctor_view(CT e) noexcept
-        : m_e(e), m_functor(functor_type())
-    {
-    }
-
-    /**
-    * Constructs an xfunctor_view expression wrappering the specified \ref xexpression.
-    *
-    * @param func the functor to be applied to the elements of the underlying expression.
-    * @param e the underlying expression
-    */
-    template <class F, class CT>
-    template <class Func, class E>
-    inline xfunctor_view<F, CT>::xfunctor_view(Func&& func, E&& e) noexcept
-        : m_e(std::forward<E>(e)), m_functor(std::forward<Func>(func))
-    {
-    }
-    //@}
-
-    /**
-     * @name Extended copy semantic
-     */
-    //@{
-    /**
-     * The extended assignment operator.
-     */
-    template <class F, class CT>
-    template <class E>
-    inline auto xfunctor_view<F, CT>::operator=(const xexpression<E>& e) -> self_type&
-    {
-        bool cond = (e.derived_cast().shape().size() == dimension()) && std::equal(shape().begin(), shape().end(), e.derived_cast().shape().begin());
-        if (!cond)
-        {
-            semantic_base::operator=(broadcast(e.derived_cast(), shape()));
-        }
-        else
-        {
-            semantic_base::operator=(e);
-        }
-        return *this;
-    }
-    //@}
-
-    template <class F, class CT>
-    template <class E>
-    inline auto xfunctor_view<F, CT>::operator=(const E& e) -> disable_xexpression<E, self_type>&
-    {
-        std::fill(begin(), end(), e);
-        return *this;
-    }
-
-    template <class F, class CT>
-    inline void xfunctor_view<F, CT>::assign_temporary_impl(temporary_type&& tmp)
-    {
-        std::copy(tmp.cbegin(), tmp.cend(), begin());
-    }
-
-    /**
-     * @name Size and shape
-     */
-    /**
-     * Returns the size of the expression.
-     */
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::size() const noexcept -> size_type
-    {
-        return m_e.size();
-    }
-
-    /**
-     * Returns the number of dimensions of the expression.
-     */
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::dimension() const noexcept -> size_type
-    {
-        return m_e.dimension();
-    }
-
-    /**
-     * Returns the shape of the expression.
-     */
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::shape() const noexcept -> const shape_type&
-    {
-        return m_e.shape();
-    }
-
-    /**
-     * Returns the layout_type of the expression.
-     */
-    template <class F, class CT>
-    inline layout_type xfunctor_view<F, CT>::layout() const noexcept
-    {
-        return m_e.layout();
-    }
-    //@}
-
-    /**
-     * @name Data
-     */
-    /**
-     * Returns a reference to the element at the specified position in the expression.
-     * @param args a 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.
-     */
-    template <class F, class CT>
-    template <class... Args>
-    inline auto xfunctor_view<F, CT>::operator()(Args... args) -> reference
-    {
-        XTENSOR_TRY(check_index(shape(), args...));
-        XTENSOR_CHECK_DIMENSION(shape(), args...);
-        return m_functor(m_e(args...));
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the expression,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class F, class CT>
-    template <class... Args>
-    inline auto xfunctor_view<F, CT>::at(Args... args) -> reference
-    {
-        check_access(shape(), args...);
-        return this->operator()(args...);
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the expression.
-     * @param args a 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 prefered whenever
-     * it is possible.
-     * @warning This method is NOT compatible with broadcasting, meaning the following
-     * code has undefined behavior:
-     * \code{.cpp}
-     * xt::xarray<double> a = {{0, 1}, {2, 3}};
-     * xt::xarray<double> b = {0, 1};
-     * auto fd = a + b;
-     * double res = fd.uncheked(0, 1);
-     * \endcode
-     */
-    template <class F, class CT>
-    template <class... Args>
-    inline auto xfunctor_view<F, CT>::unchecked(Args... args) -> reference
-    {
-        return m_functor(m_e.unchecked(args...));
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the expression.
-     * @param index a sequence of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices in the sequence should be equal or greater
-     * than the number of dimensions of the container.
-     */
-    template <class F, class CT>
-    template <class S>
-    inline auto xfunctor_view<F, CT>::operator[](const S& index)
-        -> disable_integral_t<S, reference>
-    {
-        return m_functor(m_e[index]);
-    }
-
-    template <class F, class CT>
-    template <class I>
-    inline auto xfunctor_view<F, CT>::operator[](std::initializer_list<I> index)
-        -> reference
-    {
-        return m_functor(m_e[index]);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::operator[](size_type i) -> reference
-    {
-        return operator()(i);
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the expression.
-     * @param first iterator starting the sequence of indices
-     * @param last iterator 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.
-     */
-    template <class F, class CT>
-    template <class IT>
-    inline auto xfunctor_view<F, CT>::element(IT first, IT last) -> reference
-    {
-        XTENSOR_TRY(check_element_index(shape(), first, last));
-        return m_functor(m_e.element(first, last));
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the expression.
-     * @param args a 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.
-     */
-    template <class F, class CT>
-    template <class... Args>
-    inline auto xfunctor_view<F, CT>::operator()(Args... args) const -> const_reference
-    {
-        XTENSOR_TRY(check_index(shape(), args...));
-        XTENSOR_CHECK_DIMENSION(shape(), args...);
-        return m_functor(m_e(args...));
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the expression,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class F, class CT>
-    template <class... Args>
-    inline auto xfunctor_view<F, CT>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), args...);
-        return this->operator()(args...);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the expression.
-     * @param args a 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 prefered whenever
-     * it is possible.
-     * @warning This method is NOT compatible with broadcasting, meaning the following
-     * code has undefined behavior:
-     * \code{.cpp}
-     * xt::xarray<double> a = {{0, 1}, {2, 3}};
-     * xt::xarray<double> b = {0, 1};
-     * auto fd = a + b;
-     * double res = fd.uncheked(0, 1);
-     * \endcode
-     */
-    template <class F, class CT>
-    template <class... Args>
-    inline auto xfunctor_view<F, CT>::unchecked(Args... args) const -> const_reference
-    {
-        return m_functor(m_e.unchecked(args...));
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the expression.
-     * @param index a sequence of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices in the sequence should be equal or greater
-     * than the number of dimensions of the container.
-     */
-    template <class F, class CT>
-    template <class S>
-    inline auto xfunctor_view<F, CT>::operator[](const S& index) const
-        -> disable_integral_t<S, const_reference>
-    {
-        return m_functor(m_e[index]);
-    }
-
-    template <class F, class CT>
-    template <class I>
-    inline auto xfunctor_view<F, CT>::operator[](std::initializer_list<I> index) const
-        -> const_reference
-    {
-        return m_functor(m_e[index]);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the expression.
-     * @param first iterator starting the sequence of indices
-     * @param last iterator 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.
-     */
-    template <class F, class CT>
-    template <class IT>
-    inline auto xfunctor_view<F, CT>::element(IT first, IT last) const -> const_reference
-    {
-        XTENSOR_TRY(check_element_index(shape(), first, last));
-        return m_functor(m_e.element(first, last));
-    }
-
-    /**
-     * Returns a reference to the underlying expression of the view.
-     */
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::expression() noexcept -> xexpression_type&
-    {
-        return m_e;
-    }
-
-    /**
-     * Returns a consttant reference to the underlying expression of the view.
-     */
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::expression() const noexcept -> const xexpression_type&
-    {
-        return m_e;
-    }
-
-    //@}
-
-    /**
-     * @name Broadcasting
-     */
-    //@{
-    /**
-     * Broadcast the shape of the function to the specified parameter.
-     * @param shape the result shape
-     * @param reuse_cache boolean for reusing a previously computed shape
-     * @return a boolean indicating whether the broadcasting is trivial
-     */
-    template <class F, class CT>
-    template <class S>
-    inline bool xfunctor_view<F, CT>::broadcast_shape(S& shape, bool reuse_cache) const
-    {
-        return m_e.broadcast_shape(shape, reuse_cache);
-    }
-
-    /**
-    * Checks whether the xfunctor_view can be linearly assigned to an expression
-    * with the specified strides.
-    * @return a boolean indicating whether a linear assign is possible
-    */
-    template <class F, class CT>
-    template <class S>
-    inline bool xfunctor_view<F, CT>::has_linear_assign(const S& strides) const
-    {
-        return m_e.has_linear_assign(strides);
-    }
-    //@}
-
-    /**
-     * @name Iterators
-     */
-    //@{
-    /**
-     * Returns an iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::begin() noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template begin<L>())>
-            (m_e.template begin<L>(), &m_functor);
-    }
-
-    /**
-     * Returns an iterator to the element following the last element
-     * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::end() noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template end<L>())>
-            (m_e.template end<L>(), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::begin() const noexcept
-    {
-        return this->template cbegin<L>();
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element
-     * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::end() const noexcept
-    {
-        return this->template cend<L>();
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::cbegin() const noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template cbegin<L>())>
-            (m_e.template cbegin<L>(), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element
-     * of the expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::cend() const noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template cend<L>())>
-            (m_e.template cend<L>(), &m_functor);
-    }
-    //@}
-
-    /**
-     * @name Broadcast iterators
-     */
-    //@{
-    /**
-     * Returns a constant iterator to the first element of the expression. The
-     * iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::begin(const S& shape) noexcept -> broadcast_iterator<S, L>
-    {
-        return broadcast_iterator<S, L>(m_e.template begin<S, L>(shape), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element of the
-     * expression. The iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::end(const S& shape) noexcept -> broadcast_iterator<S, L>
-    {
-        return broadcast_iterator<S, L>(m_e.template end<S, L>(shape), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the expression. The
-     * iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::begin(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
-    {
-        return cbegin<S, L>(shape);
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element of the
-     * expression. The iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::end(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
-    {
-        return cend<S, L>(shape);
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the expression. The
-     * iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::cbegin(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
-    {
-        return const_broadcast_iterator<S, L>(m_e.template cbegin<S, L>(shape), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element of the
-     * expression. The iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::cend(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
-    {
-        return const_broadcast_iterator<S, L>(m_e.template cend<S, L>(shape), &m_functor);
-    }
-    //@}
-
-    /**
-     * @name Reverse iterators
-     */
-    //@{
-    /**
-     * Returns an iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::rbegin() noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template rbegin<L>())>
-            (m_e.template rbegin<L>(), &m_functor);
-    }
-
-    /**
-     * Returns an iterator to the element following the last element
-     * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::rend() noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template rend<L>())>
-            (m_e.template rend<L>(), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::rbegin() const noexcept
-    {
-        return this->template crbegin<L>();
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element
-     * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::rend() const noexcept
-    {
-        return this->template crend<L>();
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::crbegin() const noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template rbegin<L>())>
-            (m_e.template rbegin<L>(), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element
-     * of the reversed expression.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <layout_type L>
-    inline auto xfunctor_view<F, CT>::crend() const noexcept
-    {
-        return xfunctor_iterator<functor_type, decltype(m_e.template rend<L>())>
-            (m_e.template rend<L>(), &m_functor);
-    }
-    //@}
-
-    /**
-     * @name Reverse broadcast iterators
-     */
-    /**
-     * Returns an iterator to the first element of the expression. The
-     * iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::rbegin(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
-    {
-        return reverse_broadcast_iterator<S, L>(m_e.template rbegin<S, L>(shape), &m_functor);
-    }
-
-    /**
-     * Returns an iterator to the element following the last element of the
-     * reversed expression. The iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::rend(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
-    {
-        return reverse_broadcast_iterator<S, L>(m_e.template rend<S, L>(shape), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the reversed expression.
-     * The iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::rbegin(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
-    {
-        return crbegin<S, L>(shape);
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element
-     * of the reversed expression.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::rend(const S& /*shape*/) const noexcept -> const_reverse_broadcast_iterator<S, L>
-    {
-        return crend<S, L>();
-    }
-
-    /**
-     * Returns a constant iterator to the first element of the reversed expression.
-     * The iteration is broadcasted to the specified shape.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::crbegin(const S& /*shape*/) const noexcept -> const_reverse_broadcast_iterator<S, L>
-    {
-        return const_reverse_broadcast_iterator<S, L>(m_e.template crbegin<S, L>(), &m_functor);
-    }
-
-    /**
-     * Returns a constant iterator to the element following the last element
-     * of the reversed expression.
-     * @param shape the shape used for broadcasting
-     * @tparam S type of the \c shape parameter.
-     * @tparam L layout used for the traversal. Default value is \c XTENSOR_DEFAULT_LAYOUT.
-     */
-    template <class F, class CT>
-    template <class S, layout_type L>
-    inline auto xfunctor_view<F, CT>::crend(const S& shape) const noexcept -> const_reverse_broadcast_iterator<S, L>
-    {
-        return const_reverse_broadcast_iterator<S, L>(m_e.template crend<S, L>(shape), &m_functor);
-    }
-    //@}
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_begin() noexcept -> storage_iterator
-    {
-        return storage_iterator(m_e.storage_begin(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_end() noexcept -> storage_iterator
-    {
-        return storage_iterator(m_e.storage_end(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_begin() const noexcept -> const_storage_iterator
-    {
-        return const_storage_iterator(m_e.storage_begin(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_end() const noexcept -> const_storage_iterator
-    {
-        return const_storage_iterator(m_e.storage_end(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_cbegin() const noexcept -> const_storage_iterator
-    {
-        return const_storage_iterator(m_e.storage_cbegin(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_cend() const noexcept -> const_storage_iterator
-    {
-        return const_storage_iterator(m_e.storage_cend(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_rbegin() noexcept -> reverse_storage_iterator
-    {
-        return reverse_storage_iterator(m_e.storage_rbegin(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_rend() noexcept -> reverse_storage_iterator
-    {
-        return reverse_storage_iterator(m_e.storage_rend(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_rbegin() const noexcept -> const_reverse_storage_iterator
-    {
-        return const_reverse_storage_iterator(m_e.storage_rbegin(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_rend() const noexcept -> const_reverse_storage_iterator
-    {
-        return const_reverse_storage_iterator(m_e.storage_rend(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_crbegin() const noexcept -> const_reverse_storage_iterator
-    {
-        return const_reverse_storage_iterator(m_e.storage_crbegin(), &m_functor);
-    }
-
-    template <class F, class CT>
-    inline auto xfunctor_view<F, CT>::storage_crend() const noexcept -> const_reverse_storage_iterator
-    {
-        return const_reverse_storage_iterator(m_e.storage_crend(), &m_functor);
-    }
-
-    /***************
-     * stepper api *
-     ***************/
-
-    template <class F, class CT>
-    template <class S>
-    inline auto xfunctor_view<F, CT>::stepper_begin(const S& shape) noexcept -> stepper
-    {
-        return stepper(m_e.stepper_begin(shape), &m_functor);
-    }
-
-    template <class F, class CT>
-    template <class S>
-    inline auto xfunctor_view<F, CT>::stepper_end(const S& shape, layout_type l) noexcept -> stepper
-    {
-        return stepper(m_e.stepper_end(shape, l), &m_functor);
-    }
-
-    template <class F, class CT>
-    template <class S>
-    inline auto xfunctor_view<F, CT>::stepper_begin(const S& shape) const noexcept -> const_stepper
-    {
-        const xexpression_type& const_m_e = m_e;
-        return const_stepper(const_m_e.stepper_begin(shape), &m_functor);
-    }
-
-    template <class F, class CT>
-    template <class S>
-    inline auto xfunctor_view<F, CT>::stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
-    {
-        const xexpression_type& const_m_e = m_e;
-        return const_stepper(const_m_e.stepper_end(shape, l), &m_functor);
-    }
-
-    template <class F, class CT>
-    template <class E>
-    inline auto xfunctor_view<F, CT>::build_functor_view(E&& e) const -> rebind_t<E>
-    {
-        return rebind_t<E>(functor_type(m_functor), std::forward<E>(e));
-    }
-
-    /************************************
-     * xfunctor_iterator implementation *
-     ************************************/
-
-    template <class F, class IT>
-    xfunctor_iterator<F, IT>::xfunctor_iterator(const IT& it, const functor_type* pf)
-        : m_it(it), p_functor(pf)
-    {
-    }
-
-    template <class F, class IT>
-    inline auto xfunctor_iterator<F, IT>::operator++() -> self_type&
-    {
-        ++m_it;
-        return *this;
-    }
-
-    template <class F, class IT>
-    inline auto xfunctor_iterator<F, IT>::operator--() -> self_type&
-    {
-        --m_it;
-        return *this;
-    }
-
-    template <class F, class IT>
-    inline auto xfunctor_iterator<F, IT>::operator+=(difference_type n) -> self_type&
-    {
-        m_it += n;
-        return *this;
-    }
-
-    template <class F, class IT>
-    inline auto xfunctor_iterator<F, IT>::operator-=(difference_type n) -> self_type&
-    {
-        m_it -= n;
-        return *this;
-    }
-
-    template <class F, class IT>
-    inline auto xfunctor_iterator<F, IT>::operator-(xfunctor_iterator rhs) const -> difference_type
-    {
-        return m_it - rhs.m_it;
-    }
-
-    template <class F, class IT>
-    auto xfunctor_iterator<F, IT>::operator*() const -> reference
-    {
-        return xtl::proxy_wrapper((*p_functor)(*m_it));
-    }
-
-    template <class F, class IT>
-    auto xfunctor_iterator<F, IT>::operator->() const -> pointer
-    {
-        return &(operator*());
-    }
-
-    template <class F, class IT>
-    auto xfunctor_iterator<F, IT>::equal(const xfunctor_iterator& rhs) const -> bool
-    {
-        return m_it == rhs.m_it;
-    }
-
-    template <class F, class IT>
-    auto xfunctor_iterator<F, IT>::less_than(const xfunctor_iterator& rhs) const -> bool
-    {
-        return m_it < rhs.m_it;
-    }
-
-    template <class F, class IT>
-    bool operator==(const xfunctor_iterator<F, IT>& lhs,
-                    const xfunctor_iterator<F, IT>& rhs)
-    {
-        return lhs.equal(rhs);
-    }
-
-    template <class F, class IT>
-    bool operator<(const xfunctor_iterator<F, IT>& lhs,
-                   const xfunctor_iterator<F, IT>& rhs)
-    {
-        return !lhs.less_than(rhs);
-    }
-
-    /***********************************
-     * xfunctor_stepper implementation *
-     ***********************************/
-
-    template <class F, class ST>
-    xfunctor_stepper<F, ST>::xfunctor_stepper(const ST& stepper, const functor_type* pf)
-        : m_stepper(stepper), p_functor(pf)
-    {
-    }
-
-    template <class F, class ST>
-    auto xfunctor_stepper<F, ST>::operator*() const -> reference
-    {
-        return (*p_functor)(*m_stepper);
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::step(size_type dim)
-    {
-        m_stepper.step(dim);
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::step_back(size_type dim)
-    {
-        m_stepper.step_back(dim);
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::step(size_type dim, size_type n)
-    {
-        m_stepper.step(dim, n);
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::step_back(size_type dim, size_type n)
-    {
-        m_stepper.step_back(dim, n);
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::reset(size_type dim)
-    {
-        m_stepper.reset(dim);
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::reset_back(size_type dim)
-    {
-        m_stepper.reset_back(dim);
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::to_begin()
-    {
-        m_stepper.to_begin();
-    }
-
-    template <class F, class ST>
-    void xfunctor_stepper<F, ST>::to_end(layout_type l)
-    {
-        m_stepper.to_end(l);
-    }
-}
-#endif
diff --git a/include/xtensor/xhistogram.hpp b/include/xtensor/xhistogram.hpp
deleted file mode 100644
index 09cb251d5..000000000
--- a/include/xtensor/xhistogram.hpp
+++ /dev/null
@@ -1,399 +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. *
-****************************************************************************/
-
-/**
- * @brief construct histogram
- */
-
-#ifndef XTENSOR_HISTOGRAM_HPP
-#define XTENSOR_HISTOGRAM_HPP
-
-#include "xtensor.hpp"
-#include "xsort.hpp"
-
-namespace xt
-{
-    /**
-     * @ingroup histogram
-     * @brief Compute the histogram of a set of data.
-     *
-     * @param data The data.
-     * @param bin_edges The bin-edges.
-     * @param weights Weight factors corresponding to each data-point.
-     * @param density If true the resulting integral is normalized to 1. [default: false]
-     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
-     */
-    template<class R = double, class E1, class E2, class E3>
-    inline auto histogram(E1&& data, E2&& bin_edges, E3&& weights,
-                          bool density = false)
-    {
-        // alias counter and value type
-        using size_type = detail::common_size_type_t<std::decay_t<E1>,std::decay_t<E2>,std::decay_t<E3>>;
-        using value_type = typename std::decay_t<E3>::value_type;
-
-        // basic checks
-        // - rank
-        XTENSOR_ASSERT(data.dimension() == 1);
-        XTENSOR_ASSERT(weights.dimension() == 1);
-        XTENSOR_ASSERT(bin_edges.dimension() == 1);
-        // - size
-        XTENSOR_ASSERT(weights.size() == data.size());
-        XTENSOR_ASSERT(bin_edges.size() >= 2);
-        // - bin-edges must be sorted
-        XTENSOR_ASSERT(std::is_sorted(bin_edges.cbegin(), bin_edges.cend()));
-        // - data must be enclosed in the bins
-        XTENSOR_ASSERT(xt::amin(data)[0] >= bin_edges[0]);
-        XTENSOR_ASSERT(xt::amax(data)[0] <= bin_edges[bin_edges.size() - 1]);
-
-        // initialize output
-        xt::xtensor<value_type, 1> count = xt::zeros<value_type>({bin_edges.size() - 1});
-
-        // indices that sort "data"
-        auto isort = xt::argsort(data);
-
-        // index of the current bin
-        size_type ibin = 0;
-
-        // fill the histogram: loop over (sorted) data
-        for (auto& idx : isort)
-        {
-            // - proceed to the relevant bin
-            while (data[idx] >= bin_edges[ibin+1] && ibin < bin_edges.size() - 2)
-            {
-                ++ibin;
-            }
-            // - update the count
-            count[ibin] += weights[idx];
-        }
-
-        // cast type
-        xt::xtensor<R,1> prob = xt::cast<R>(count);
-
-        // normalize
-        if (density)
-        {
-            // - size as doubles
-            R n = static_cast<R>(data.size());
-            // - apply normalization
-            for (size_type i = 0 ; i < bin_edges.size() - 1 ; ++i)
-            {
-                prob[i] /= (static_cast<R>(bin_edges[i + 1] - bin_edges[i]) * n);
-            }
-        }
-
-        return prob;
-    }
-
-    /**
-     * @ingroup histogram
-     * @brief Compute the histogram of a set of data.
-     *
-     * @param data The data.
-     * @param bin_edges The bin-edges.
-     * @param density If true the resulting integral is normalized to 1. [default: false]
-     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
-     */
-    template<class E1, class E2>
-    inline auto histogram(E1&& data, E2&& bin_edges, bool density = false)
-    {
-        using value_type = typename std::decay_t<E1>::value_type;
-
-        auto n = data.size();
-
-        return histogram(std::forward<E1>(data),
-                         std::forward<E2>(bin_edges),
-                         xt::ones<value_type>({n}),
-                         density);
-    }
-
-    /**
-     * @ingroup histogram
-     * @brief Compute the histogram of a set of data.
-     *
-     * @param data The data.
-     * @param bins The number of bins. [default: 10]
-     * @param density If true the resulting integral is normalized to 1. [default: false]
-     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
-     */
-    template<class E1>
-    inline auto histogram(E1&& data, std::size_t bins = 10, bool density = false)
-    {
-        using value_type = typename std::decay_t<E1>::value_type;
-
-        auto n = data.size();
-
-        auto bin_edges = histogram_bin_edges(data, xt::ones<value_type>({n}), bins);
-
-        return histogram(std::forward<E1>(data), std::forward<E1>(bin_edges),
-                         xt::ones<value_type>({n}), density);
-    }
-
-    /**
-     * @ingroup histogram
-     * @brief Compute the histogram of a set of data.
-     *
-     * @param data The data.
-     * @param bins The number of bins.
-     * @param weights Weight factors corresponding to each data-point.
-     * @param density If true the resulting integral is normalized to 1. [default: false]
-     * @return An one-dimensional xarray<double>, length: bin_edges.size()-1.
-     */
-    template<class E1, class E2>
-    inline auto histogram(E1&& data, std::size_t bins, E2&& weights,
-                          bool density = false)
-    {
-        auto bin_edges = histogram_bin_edges(data, weights, bins);
-
-        return histogram(std::forward<E1>(data), std::forward<E1>(bin_edges),
-            std::forward<E2>(weights), density);
-    }
-
-    /**
-     * @ingroup histogram
-     * @brief Defines different algorithms to be used in "histogram_bin_edges"
-     */
-    enum class histogram_algorithm { automatic, linspace, logspace, uniform };
-
-    /**
-     * @ingroup histogram
-     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
-     *
-     * @param data The data.
-     * @param weights Weight factors corresponding to each data-point.
-     * @param left The lower-most edge.
-     * @param right The upper-most edge.
-     * @param bins The number of bins. [default: 10]
-     * @param mode The type of algorithm to use. [default: "auto"]
-     * @return An one-dimensional xarray<double>, length: bins+1.
-     */
-    template<class E1, class E2, class E3>
-    inline auto histogram_bin_edges(E1&& data, E2&& weights, E3 left, E3 right,
-                                    std::size_t bins = 10,
-                                    histogram_algorithm mode = histogram_algorithm::automatic)
-    {
-        // counter and return type
-        using size_type = detail::common_size_type_t<std::decay_t<E1>,std::decay_t<E2>>;
-        using value_type = typename std::decay_t<E1>::value_type;
-        using weights_type = typename std::decay_t<E2>::value_type;
-
-        // basic checks
-        // - rank
-        XTENSOR_ASSERT(data.dimension() == 1);
-        XTENSOR_ASSERT(weights.dimension() == 1);
-        // - size
-        XTENSOR_ASSERT(weights.size() == data.size());
-        // - bounds
-        XTENSOR_ASSERT(left <= xt::amin(data)[0]);
-        XTENSOR_ASSERT(right >= xt::amax(data)[0]);
-        // - non-empty
-        XTENSOR_ASSERT(bins > std::size_t(0));
-
-        // act on different modes
-        switch(mode)
-        {
-            // bins of equal width
-            case histogram_algorithm::automatic:
-            {
-                xt::xtensor<value_type, 1> bin_edges = xt::linspace<value_type>(left, right, bins + 1);
-                return bin_edges;
-            }
-
-            // bins of equal width
-            case histogram_algorithm::linspace:
-            {
-                xt::xtensor<value_type, 1> bin_edges = xt::linspace<value_type>(left, right, bins + 1);
-                return bin_edges;
-            }
-
-            // bins of logarithmically increasing size
-            case histogram_algorithm::logspace:
-            {
-                using rhs_value_type = std::conditional_t<std::is_integral<value_type>::value, double, value_type>;
-
-                xtensor<value_type, 1> bin_edges = xt::cast<value_type>(
-                    xt::logspace<rhs_value_type>(std::log10(left), std::log10(right), bins + 1));
-
-                // TODO: replace above with below after 'xsimd' fix
-                // xt::xtensor<value_type,1> bin_edges = xt::logspace<value_type>(
-                //     std::log10(left), std::log10(right), bins+1);
-
-                return bin_edges;
-            }
-
-            // same amount of data in each bin
-            case histogram_algorithm::uniform:
-            {
-                // indices that sort "data"
-                auto isort = xt::argsort(data);
-
-                // histogram: all of equal 'height'
-                // - height
-                weights_type w = xt::sum<weights_type>(weights)[0] / static_cast<weights_type>(bins);
-                // - apply to all bins
-                xt::xtensor<weights_type, 1> count = w * xt::ones<weights_type>({bins});
-
-                // take cumulative sum, to act as easy look-up
-                count = xt::cumsum(count);
-
-                // edges
-                // - allocate
-                std::vector<size_t> shape = {bins + 1};
-                xt::xtensor<value_type, 1> bin_edges = xtensor<value_type, 1>::from_shape(shape);
-                // - first/last edge
-                bin_edges[0] = left;
-                bin_edges[bins] = right;
-                // - cumulative weight
-                weights_type cum_weight = static_cast<weights_type>(0);
-                // - current bin
-                size_type ibin = 0;
-                // - loop to find interior bin-edges
-                for (size_type i = 0; i < weights.size(); ++i)
-                {
-                    if (cum_weight >= count[ibin])
-                    {
-                        bin_edges[ibin + 1] = data[isort[i]];
-                        ++ibin;
-                    }
-                    cum_weight += weights[isort[i]];
-                }
-                return bin_edges;
-            }
-            default:
-            {
-                xt::xtensor<value_type, 1> bin_edges = xt::linspace<value_type>(left, right, bins + 1);
-                return bin_edges;
-            }
-        }
-    }
-
-    /**
-     * @ingroup histogram
-     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
-     *
-     * @param data The data.
-     * @param weights Weight factors corresponding to each data-point.
-     * @param bins The number of bins. [default: 10]
-     * @param mode The type of algorithm to use. [default: "auto"]
-     * @return An one-dimensional xarray<double>, length: bins+1.
-     */
-    template<class E1, class E2>
-    inline auto histogram_bin_edges(E1&& data, E2&& weights, std::size_t bins = 10,
-                                    histogram_algorithm mode = histogram_algorithm::automatic)
-    {
-        using value_type = typename std::decay_t<E1>::value_type;
-        std::array<value_type, 2> left_right;
-        left_right = xt::minmax(data)();
-
-        return histogram_bin_edges(std::forward<E1>(data), std::forward<E2>(weights),
-                                   left_right[0], left_right[1], bins, mode);
-    }
-
-    /**
-     * @ingroup histogram
-     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
-     *
-     * @param data The data.
-     * @param bins The number of bins. [default: 10]
-     * @param mode The type of algorithm to use. [default: "auto"]
-     * @return An one-dimensional xarray<double>, length: bins+1.
-     */
-    template<class E1>
-    inline auto histogram_bin_edges(E1&& data, std::size_t bins = 10,
-                                    histogram_algorithm mode = histogram_algorithm::automatic)
-    {
-        using value_type = typename std::decay_t<E1>::value_type;
-
-        auto n = data.size();
-        std::array<value_type, 2> left_right;
-        left_right = xt::minmax(data)();
-
-        return histogram_bin_edges(std::forward<E1>(data), xt::ones<value_type>({n}),
-                                   left_right[0], left_right[1], bins, mode);
-    }
-
-    /**
-     * @ingroup histogram
-     * @brief Compute the bin-edges of a histogram of a set of data using different algorithms.
-     *
-     * @param data The data.
-     * @param left The lower-most edge.
-     * @param right The upper-most edge.
-     * @param bins The number of bins. [default: 10]
-     * @param mode The type of algorithm to use. [default: "auto"]
-     * @return An one-dimensional xarray<double>, length: bins+1.
-     */
-    template<class E1, class E2>
-    inline auto histogram_bin_edges(E1&& data, E2 left, E2 right,
-        std::size_t bins=10, histogram_algorithm mode=histogram_algorithm::automatic
-    )
-    {
-        using value_type = typename std::decay_t<E1>::value_type;
-
-        auto n = data.size();
-
-        return histogram_bin_edges(std::forward<E1>(data), xt::ones<value_type>({n}),
-                                   left, right, bins, mode);
-    }
-
-    /**
-     * Count number of occurrences of each value in array of non-negative ints.
-     * 
-     * The number of bins (of size 1) is one larger than the largest value in x.
-     * If minlength is specified, there will be at least this number of bins in 
-     * the output array (though it will be longer if necessary, depending on the 
-     * contents of x). Each bin gives the number of occurrences of its index 
-     * value in x. If weights is specified the input array is weighted by it, 
-     * i.e. if a value ``n`` is found at position ``i``, ``out[n] += weight[i]``
-     * instead of ``out[n] += 1``.
-     *
-     * @param data the 1D container with integers to count into bins
-     * @param weights a 1D container with the same number of elements as ``data``
-     * @param minlength The minlength
-     *
-     * @return 1D container with the bincount
-     */
-    template <class E1, class E2, XTENSOR_REQUIRE<is_xexpression<std::decay_t<E2>>::value>>
-    inline auto bincount(E1&& data, E2&& weights, std::size_t minlength = 0)
-    {
-        using result_value_type = typename std::decay_t<E2>::value_type;
-        using input_value_type = typename std::decay_t<E1>::value_type;
-        using size_type = typename std::decay_t<E1>::size_type;
-
-        static_assert(std::is_integral<typename std::decay_t<E1>::value_type>::value, "Bincount data has to be integral type.");
-        XTENSOR_ASSERT(data.dimension() == 1);
-        XTENSOR_ASSERT(weights.dimension() == 1);
-
-        std::array<input_value_type, 2> left_right;
-        left_right = xt::minmax(data)();
-
-        if (left_right[0] < input_value_type(0))
-        {
-            throw std::runtime_error("Data argument for bincount can only contain positive integers!");
-        }
-
-        xt::xtensor<result_value_type, 1> res =
-            xt::zeros<result_value_type>({std::max(minlength, std::size_t(left_right[1] + 1))});
-
-        for (size_type i = 0; i < data.size(); ++i)
-        {
-            res(data(i)) += weights(i);
-        }
-
-        return res;
-    }
-
-    template <class E1>
-    inline auto bincount(E1&& data, std::size_t minlength = 0)
-    {
-        return bincount(std::forward<E1>(data),
-                        xt::ones<typename std::decay_t<E1>::value_type>(data.shape()),
-                        minlength);
-    }
-}
-
-#endif
diff --git a/include/xtensor/xmanipulation.hpp b/include/xtensor/xmanipulation.hpp
deleted file mode 100644
index 272b44b5a..000000000
--- a/include/xtensor/xmanipulation.hpp
+++ /dev/null
@@ -1,659 +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. *
-****************************************************************************/
-
-#ifndef XTENSOR_MANIPULATION_HPP
-#define XTENSOR_MANIPULATION_HPP
-
-#include "xstrided_view.hpp"
-#include "xutils.hpp"
-
-namespace xt
-{
-    template <class E>
-    auto transpose(E&& e) noexcept;
-
-    template <class E, class S, class Tag = check_policy::none>
-    auto transpose(E&& e, S&& permutation, Tag check_policy = Tag());
-
-    template <layout_type L, class E>
-    auto ravel(E&& e);
-
-    template <class E>
-    auto flatten(E&& e);
-
-    template <class E>
-    auto trim_zeros(E&& e, const std::string& direction = "fb");
-
-    template <class E>
-    auto squeeze(E&& e);
-
-    template <class E, class S, class Tag = check_policy::none, std::enable_if_t<!std::is_integral<S>::value, int> = 0>
-    auto squeeze(E&& e, S&& axis, Tag check_policy = Tag());
-
-    /****************************
-     * transpose implementation *
-     ****************************/
-
-    namespace detail
-    {
-        inline layout_type transpose_layout_noexcept(layout_type l) noexcept
-        {
-            layout_type result = l;
-            if (l == layout_type::row_major)
-            {
-                result = layout_type::column_major;
-            }
-            else if (l == layout_type::column_major)
-            {
-                result = layout_type::row_major;
-            }
-            return result;
-        }
-
-        inline layout_type transpose_layout(layout_type l)
-        {
-            if (l != layout_type::row_major && l != layout_type::column_major)
-            {
-                throw transpose_error("cannot compute transposed layout of dynamic layout");
-            }
-            return transpose_layout_noexcept(l);
-        }
-
-        template <class E, class S>
-        inline auto transpose_impl(E&& e, S&& permutation, check_policy::none)
-        {
-            if (sequence_size(permutation) != e.dimension())
-            {
-                throw transpose_error("Permutation does not have the same size as shape");
-            }
-
-            // permute stride and shape
-            using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
-            shape_type temp_shape;
-            resize_container(temp_shape, e.shape().size());
-
-            using strides_type = get_strides_t<shape_type>;
-            strides_type temp_strides;
-            resize_container(temp_strides, e.strides().size());
-
-            using size_type = typename std::decay_t<E>::size_type;
-            for (std::size_t i = 0; i < e.shape().size(); ++i)
-            {
-                if (std::size_t(permutation[i]) >= e.dimension())
-                {
-                    throw transpose_error("Permutation contains wrong axis");
-                }
-                size_type perm = static_cast<size_type>(permutation[i]);
-                temp_shape[i] = e.shape()[perm];
-                temp_strides[i] = e.strides()[perm];
-            }
-
-            layout_type new_layout = layout_type::dynamic;
-            if (std::is_sorted(std::begin(permutation), std::end(permutation)))
-            {
-                // keep old layout
-                new_layout = e.layout();
-            }
-            else if (std::is_sorted(std::begin(permutation), std::end(permutation), std::greater<>()))
-            {
-                new_layout = transpose_layout_noexcept(e.layout());
-            }
-
-            using view_type = typename select_strided_view<std::decay_t<E>>::template type<xclosure_t<E>, shape_type>;
-            return view_type(std::forward<E>(e), std::move(temp_shape), std::move(temp_strides), get_offset(e), new_layout);
-        }
-
-        template <class E, class S>
-        inline auto transpose_impl(E&& e, S&& permutation, check_policy::full)
-        {
-            // check if axis appears twice in permutation
-            for (std::size_t i = 0; i < sequence_size(permutation); ++i)
-            {
-                for (std::size_t j = i + 1; j < sequence_size(permutation); ++j)
-                {
-                    if (permutation[i] == permutation[j])
-                    {
-                        throw transpose_error("Permutation contains axis more than once");
-                    }
-                }
-            }
-            return transpose_impl(std::forward<E>(e), std::forward<S>(permutation), check_policy::none());
-        }
-
-        template <class E, class S, class X, std::enable_if_t<has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline void compute_transposed_strides(E&& e, const S&, X& strides)
-        {
-            std::copy(e.strides().crbegin(), e.strides().crend(), strides.begin());
-        }
-
-        template <class E, class S, class X, std::enable_if_t<!has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline void compute_transposed_strides(E&&, const S& shape, X& strides)
-        {
-            layout_type l = transpose_layout(std::decay_t<E>::static_layout);
-            compute_strides(shape, l, strides);
-        }
-    }
-
-    /**
-     * Returns a transpose view by reversing the dimensions of xexpression e
-     * @param e the input expression
-     */
-    template <class E>
-    inline auto transpose(E&& e) noexcept
-    {
-        using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
-        shape_type shape;
-        resize_container(shape, e.shape().size());
-        std::copy(e.shape().crbegin(), e.shape().crend(), shape.begin());
-
-        get_strides_t<shape_type> strides;
-        resize_container(strides, e.shape().size());
-        detail::compute_transposed_strides(e, shape, strides);
-
-        layout_type new_layout = detail::transpose_layout_noexcept(e.layout());
-
-        using view_type = typename select_strided_view<std::decay_t<E>>::template type<xclosure_t<E>, shape_type>;
-        return view_type(std::forward<E>(e), std::move(shape), std::move(strides), detail::get_offset(e), new_layout);
-    }
-
-    /**
-     * Returns a transpose view by permuting the xexpression e with @p permutation.
-     * @param e the input expression
-     * @param permutation the sequence containing permutation
-     * @param check_policy the check level (check_policy::full() or check_policy::none())
-     * @tparam Tag selects the level of error checking on permutation vector defaults to check_policy::none.
-     */
-    template <class E, class S, class Tag>
-    inline auto transpose(E&& e, S&& permutation, Tag check_policy)
-    {
-        return detail::transpose_impl(std::forward<E>(e), std::forward<S>(permutation), check_policy);
-    }
-
-    /// @cond DOXYGEN_INCLUDE_SFINAE
-#ifdef X_OLD_CLANG
-    template <class E, class I, class Tag = check_policy::none>
-    inline auto transpose(E&& e, std::initializer_list<I> permutation, Tag check_policy = Tag())
-    {
-        dynamic_shape<I> perm(permutation);
-        return detail::transpose_impl(std::forward<E>(e), std::move(perm), check_policy);
-    }
-#else
-    template <class E, class I, std::size_t N, class Tag = check_policy::none>
-    inline auto transpose(E&& e, const I(&permutation)[N], Tag check_policy = Tag())
-    {
-        return detail::transpose_impl(std::forward<E>(e), permutation, check_policy);
-    }
-#endif
-    /// @endcond
-
-    /***************************
-     * ravel and flatten views *
-     ***************************/
-
-    namespace detail
-    {
-        template <class E>
-        inline auto build_ravel_view(E&& e)
-        {
-            using shape_type = static_shape<std::size_t, 1>;
-            using view_type = xstrided_view<xclosure_t<E>, shape_type>;
-
-            shape_type new_shape;
-            get_strides_t<shape_type> new_strides;
-            new_shape[0] = e.size();
-            new_strides[0] = std::size_t(1);
-            std::size_t offset = detail::get_offset(e);
-
-            return view_type(std::forward<E>(e),
-                             std::move(new_shape),
-                             std::move(new_strides),
-                             offset,
-                             layout_type::dynamic);
-        }
-
-        template <class E, class S>
-        inline auto build_ravel_view(E&& e, S&& flatten_strides, layout_type l)
-        {
-            using shape_type = static_shape<std::size_t, 1>;
-            using view_type = xstrided_view<xclosure_t<E>, shape_type, layout_type::dynamic, detail::flat_expression_adaptor<std::remove_reference_t<E>>>;
-
-            shape_type new_shape;
-            get_strides_t<shape_type> new_strides;
-            new_shape[0] = e.size();
-            new_strides[0] = std::size_t(1);
-            std::size_t offset = detail::get_offset(e);
-
-            return view_type(std::forward<E>(e),
-                             std::move(new_shape),
-                             std::move(new_strides),
-                             offset,
-                             layout_type::dynamic,
-                             std::move(flatten_strides),
-                             l);
-        }
-
-        template <bool same_layout>
-        struct ravel_impl
-        {
-            template <class E>
-            inline static auto run(E&& e)
-            {
-                return build_ravel_view(std::forward<E>(e));
-            }
-        };
-
-        template <>
-        struct ravel_impl<false>
-        {
-            template <class E>
-            inline static auto run(E&& e)
-            {
-                // Case where the static layout is either row_major or column major.
-                using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
-                get_strides_t<shape_type> strides;
-                resize_container(strides, e.shape().size());
-                layout_type l = detail::transpose_layout(e.layout());
-                compute_strides(e.shape(), l, strides);
-                return build_ravel_view(std::forward<E>(e), std::move(strides), l);
-            }
-        };
-    }
-
-    /**
-     * Returns a flatten view of the given expression. No copy is made.
-     * @param e the input expression
-     * @tparam L the layout used to read the elements of e
-     * @tparam E the type of the expression
-     */
-    template <layout_type L, class E>
-    inline auto ravel(E&& e)
-    {
-        return detail::ravel_impl<std::decay_t<E>::static_layout == L>::run(std::forward<E>(e));
-    }
-
-    /**
-     * Returns a flatten view of the given expression. No copy is made.
-     * The layout used to read the elements is the one of e.
-     * @param e the input expression
-     * @tparam E the type of the expression
-     */
-    template <class E>
-    inline auto flatten(E&& e)
-    {
-        return ravel<std::decay_t<E>::static_layout>(std::forward<E>(e));
-    }
-
-    /**
-     * Trim zeros at beginning, end or both of 1D sequence.
-     *
-     * @param e input xexpression
-     * @param direction string of either 'f' for trim from beginning, 'b' for trim from end
-     *                  or 'fb' (default) for both.
-     * @return returns a view without zeros at the beginning and end
-     */
-    template <class E>
-    inline auto trim_zeros(E&& e, const std::string& direction)
-    {
-        XTENSOR_ASSERT_MSG(e.dimension() == 1, "Dimension for trim_zeros has to be 1.");
-
-        std::ptrdiff_t begin = 0, end = static_cast<std::ptrdiff_t>(e.size());
-
-        auto find_fun = [](const auto& i) {
-            return i != 0;
-        };
-
-        if (direction.find("f") != std::string::npos)
-        {
-            begin = std::find_if(e.cbegin(), e.cend(), find_fun) - e.cbegin();
-        }
-
-        if (direction.find("b") != std::string::npos && begin != end)
-        {
-            end -= std::find_if(e.crbegin(), e.crend(), find_fun) - e.crbegin();
-        }
-
-        return strided_view(std::forward<E>(e), { range(begin, end) });
-    }
-
-    /**
-     * Returns a squeeze view of the given expression. No copy is made.
-     * Squeezing an expression removes dimensions of extent 1.
-     *
-     * @param e the input expression
-     * @tparam E the type of the expression
-     */
-    template <class E>
-    inline auto squeeze(E&& e)
-    {
-        dynamic_shape<std::size_t> new_shape;
-        dynamic_shape<std::ptrdiff_t> new_strides;
-        std::copy_if(e.shape().cbegin(), e.shape().cend(), std::back_inserter(new_shape),
-                     [](std::size_t i) { return i != 1; });
-        decltype(auto) old_strides = detail::get_strides(e);
-        std::copy_if(old_strides.cbegin(), old_strides.cend(), std::back_inserter(new_strides),
-                     [](std::ptrdiff_t i) { return i != 0; });
-
-        using view_type = xstrided_view<xclosure_t<E>, dynamic_shape<std::size_t>>;
-        return view_type(std::forward<E>(e), std::move(new_shape), std::move(new_strides), 0, e.layout());
-    }
-
-    namespace detail
-    {
-        template <class E, class S>
-        inline auto squeeze_impl(E&& e, S&& axis, check_policy::none)
-        {
-            std::size_t new_dim = e.dimension() - axis.size();
-            dynamic_shape<std::size_t> new_shape(new_dim);
-            dynamic_shape<std::ptrdiff_t> new_strides(new_dim);
-
-            decltype(auto) old_strides = detail::get_strides(e);
-
-            for (std::size_t i = 0, ix = 0; i < e.dimension(); ++i)
-            {
-                if (axis.cend() == std::find(axis.cbegin(), axis.cend(), i))
-                {
-                    new_shape[ix] = e.shape()[i];
-                    new_strides[ix++] = old_strides[i];
-                }
-            }
-
-            using view_type = xstrided_view<xclosure_t<E>, dynamic_shape<std::size_t>>;
-            return view_type(std::forward<E>(e), std::move(new_shape), std::move(new_strides), 0, e.layout());
-        }
-
-        template <class E, class S>
-        inline auto squeeze_impl(E&& e, S&& axis, check_policy::full)
-        {
-            for (auto ix : axis)
-            {
-                if (static_cast<std::size_t>(ix) > e.dimension())
-                {
-                    throw std::runtime_error("Axis argument to squeeze > dimension of expression");
-                }
-                if (e.shape()[static_cast<std::size_t>(ix)] != 1)
-                {
-                    throw std::runtime_error("Trying to squeeze axis != 1");
-                }
-            }
-            return squeeze_impl(std::forward<E>(e), std::forward<S>(axis), check_policy::none());
-        }
-    }
-
-    /**
-     * @brief Remove single-dimensional entries from the shape of an xexpression
-     *
-     * @param e input xexpression
-     * @param axis integer or container of integers, select a subset of single-dimensional
-     *        entries of the shape.
-     * @param check_policy select check_policy. With check_policy::full(), selecting an axis
-     *        which is greater than one will throw a runtime_error.
-     */
-    template <class E, class S, class Tag, std::enable_if_t<!std::is_integral<S>::value, int>>
-    inline auto squeeze(E&& e, S&& axis, Tag check_policy)
-    {
-        return detail::squeeze_impl(std::forward<E>(e), std::forward<S>(axis), check_policy);
-    }
-
-    /// @cond DOXYGEN_INCLUDE_SFINAE
-#ifdef X_OLD_CLANG
-    template <class E, class I, class Tag = check_policy::none>
-    inline auto squeeze(E&& e, std::initializer_list<I> axis, Tag check_policy = Tag())
-    {
-        dynamic_shape<I> ax(axis);
-        return detail::squeeze_impl(std::forward<E>(e), std::move(ax), check_policy);
-    }
-#else
-    template <class E, class I, std::size_t N, class Tag = check_policy::none>
-    inline auto squeeze(E&& e, const I(&axis)[N], Tag check_policy = Tag())
-    {
-        using arr_t = std::array<I, N>;
-        return detail::squeeze_impl(std::forward<E>(e), xtl::forward_sequence<arr_t>(axis), check_policy);
-    }
-#endif
-
-    template <class E, class Tag = check_policy::none>
-    inline auto squeeze(E&& e, std::size_t axis, Tag check_policy = Tag())
-    {
-        return squeeze(std::forward<E>(e), std::array<std::size_t, 1>{ axis }, check_policy);
-    }
-    /// @endcond
-
-    /**
-     * @brief Expand the shape of an xexpression.
-     *
-     * Insert a new axis that will appear at the axis position in the expanded array shape.
-     * This will return a ``strided_view`` with a ``xt::newaxis()`` at the indicated axis.
-     *
-     * @param e input xexpression
-     * @param axis axis to expand
-     * @return returns a ``strided_view`` with expanded dimension
-     */
-    template <class E>
-    auto expand_dims(E&& e, std::size_t axis)
-    {
-        xstrided_slice_vector sv(e.dimension() + 1, all());
-        sv[axis] = newaxis();
-        return strided_view(std::forward<E>(e), std::move(sv));
-    }
-
-    /**
-     * Expand dimensions of xexpression to at least `N`
-     *
-     * This adds ``newaxis()`` slices to a ``strided_view`` until
-     * the dimension of the view reaches at least `N`.
-     * Note: dimensions are added equally at the beginning and the end.
-     * For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1).
-     *
-     * @param e input xexpression
-     * @tparam N the number of requested dimensions
-     * @return ``strided_view`` with expanded dimensions
-     */
-    template <std::size_t N, class E>
-    auto atleast_Nd(E&& e)
-    {
-        xstrided_slice_vector sv((std::max)(e.dimension(), N), all());
-        if (e.dimension() < N)
-        {
-            std::size_t i = 0;
-            std::size_t end = static_cast<std::size_t>(std::round(double(N - e.dimension()) / double(N)));
-            for (; i < end; ++i)
-            {
-                sv[i] = newaxis();
-            }
-            i += e.dimension();
-            for (; i < N; ++i)
-            {
-                sv[i] = newaxis();
-            }
-        }
-        return strided_view(std::forward<E>(e), std::move(sv));
-    }
-
-    /**
-     * Expand to at least 1D
-     * @sa atleast_Nd
-     */
-    template <class E>
-    auto atleast_1d(E&& e)
-    {
-        return atleast_Nd<1>(std::forward<E>(e));
-    }
-
-    /**
-     * Expand to at least 2D
-     * @sa atleast_Nd
-     */
-    template <class E>
-    auto atleast_2d(E&& e)
-    {
-        return atleast_Nd<2>(std::forward<E>(e));
-    }
-
-    /**
-     * Expand to at least 3D
-     * @sa atleast_Nd
-     */
-    template <class E>
-    auto atleast_3d(E&& e)
-    {
-        return atleast_Nd<3>(std::forward<E>(e));
-    }
-
-    /**
-     * @brief Split xexpression along axis into subexpressions
-     *
-     * This splits an xexpression along the axis in `n` equal parts and
-     * returns a vector of ``strided_view``.
-     * Calling split with axis > dimension of e or a `n` that does not result in
-     * an equal division of the xexpression will throw a runtime_error.
-     *
-     * @param e input xexpression
-     * @param n number of elements to return
-     * @param axis axis along which to split the expression
-     */
-    template <class E>
-    auto split(E& e, std::size_t n, std::size_t axis = 0)
-    {
-        if (axis >= e.dimension())
-        {
-            throw std::runtime_error("Split along axis > dimension.");
-        }
-
-        std::size_t ax_sz = e.shape()[axis];
-        xstrided_slice_vector sv(e.dimension(), all());
-        std::size_t step = ax_sz / n;
-        std::size_t rest = ax_sz % n;
-
-        if (rest)
-        {
-            throw std::runtime_error("Split does not result in equal division.");
-        }
-
-        std::vector<decltype(strided_view(e, sv))> result;
-        for (std::size_t i = 0; i < n; ++i)
-        {
-            sv[axis] = range(i * step, (i + 1) * step);
-            result.emplace_back(strided_view(e, sv));
-        }
-        return result;
-    }
-
-    /**
-     * @brief Reverse the order of elements in an xexpression along the given axis.
-     * Note: A NumPy/Matlab style `flipud(arr)` is equivalent to `xt::flip(arr, 0)`,
-     * `fliplr(arr)` to `xt::flip(arr, 1)`.
-     *
-     * @param e the input xexpression
-     * @param axis the axis along which elements should be reversed
-     *
-     * @return returns a view with the result of the flip
-     */
-    template <class E>
-    inline auto flip(E&& e, std::size_t axis)
-    {
-        using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
-
-        shape_type shape;
-        resize_container(shape, e.shape().size());
-        std::copy(e.shape().cbegin(), e.shape().cend(), shape.begin());
-
-        get_strides_t<shape_type> strides;
-        decltype(auto) old_strides = detail::get_strides(e);
-        resize_container(strides, old_strides.size());
-        std::copy(old_strides.cbegin(), old_strides.cend(), strides.begin());
-
-        strides[axis] *= -1;
-        std::size_t offset = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(e.data_offset()) + old_strides[axis] * (static_cast<std::ptrdiff_t>(e.shape()[axis]) - 1));
-
-        return strided_view(std::forward<E>(e), std::move(shape), std::move(strides), offset);
-    }
-
-    template <std::ptrdiff_t N>
-    struct rot90_impl;
-
-    template <>
-    struct rot90_impl<0>
-    {
-        template <class E>
-        inline auto operator()(E&& e, const std::array<std::size_t, 2>& /*axes*/)
-        {
-            return std::forward<E>(e);
-        }
-    };
-
-    template <>
-    struct rot90_impl<1>
-    {
-        template <class E>
-        inline auto operator()(E&& e, const std::array<std::size_t, 2>& axes)
-        {
-            using std::swap;
-
-            dynamic_shape<std::ptrdiff_t> axes_list(e.shape().size());
-            std::iota(axes_list.begin(), axes_list.end(), 0);
-            swap(axes_list[axes[0]], axes_list[axes[1]]);
-
-            return transpose(flip(std::forward<E>(e), axes[1]), std::move(axes_list));
-        }
-    };
-
-    template <>
-    struct rot90_impl<2>
-    {
-        template <class E>
-        inline auto operator()(E&& e, const std::array<std::size_t, 2>& axes)
-        {
-            return flip(flip(std::forward<E>(e), axes[0]), axes[1]);
-        }
-    };
-
-    template <>
-    struct rot90_impl<3>
-    {
-        template <class E>
-        inline auto operator()(E&& e, const std::array<std::size_t, 2>& axes)
-        {
-            using std::swap;
-
-            dynamic_shape<std::ptrdiff_t> axes_list(e.shape().size());
-            std::iota(axes_list.begin(), axes_list.end(), 0);
-            swap(axes_list[axes[0]], axes_list[axes[1]]);
-
-            return flip(transpose(std::forward<E>(e), std::move(axes_list)), axes[1]);
-        }
-    };
-
-    /**
-     * @brief Rotate an array by 90 degrees in the plane specified by axes.
-     * Rotation direction is from the first towards the second axis.
-     *
-     * @param e the input xexpression
-     * @param axes the array is rotated in the plane defined by the axes. Axes must be different.
-     * @tparam N number of times the array is rotated by 90 degrees. Default is 1.
-     *
-     * @return returns a view with the result of the rotation
-     */
-    template <std::ptrdiff_t N = 1, class E>
-    inline auto rot90(E&& e, const std::array<std::ptrdiff_t, 2>& axes = {0, 1})
-    {
-        auto ndim = std::ptrdiff_t(e.shape().size());
-
-        if (axes[0] == axes[1] || std::abs(axes[0] - axes[1]) == ndim)
-        {
-            throw std::runtime_error("Axes must be different");
-        }
-
-        auto norm_axes = forward_normalize<std::array<std::size_t, 2>>(e, axes);
-        constexpr std::ptrdiff_t n = (4 + (N % 4)) % 4;
-
-        return rot90_impl<n>()(std::forward<E>(e), norm_axes);
-    }
-}
-
-#endif
diff --git a/include/xtensor/xmasked_value.hpp b/include/xtensor/xmasked_value.hpp
deleted file mode 100644
index 8ee57677b..000000000
--- a/include/xtensor/xmasked_value.hpp
+++ /dev/null
@@ -1,675 +0,0 @@
-/***************************************************************************
-* Copyright (c) 2017, 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. *
-****************************************************************************/
-
-#ifndef XTENSOR_XMASKED_VALUE_HPP
-#define XTENSOR_XMASKED_VALUE_HPP
-
-#include "xtl/xoptional.hpp"
-
-#include "xutils.hpp"
-
-namespace xt
-{
-    template <class T, class B = bool>
-    class xmasked_value;
-}
-
-// Monkey patch on the xtl::common_optional_t implementation
-namespace xtl
-{
-    namespace detail
-    {
-        template <class T1, class T2, class B2>
-        struct common_optional_impl<T1, xt::xmasked_value<T2, B2>>
-            : common_optional_impl<T1, T2>
-        {
-        };
-
-        template <class T1, class B1, class T2>
-        struct common_optional_impl<xt::xmasked_value<T1, B1>, T2>
-            : common_optional_impl<T1, T2>
-        {
-        };
-    }
-}
-
-namespace xt
-{
-    template <class T>
-    inline xmasked_value<T, bool> masked() noexcept
-    {
-        return xmasked_value<T, bool>(T(0), false);
-    }
-
-    namespace detail
-    {
-        template <class E>
-        struct is_xmasked_value_impl : std::false_type
-        {
-        };
-
-        template <class T, class B>
-        struct is_xmasked_value_impl<xmasked_value<T, B>> : std::true_type
-        {
-        };
-    }
-
-    template <class E>
-    using is_xmasked_value = detail::is_xmasked_value_impl<E>;
-
-    template <class E, class R>
-    using disable_xmasked_value = std::enable_if_t<!is_xmasked_value<E>::value, R>;
-
-    template <class E, class R>
-    using disable_xoptional_like = std::enable_if_t<!xtl::is_xoptional<E>::value && !is_xmasked_value<E>::value, R>;
-
-    template <class E1, class E2, class R = void>
-    using disable_both_xoptional_like = std::enable_if_t<
-        !xtl::is_xoptional<E1>::value && !is_xmasked_value<E1>::value &&
-            !xtl::is_xoptional<E2>::value && !is_xmasked_value<E2>::value,
-        R
-    >;
-
-    /****************************
-    * xmasked_value declaration *
-    *****************************/
-
-    template <class T, class B>
-    class xmasked_value
-    {
-    public:
-
-        using self_type = xmasked_value<T, B>;
-
-        using value_type = T;
-        using flag_type = B;
-
-        template <class T1, class B1>
-        constexpr xmasked_value(T1&& value, B1&& flag);
-
-        template <class T1>
-        explicit constexpr xmasked_value(T1&& value);
-
-        explicit constexpr xmasked_value();
-
-        inline operator value_type() {
-            return convert<value_type>();
-        }
-
-        std::add_lvalue_reference_t<T> value() & noexcept;
-        std::add_lvalue_reference_t<std::add_const_t<T>> value() const & noexcept;
-        std::conditional_t<std::is_reference<T>::value, apply_cv_t<T, std::decay_t<T>>&, std::decay_t<T>> value() && noexcept;
-        std::conditional_t<std::is_reference<T>::value, const std::decay_t<T>&, std::decay_t<T>> value() const && noexcept;
-
-        std::add_lvalue_reference_t<B> visible() & noexcept;
-        std::add_lvalue_reference_t<std::add_const_t<B>> visible() const & noexcept;
-        std::conditional_t<std::is_reference<B>::value, apply_cv_t<B, std::decay_t<B>>&, std::decay_t<B>> visible() && noexcept;
-        std::conditional_t<std::is_reference<B>::value, const std::decay_t<B>&, std::decay_t<B>> visible() const && noexcept;
-
-        template <class T1, class B1>
-        bool equal(const xmasked_value<T1, B1>& rhs) const noexcept;
-
-        template <class T1>
-        auto equal(const T1& rhs) const noexcept -> disable_xmasked_value<T1, bool>;
-
-        template <class T1, class B1>
-        void swap(xmasked_value<T1, B1>& other);
-
-#define DEFINE_ASSIGN_OPERATOR(OP)                                                            \
-        template <class T1>                                                                   \
-        inline xmasked_value& operator OP(const T1& rhs)                                      \
-        {                                                                                     \
-            if (m_visible)                                                                    \
-            {                                                                                 \
-                m_value OP rhs;                                                               \
-            }                                                                                 \
-            return *this;                                                                     \
-        }                                                                                     \
-                                                                                              \
-        template <class T1, class B1>                                                         \
-        inline xmasked_value& operator OP(const xmasked_value<T1, B1>& rhs)                   \
-        {                                                                                     \
-            m_visible = m_visible && rhs.visible();                                           \
-            if (m_visible)                                                                    \
-            {                                                                                 \
-                m_value OP rhs.value();                                                       \
-            }                                                                                 \
-            return *this;                                                                     \
-        }
-
-        DEFINE_ASSIGN_OPERATOR(=);
-        DEFINE_ASSIGN_OPERATOR(+=);
-        DEFINE_ASSIGN_OPERATOR(-=);
-        DEFINE_ASSIGN_OPERATOR(*=);
-        DEFINE_ASSIGN_OPERATOR(/=);
-        DEFINE_ASSIGN_OPERATOR(%=);
-        DEFINE_ASSIGN_OPERATOR(&=);
-        DEFINE_ASSIGN_OPERATOR(|=);
-        DEFINE_ASSIGN_OPERATOR(^=);
-#undef DEFINE_ASSIGN_OPERATOR
-
-    private:
-
-        template <class V>
-        std::enable_if_t<xtl::is_xoptional<V>::value, V> convert() const;
-
-        template <class V>
-        std::enable_if_t<!xtl::is_xoptional<V>::value, V> convert() const;
-
-        value_type m_value;
-        flag_type m_visible;
-    };
-
-    /********************************
-     * xmasked_value implementation *
-     ********************************/
-
-    template <class T, class B>
-    template <class T1, class B1>
-    inline constexpr xmasked_value<T, B>::xmasked_value(T1&& value, B1&& flag)
-        : m_value(std::forward<T1>(value)), m_visible(std::forward<B1>(flag))
-    {
-    }
-
-    template <class T, class B>
-    template <class T1>
-    inline constexpr xmasked_value<T, B>::xmasked_value(T1&& value)
-        : m_value(std::forward<T1>(value)), m_visible(true)
-    {
-    }
-
-    template <class T, class B>
-    inline constexpr xmasked_value<T, B>::xmasked_value()
-        : m_value(0), m_visible(true)
-    {
-    }
-
-    template <class T>
-    inline auto masked_value(T&& val)
-    {
-        return xmasked_value<T>(std::forward<T>(val));
-    }
-
-    template <class T, class B>
-    inline auto masked_value(T&& val, B&& mask)
-    {
-        return xmasked_value<T, B>(std::forward<T>(val), std::forward<B>(mask));
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::value() & noexcept -> std::add_lvalue_reference_t<T>
-    {
-        return m_value;
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::value() const & noexcept -> std::add_lvalue_reference_t<std::add_const_t<T>>
-    {
-        return m_value;
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::value() && noexcept -> std::conditional_t<std::is_reference<T>::value, apply_cv_t<T, std::decay_t<T>>&, std::decay_t<T>>
-    {
-        return m_value;
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::value() const && noexcept -> std::conditional_t<std::is_reference<T>::value, const std::decay_t<T>&, std::decay_t<T>>
-    {
-        return m_value;
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::visible() & noexcept -> std::add_lvalue_reference_t<B>
-    {
-        return m_visible;
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::visible() const & noexcept -> std::add_lvalue_reference_t<std::add_const_t<B>>
-    {
-        return m_visible;
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::visible() && noexcept -> std::conditional_t<std::is_reference<B>::value, apply_cv_t<B, std::decay_t<B>>&, std::decay_t<B>>
-    {
-        return m_visible;
-    }
-
-    template <class T, class B>
-    inline auto xmasked_value<T, B>::visible() const && noexcept -> std::conditional_t<std::is_reference<B>::value, const std::decay_t<B>&, std::decay_t<B>>
-    {
-        return m_visible;
-    }
-
-    template <class T, class B>
-    template <class T1, class B1>
-    inline bool xmasked_value<T, B>::equal(const xmasked_value<T1, B1>& rhs) const noexcept
-    {
-        return (!m_visible && !rhs.visible()) || (m_value == rhs.value() && (m_visible && rhs.visible()));
-    }
-
-    template <class T, class B>
-    template <class T1>
-    inline auto xmasked_value<T, B>::equal(const T1& rhs) const noexcept -> disable_xmasked_value<T1, bool>
-    {
-        return m_visible && m_value == rhs;
-    }
-
-    template <class T, class B>
-    template <class T1, class B1>
-    inline void xmasked_value<T, B>::swap(xmasked_value<T1, B1>& other)
-    {
-        using std::swap;
-        swap(m_value, other.m_value);
-        swap(m_visible, other.m_visible);
-    }
-
-    template <class T, class B>
-    template <class V>
-    inline auto xmasked_value<T, B>::convert() const -> std::enable_if_t<xtl::is_xoptional<V>::value, V>
-    {
-        return V(m_value.value(), m_value.has_value() && visible());
-    }
-
-    template <class T, class B>
-    template <class V>
-    inline auto xmasked_value<T, B>::convert() const -> std::enable_if_t<!xtl::is_xoptional<V>::value, V>
-    {
-        return m_value;
-    }
-
-    template <class T1, class B1, class T2, class B2>
-    inline bool operator==(const xmasked_value<T1, B1>& lhs, const xmasked_value<T2, B2>& rhs) noexcept
-    {
-        return lhs.equal(rhs);
-    }
-
-    template <class T1, class B1, class T2, class B2>
-    inline bool operator==(const xmasked_value<T1, B1>& lhs, const xtl::xoptional<T2, B2>& rhs) noexcept
-    {
-        return lhs.equal(rhs);
-    }
-
-    template <class T1, class B1, class T2, class B2>
-    inline bool operator==(const xtl::xoptional<T1, B1>& lhs, const xmasked_value<T2, B2>& rhs) noexcept
-    {
-        return rhs.equal(lhs);
-    }
-
-    template <class T1, class T2, class B2>
-    inline auto operator==(const T1& lhs, const xmasked_value<T2, B2>& rhs) noexcept -> disable_xoptional_like<T1, bool>
-    {
-        return rhs.equal(lhs);
-    }
-
-    template <class T1, class B1, class T2>
-    inline auto operator==(const xmasked_value<T1, B1>& lhs, const T2& rhs) noexcept -> disable_xoptional_like<T2, bool>
-    {
-        return lhs.equal(rhs);
-    }
-
-    template <class T1, class B1, class T2, class B2>
-    inline bool operator!=(const xmasked_value<T1, B1>& lhs, const xmasked_value<T2, B2>& rhs) noexcept
-    {
-        return !lhs.equal(rhs);
-    }
-
-    template <class T1, class B1, class T2, class B2>
-    inline bool operator!=(xmasked_value<T1, B1> lhs, xtl::xoptional<T2, B2> rhs) noexcept
-    {
-        return !lhs.equal(rhs);
-    }
-
-    template <class T1, class B1, class T2, class B2>
-    inline bool operator!=(xtl::xoptional<T1, B1> lhs, xmasked_value<T2, B2> rhs) noexcept
-    {
-        return !rhs.equal(lhs);
-    }
-
-    template <class T1, class T2, class B2>
-    inline auto operator!=(const T1& lhs, const xmasked_value<T2, B2>& rhs) noexcept -> disable_xoptional_like<T1, bool>
-    {
-        return !rhs.equal(lhs);
-    }
-
-    template <class T1, class B1, class T2>
-    inline auto operator!=(const xmasked_value<T1, B1>& lhs, const T2& rhs) noexcept -> disable_xoptional_like<T2, bool>
-    {
-        return !lhs.equal(rhs);
-    }
-
-    template <class T, class B>
-    inline auto operator+(const xmasked_value<T, B>& e) noexcept
-        -> xmasked_value<std::decay_t<T>, std::decay_t<B>>
-    {
-        return xmasked_value<std::decay_t<T>, std::decay_t<B>>(e.value(), e.visible());
-    }
-
-    template <class T, class B>
-    inline auto operator-(const xmasked_value<T, B>& e) noexcept
-        -> xmasked_value<std::decay_t<T>, std::decay_t<B>>
-    {
-        return xmasked_value<std::decay_t<T>, std::decay_t<B>>(-e.value(), e.visible());
-    }
-
-    template <class T, class B>
-    inline auto operator~(const xmasked_value<T, B>& e) noexcept
-        -> xmasked_value<std::decay_t<T>>
-    {
-        using value_type = std::decay_t<T>;
-        return e.visible() ? masked_value(~e.value()) : masked<value_type>();
-    }
-
-    template <class T, class B>
-    inline auto operator!(const xmasked_value<T, B>& e) noexcept
-        -> xmasked_value<bool>
-    {
-        return e.visible() ? masked_value(!e.value()) : masked<bool>();
-    }
-
-    template <class T, class B, class OC, class OT>
-    inline std::basic_ostream<OC, OT>& operator<<(std::basic_ostream<OC, OT>& out, xmasked_value<T, B> v)
-    {
-        if (v.visible())
-        {
-            out << v.value();
-        }
-        else
-        {
-            out << "masked";
-        }
-        return out;
-    }
-
-    template <class T1, class B1, class T2, class B2>
-    inline void swap(xmasked_value<T1, B1>& lhs, xmasked_value<T2, B2>& rhs)
-    {
-        lhs.swap(rhs);
-    }
-
-#define DEFINE_OPERATOR(OP)                                                                                                                \
-    /* Must be implemented in order to fix ambiguity with operators defined in xoptional */                                                \
-    template <class T1, class B1, class T2, class B2>                                                                                      \
-    inline auto operator OP(const xmasked_value<T1, B1>& e1, const xtl::xoptional<T2, B2>& e2) noexcept                                    \
-        -> std::enable_if_t<xtl::is_xoptional<T1>::value, xmasked_value<xtl::common_optional_t<std::decay_t<T1>, xtl::xoptional<T2, B2>>>> \
-    {                                                                                                                                      \
-        using value_type = xtl::common_optional_t<std::decay_t<T1>, xtl::xoptional<T2, B2>>;                                               \
-        return e1.visible() ? masked_value(e1.value() OP e2) : masked<value_type>();                                                       \
-    }                                                                                                                                      \
-                                                                                                                                           \
-    template <class T1, class B1, class T2, class B2>                                                                                      \
-    inline auto operator OP(const xtl::xoptional<T1, B1>& e1, const xmasked_value<T2, B2>& e2) noexcept                                    \
-        -> std::enable_if_t<xtl::is_xoptional<T2>::value, xmasked_value<xtl::common_optional_t<xtl::xoptional<T1, B1>, std::decay_t<T2>>>> \
-    {                                                                                                                                      \
-        using value_type = xtl::common_optional_t<xtl::xoptional<T1, B1>, std::decay_t<T2>>;                                               \
-        return e2.visible() ? masked_value(e1 OP e2.value()) : masked<value_type>();                                                       \
-    }                                                                                                                                      \
-                                                                                                                                           \
-    template <class T1, class B1, class T2, class B2>                                                                                      \
-    inline auto operator OP(const xmasked_value<T1, B1>& e1, const xmasked_value<T2, B2>& e2) noexcept                                     \
-        -> xmasked_value<xt::promote_type_t<std::decay_t<T1>, std::decay_t<T2>>>                                                           \
-    {                                                                                                                                      \
-        using value_type = xt::promote_type_t<std::decay_t<T1>, std::decay_t<T2>>;                                                         \
-        return e1.visible() && e2.visible() ? masked_value(e1.value() OP e2.value()) : masked<value_type>();                               \
-    }                                                                                                                                      \
-                                                                                                                                           \
-    template <class T1, class B1, class T2>                                                                                                \
-    inline auto operator OP(const xmasked_value<T1, B1>& e1, const T2& e2) noexcept                                                        \
-        -> disable_xoptional_like<T2, xmasked_value<xt::promote_type_t<std::decay_t<T1>, std::decay_t<T2>>>>                               \
-    {                                                                                                                                      \
-        using value_type = xt::promote_type_t<std::decay_t<T1>, std::decay_t<T2>>;                                                         \
-        return e1.visible() ? masked_value(e1.value() OP e2) : masked<value_type>();                                                       \
-    }                                                                                                                                      \
-                                                                                                                                           \
-    template <class T1, class T2, class B2>                                                                                                \
-    inline auto operator OP(const T1& e1, const xmasked_value<T2, B2>& e2) noexcept                                                        \
-        -> disable_xoptional_like<T1, xmasked_value<xt::promote_type_t<std::decay_t<T1>, std::decay_t<T2>>>>                               \
-    {                                                                                                                                      \
-        using value_type = xt::promote_type_t<std::decay_t<T1>, std::decay_t<T2>>;                                                         \
-        return e2.visible() ? masked_value(e1 OP e2.value()) : masked<value_type>();                                                       \
-    }
-
-#define DEFINE_BOOL_OPERATOR(OP)                                                                           \
-    /* Must be implemented in order to fix ambiguity with operators defined in xoptional */                \
-    template <class T1, class B1, class T2, class B2>                                                      \
-    inline auto operator OP(const xmasked_value<T1, B1>& e1, const xtl::xoptional<T2, B2>& e2) noexcept    \
-        -> std::enable_if_t<xtl::is_xoptional<T1>::value, xmasked_value<xtl::xoptional<bool>>>             \
-    {                                                                                                      \
-        return e1.visible() ? masked_value(e1.value() OP e2) : masked<xtl::xoptional<bool>>();             \
-    }                                                                                                      \
-                                                                                                           \
-    template <class T1, class B1, class T2, class B2>                                                      \
-    inline auto operator OP(const xtl::xoptional<T1, B1>& e1, const xmasked_value<T2, B2>& e2) noexcept    \
-        -> std::enable_if_t<xtl::is_xoptional<T2>::value, xmasked_value<xtl::xoptional<bool>>>             \
-    {                                                                                                      \
-        return e2.visible() ? masked_value(e1 OP e2.value()) : masked<xtl::xoptional<bool>>();             \
-    }                                                                                                      \
-                                                                                                           \
-    template <class T1, class B1, class T2, class B2>                                                      \
-    inline auto operator OP(const xmasked_value<T1, B1>& e1, const xmasked_value<T2, B2>& e2) noexcept     \
-        -> xmasked_value<decltype(e1.value() OP e2.value())>                                               \
-    {                                                                                                      \
-        return e1.visible() && e2.visible() ?                                                              \
-            masked_value(e1.value() OP e2.value()) :                                                       \
-            masked<decltype(e1.value() OP e2.value())>();                                                  \
-    }                                                                                                      \
-                                                                                                           \
-    template <class T1, class B1, class T2>                                                                \
-    inline auto operator OP(const xmasked_value<T1, B1>& e1, const T2& e2) noexcept                        \
-        -> disable_xoptional_like<T2, xmasked_value<decltype(e1.value() OP e2)>>                           \
-    {                                                                                                      \
-        return e1.visible() ? masked_value(e1.value() OP e2) : masked<decltype(e1.value() OP e2)>();       \
-    }                                                                                                      \
-                                                                                                           \
-    template <class T1, class T2, class B2>                                                                \
-    inline auto operator OP(const T1& e1, const xmasked_value<T2, B2>& e2) noexcept                        \
-        -> disable_xoptional_like<T1, xmasked_value<decltype(e1 OP e2.value())>>                           \
-    {                                                                                                      \
-        return e2.visible() ? masked_value(e1 OP e2.value()) : masked<decltype(e1 OP e2.value())>();       \
-    }
-
-#define DEFINE_UNARY_OPERATOR(OP)                                                     \
-    template <class T, class B>                                                       \
-    inline xmasked_value<std::decay_t<T>> OP(const xmasked_value<T, B>& e)            \
-    {                                                                                 \
-        using std::OP;                                                                \
-        return e.visible() ? masked_value(OP(e.value())) : masked<std::decay_t<T>>(); \
-    }
-
-#define DEFINE_UNARY_BOOL_OPERATOR(OP)                                                        \
-    template <class T, class B>                                                               \
-    inline auto OP(const xmasked_value<T, B>& e)                                              \
-    {                                                                                         \
-        using std::OP;                                                                        \
-        return e.visible() ? masked_value(OP(e.value())) : masked<decltype(OP(e.value()))>(); \
-    }
-
-#define DEFINE_BINARY_OPERATOR(OP)                                                                       \
-    template <class T1, class B1, class T2, class B2>                                                    \
-    inline auto OP(const xmasked_value<T1, B1>& e1, const xmasked_value<T2, B2>& e2)                     \
-    {                                                                                                    \
-        using std::OP;                                                                                   \
-        return e1.visible() && e2.visible() ?                                                            \
-            masked_value(OP(e1.value(), e2.value())) :                                                   \
-            masked<decltype(OP(e1.value(), e2.value()))>();                                              \
-    }                                                                                                    \
-                                                                                                         \
-    template <class T1, class B1, class T2>                                                              \
-    inline auto OP(const xmasked_value<T1, B1>& e1, const T2& e2)                                        \
-    {                                                                                                    \
-        using std::OP;                                                                                   \
-        return e1.visible() ? masked_value(OP(e1.value(), e2)) : masked<decltype(OP(e1.value(), e2))>(); \
-    }                                                                                                    \
-                                                                                                         \
-    template <class T1, class T2, class B2>                                                              \
-    inline auto OP(const T1& e1, const xmasked_value<T2, B2>& e2)                                        \
-    {                                                                                                    \
-        using std::OP;                                                                                   \
-        return e2.visible() ? masked_value(OP(e1, e2.value())) : masked<decltype(OP(e1, e2.value()))>(); \
-    }
-
-#define DEFINE_TERNARY_OPERATOR_MMM(OP)                                                                               \
-    template <class T1, class B1, class T2, class B2, class T3, class B3>                                             \
-    inline auto OP(const xmasked_value<T1, B1>& e1, const xmasked_value<T2, B2>& e2, const xmasked_value<T3, B3>& e3) \
-    {                                                                                                                 \
-        using std::OP;                                                                                                \
-        return (e1.visible() && e2.visible() && e3.visible()) ?                                                       \
-                masked_value(OP(e1.value(), e2.value(), e3.value())) :                                                \
-                masked<decltype(OP(e1.value(), e2.value(), e3.value()))>();                                           \
-    }
-
-#define DEFINE_TERNARY_OPERATOR_MMT(OP)                                                              \
-    template <class T1, class B1, class T2, class B2, class T3>                                      \
-    inline auto OP(const xmasked_value<T1, B1>& e1, const xmasked_value<T2, B2>& e2, const T3& e3)   \
-    {                                                                                                \
-        using std::OP;                                                                               \
-        return (e1.visible() && e2.visible()) ?                                                      \
-                masked_value(OP(e1.value(), e2.value(), e3)) :                                       \
-                masked<decltype(OP(e1.value(), e2.value(), e3))>();                                  \
-    }
-
-#define DEFINE_TERNARY_OPERATOR_MTM(OP)                                                            \
-    template <class T1, class B1, class T2, class T3, class B3>                                    \
-    inline auto OP(const xmasked_value<T1, B1>& e1, const T2& e2, const xmasked_value<T3, B3>& e3) \
-    {                                                                                              \
-        using std::OP;                                                                             \
-        return (e1.visible() && e3.visible()) ?                                                    \
-                masked_value(OP(e1.value(), e2, e3.value())) :                                     \
-                masked<decltype(OP(e1.value(), e2, e3.value()))>();                                \
-    }
-
-#define DEFINE_TERNARY_OPERATOR_TMM(OP)                                                            \
-    template <class T1, class T2, class B2, class T3, class B3>                                    \
-    inline auto OP(const T1& e1, const xmasked_value<T2, B2>& e2, const xmasked_value<T3, B3>& e3) \
-    {                                                                                              \
-        using std::OP;                                                                             \
-        return (e2.visible() && e3.visible()) ?                                                    \
-                masked_value(OP(e1, e2.value(), e3.value())) :                                     \
-                masked<decltype(OP(e1, e2.value(), e3.value()))>();                                \
-    }
-
-#define DEFINE_TERNARY_OPERATOR_TTM(OP)                                         \
-    template <class T1, class T2, class T3, class B3>                           \
-    inline auto OP(const T1& e1, const T2& e2, const xmasked_value<T3, B3>& e3) \
-    {                                                                           \
-        using std::OP;                                                          \
-        return e3.visible() ?                                                   \
-            masked_value(OP(e1, e2, e3.value())) :                              \
-            masked<decltype(OP(e1, e2, e3.value()))>();                         \
-    }
-
-#define DEFINE_TERNARY_OPERATOR_TMT(OP)                                         \
-    template <class T1, class T2, class B2, class T3>                           \
-    inline auto OP(const T1& e1, const xmasked_value<T2, B2>& e2, const T3& e3) \
-    {                                                                           \
-        using std::OP;                                                          \
-        return e2.visible() ?                                                   \
-            masked_value(OP(e1, e2.value(), e3)) :                              \
-            masked<decltype(OP(e1, e2.value(), e3))>();                         \
-    }
-
-#define DEFINE_TERNARY_OPERATOR_MTT(OP)                                         \
-    template <class T1, class B1, class T2, class T3>                           \
-    inline auto OP(const xmasked_value<T1, B1>& e1, const T2& e2, const T3& e3) \
-    {                                                                           \
-        using std::OP;                                                          \
-        return e1.visible() ?                                                   \
-            masked_value(OP(e1.value(), e2, e3)) :                              \
-            masked<decltype(OP(e1.value(), e2, e3))>();                         \
-    }
-
-#define DEFINE_TERNARY_OPERATOR(OP) \
-    DEFINE_TERNARY_OPERATOR_MMM(OP) \
-                                    \
-    DEFINE_TERNARY_OPERATOR_MMT(OP) \
-    DEFINE_TERNARY_OPERATOR_MTM(OP) \
-    DEFINE_TERNARY_OPERATOR_TMM(OP) \
-    DEFINE_TERNARY_OPERATOR_TTM(OP) \
-    DEFINE_TERNARY_OPERATOR_TMT(OP) \
-    DEFINE_TERNARY_OPERATOR_MTT(OP)
-
-    DEFINE_OPERATOR(+);
-    DEFINE_OPERATOR(-);
-    DEFINE_OPERATOR(*);
-    DEFINE_OPERATOR(/);
-    DEFINE_OPERATOR(%);
-    DEFINE_BOOL_OPERATOR(||);
-    DEFINE_BOOL_OPERATOR(&&);
-    DEFINE_OPERATOR(&);
-    DEFINE_OPERATOR(|);
-    DEFINE_OPERATOR(^);
-    DEFINE_BOOL_OPERATOR(<);
-    DEFINE_BOOL_OPERATOR(<=);
-    DEFINE_BOOL_OPERATOR(>);
-    DEFINE_BOOL_OPERATOR(>=);
-    DEFINE_UNARY_OPERATOR(abs)
-    DEFINE_UNARY_OPERATOR(fabs)
-    DEFINE_UNARY_OPERATOR(exp)
-    DEFINE_UNARY_OPERATOR(exp2)
-    DEFINE_UNARY_OPERATOR(expm1)
-    DEFINE_UNARY_OPERATOR(log)
-    DEFINE_UNARY_OPERATOR(log10)
-    DEFINE_UNARY_OPERATOR(log2)
-    DEFINE_UNARY_OPERATOR(log1p)
-    DEFINE_UNARY_OPERATOR(sqrt)
-    DEFINE_UNARY_OPERATOR(cbrt)
-    DEFINE_UNARY_OPERATOR(sin)
-    DEFINE_UNARY_OPERATOR(cos)
-    DEFINE_UNARY_OPERATOR(tan)
-    DEFINE_UNARY_OPERATOR(acos)
-    DEFINE_UNARY_OPERATOR(asin)
-    DEFINE_UNARY_OPERATOR(atan)
-    DEFINE_UNARY_OPERATOR(sinh)
-    DEFINE_UNARY_OPERATOR(cosh)
-    DEFINE_UNARY_OPERATOR(tanh)
-    DEFINE_UNARY_OPERATOR(acosh)
-    DEFINE_UNARY_OPERATOR(asinh)
-    DEFINE_UNARY_OPERATOR(atanh)
-    DEFINE_UNARY_OPERATOR(erf)
-    DEFINE_UNARY_OPERATOR(erfc)
-    DEFINE_UNARY_OPERATOR(tgamma)
-    DEFINE_UNARY_OPERATOR(lgamma)
-    DEFINE_UNARY_OPERATOR(ceil)
-    DEFINE_UNARY_OPERATOR(floor)
-    DEFINE_UNARY_OPERATOR(trunc)
-    DEFINE_UNARY_OPERATOR(round)
-    DEFINE_UNARY_OPERATOR(nearbyint)
-    DEFINE_UNARY_OPERATOR(rint)
-    DEFINE_UNARY_BOOL_OPERATOR(isfinite)
-    DEFINE_UNARY_BOOL_OPERATOR(isinf)
-    DEFINE_UNARY_BOOL_OPERATOR(isnan)
-    DEFINE_BINARY_OPERATOR(fmod)
-    DEFINE_BINARY_OPERATOR(remainder)
-    DEFINE_BINARY_OPERATOR(fmax)
-    DEFINE_BINARY_OPERATOR(fmin)
-    DEFINE_BINARY_OPERATOR(fdim)
-    DEFINE_BINARY_OPERATOR(pow)
-    DEFINE_BINARY_OPERATOR(hypot)
-    DEFINE_BINARY_OPERATOR(atan2)
-    DEFINE_TERNARY_OPERATOR(fma)
-
-#undef DEFINE_TERNARY_OPERATOR
-#undef DEFINE_TERNARY_OPERATOR_MMM
-#undef DEFINE_TERNARY_OPERATOR_MMT
-#undef DEFINE_TERNARY_OPERATOR_MTM
-#undef DEFINE_TERNARY_OPERATOR_TMM
-#undef DEFINE_TERNARY_OPERATOR_TTM
-#undef DEFINE_TERNARY_OPERATOR_TMT
-#undef DEFINE_TERNARY_OPERATOR_MTT
-#undef DEFINE_BINARY_OPERATOR
-#undef DEFINE_UNARY_OPERATOR
-#undef DEFINE_UNARY_BOOL_OPERATOR
-#undef DEFINE_OPERATOR
-#undef DEFINE_BOOL_OPERATOR
-}
-
-#endif
diff --git a/include/xtensor/xmath.hpp b/include/xtensor/xmath.hpp
deleted file mode 100644
index d8c3cfabc..000000000
--- a/include/xtensor/xmath.hpp
+++ /dev/null
@@ -1,2575 +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. *
-****************************************************************************/
-
-/**
- * @brief standard mathematical functions for xexpressions
- */
-
-#ifndef XTENSOR_MATH_HPP
-#define XTENSOR_MATH_HPP
-
-#include <cmath>
-#include <algorithm>
-#include <array>
-#include <complex>
-#include <type_traits>
-
-#include <xtl/xcomplex.hpp>
-
-#include "xaccumulator.hpp"
-#include "xoperation.hpp"
-#include "xreducer.hpp"
-#include "xslice.hpp"
-#include "xstrided_view.hpp"
-#include "xeval.hpp"
-
-namespace xt
-{
-    template <class T = double>
-    struct numeric_constants
-    {
-        static constexpr T PI = 3.141592653589793238463;
-        static constexpr T PI_2 = 1.57079632679489661923;
-        static constexpr T PI_4 = 0.785398163397448309616;
-        static constexpr T D_1_PI = 0.318309886183790671538;
-        static constexpr T D_2_PI = 0.636619772367581343076;
-        static constexpr T D_2_SQRTPI = 1.12837916709551257390;
-        static constexpr T SQRT2 = 1.41421356237309504880;
-        static constexpr T SQRT1_2 = 0.707106781186547524401;
-        static constexpr T E = 2.71828182845904523536;
-        static constexpr T LOG2E = 1.44269504088896340736;
-        static constexpr T LOG10E = 0.434294481903251827651;
-        static constexpr T LN2 = 0.693147180559945309417;
-    };
-
-    /***********
-     * Helpers *
-     ***********/
-
-#define XTENSOR_UNSIGNED_ABS_FUNC(T)                                              \
-constexpr inline T abs(const T& x)                                                \
-{                                                                                 \
-    return x;                                                                     \
-}                                                                                 \
-
-#define XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, T)                 \
-constexpr inline bool FUNC_NAME(const T& /*x*/) noexcept                          \
-{                                                                                 \
-    return RETURN_VAL;                                                            \
-}                                                                                 \
-
-#define XTENSOR_INT_SPECIALIZATION(FUNC_NAME, RETURN_VAL)                         \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, char);                     \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, short);                    \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, int);                      \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, long);                     \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, long long);                \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned char);            \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned short);           \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned int);             \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned long);            \
-XTENSOR_INT_SPECIALIZATION_IMPL(FUNC_NAME, RETURN_VAL, unsigned long long);       \
-
-
-#define XTENSOR_UNARY_MATH_FUNCTOR_IMPL(NAME, R)                                  \
-    struct NAME##_fun                                                             \
-    {                                                                             \
-        template <class T>                                                        \
-        constexpr auto operator()(const T& arg) const                             \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg);                                                     \
-        }                                                                         \
-        template <class B>                                                        \
-        constexpr auto simd_apply(const B& arg) const                             \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg);                                                     \
-        }                                                                         \
-    }
-
-#define XTENSOR_UNARY_MATH_FUNCTOR(NAME) XTENSOR_UNARY_MATH_FUNCTOR_IMPL(NAME, T)
-#define XTENSOR_UNARY_BOOL_FUNCTOR(NAME) XTENSOR_UNARY_MATH_FUNCTOR_IMPL(NAME, bool)
-
-#define XTENSOR_UNARY_MATH_FUNCTOR_COMPLEX_REDUCING(NAME)                         \
-    struct NAME##_fun                                                             \
-    {                                                                             \
-        template <class T>                                                        \
-        constexpr auto operator()(const T& arg) const                             \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg);                                                     \
-        }                                                                         \
-        template <class B>                                                        \
-        constexpr auto simd_apply(const B& arg) const                             \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg);                                                     \
-        }                                                                         \
-    }
-
-#define XTENSOR_BINARY_MATH_FUNCTOR_IMPL(NAME, R)                                 \
-    struct NAME##_fun                                                             \
-    {                                                                             \
-        template <class T1, class T2>                                             \
-        constexpr auto operator()(const T1& arg1, const T2& arg2) const           \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg1, arg2);                                              \
-        }                                                                         \
-        template <class B>                                                        \
-        constexpr auto simd_apply(const B& arg1, const B& arg2) const             \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg1, arg2);                                              \
-        }                                                                         \
-    }
-
-#define XTENSOR_BINARY_MATH_FUNCTOR(NAME) XTENSOR_BINARY_MATH_FUNCTOR_IMPL(NAME, T)
-#define XTENSOR_BINARY_BOOL_FUNCTOR(NAME) XTENSOR_BINARY_MATH_FUNCTOR_IMPL(NAME, bool)
-
-#define XTENSOR_TERNARY_MATH_FUNCTOR_IMPL(NAME, R)                                \
-    struct NAME##_fun                                                             \
-    {                                                                             \
-        template <class T1, class T2, class T3>                                   \
-        constexpr auto operator()(const T1& arg1,                                 \
-                                  const T2& arg2,                                 \
-                                  const T3& arg3) const                           \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg1, arg2, arg3);                                        \
-        }                                                                         \
-        template <class B>                                                        \
-        auto simd_apply(const B& arg1, const B& arg2, const B& arg3) const        \
-        {                                                                         \
-            using math::NAME;                                                     \
-            return NAME(arg1, arg2, arg3);                                        \
-        }                                                                         \
-    }
-
-#define XTENSOR_TERNARY_MATH_FUNCTOR(NAME) XTENSOR_TERNARY_MATH_FUNCTOR_IMPL(NAME, T)
-#define XTENSOR_TERNARY_BOOL_FUNCTOR(NAME) XTENSOR_TERNARY_MATH_FUNCTOR_IMPL(NAME, bool)
-
-    namespace math
-    {
-        using std::abs;
-        using std::fabs;
-
-        using std::cos;
-        using std::sin;
-        using std::tan;
-        using std::acos;
-        using std::asin;
-        using std::atan;
-
-        using std::cosh;
-        using std::sinh;
-        using std::tanh;
-        using std::acosh;
-        using std::asinh;
-        using std::atanh;
-
-        using std::sqrt;
-        using std::cbrt;
-
-        using std::exp;
-        using std::exp2;
-        using std::expm1;
-        using std::log;
-        using std::log2;
-        using std::log10;
-        using std::log1p;
-        using std::logb;
-        using std::ilogb;
-
-        using std::floor;
-        using std::ceil;
-        using std::trunc;
-        using std::round;
-        using std::lround;
-        using std::llround;
-        using std::rint;
-        using std::nearbyint;
-        using std::remainder;
-
-        using std::erf;
-        using std::erfc;
-        using std::erfc;
-        using std::tgamma;
-        using std::lgamma;
-
-        using std::conj;
-        using std::real;
-        using std::imag;
-        using std::arg;
-
-        using std::atan2;
-
-// copysign is not in the std namespace for MSVC
-#if !defined(_MSC_VER)
-        using std::copysign;
-#endif
-        using std::fdim;
-        using std::fmax;
-        using std::fmin;
-        using std::fmod;
-        using std::hypot;
-        using std::pow;
-
-        using std::fma;
-
-        using std::isnan;
-        using std::isinf;
-        using std::isfinite;
-        using std::fpclassify;
-
-        // Overload isinf, isnan and isfinite for complex datatypes,
-        // following the Python specification:
-        template <class T>
-        inline bool isinf(const std::complex<T>& c)
-        {
-            return std::isinf(std::real(c)) || std::isinf(std::imag(c));
-        }
-
-        template <class T>
-        inline bool isnan(const std::complex<T>& c)
-        {
-            return std::isnan(std::real(c)) || std::isnan(std::imag(c));
-        }
-
-        template <class T>
-        inline bool isfinite(const std::complex<T>& c)
-        {
-            return !isinf(c) && !isnan(c);
-        }
-
-        // The following specializations are needed to avoid 'ambiguous overload' errors,
-        // whereas 'unsigned char' and 'unsigned short' are automatically converted to 'int'.
-        // we're still adding those functions to silence warnings
-        XTENSOR_UNSIGNED_ABS_FUNC(unsigned char)
-        XTENSOR_UNSIGNED_ABS_FUNC(unsigned short)
-        XTENSOR_UNSIGNED_ABS_FUNC(unsigned int)
-        XTENSOR_UNSIGNED_ABS_FUNC(unsigned long)
-        XTENSOR_UNSIGNED_ABS_FUNC(unsigned long long)
-
-#ifdef _WIN32
-        XTENSOR_INT_SPECIALIZATION(isinf, false);
-        XTENSOR_INT_SPECIALIZATION(isnan, false);
-        XTENSOR_INT_SPECIALIZATION(isfinite, true);
-#endif
-
-        XTENSOR_UNARY_MATH_FUNCTOR_COMPLEX_REDUCING(abs);
-
-        XTENSOR_UNARY_MATH_FUNCTOR(fabs);
-        XTENSOR_BINARY_MATH_FUNCTOR(fmod);
-        XTENSOR_BINARY_MATH_FUNCTOR(remainder);
-        XTENSOR_TERNARY_MATH_FUNCTOR(fma);
-        XTENSOR_BINARY_MATH_FUNCTOR(fmax);
-        XTENSOR_BINARY_MATH_FUNCTOR(fmin);
-        XTENSOR_BINARY_MATH_FUNCTOR(fdim);
-        XTENSOR_UNARY_MATH_FUNCTOR(exp);
-        XTENSOR_UNARY_MATH_FUNCTOR(exp2);
-        XTENSOR_UNARY_MATH_FUNCTOR(expm1);
-        XTENSOR_UNARY_MATH_FUNCTOR(log);
-        XTENSOR_UNARY_MATH_FUNCTOR(log10);
-        XTENSOR_UNARY_MATH_FUNCTOR(log2);
-        XTENSOR_UNARY_MATH_FUNCTOR(log1p);
-        XTENSOR_BINARY_MATH_FUNCTOR(pow);
-        XTENSOR_UNARY_MATH_FUNCTOR(sqrt);
-        XTENSOR_UNARY_MATH_FUNCTOR(cbrt);
-        XTENSOR_BINARY_MATH_FUNCTOR(hypot);
-        XTENSOR_UNARY_MATH_FUNCTOR(sin);
-        XTENSOR_UNARY_MATH_FUNCTOR(cos);
-        XTENSOR_UNARY_MATH_FUNCTOR(tan);
-        XTENSOR_UNARY_MATH_FUNCTOR(asin);
-        XTENSOR_UNARY_MATH_FUNCTOR(acos);
-        XTENSOR_UNARY_MATH_FUNCTOR(atan);
-        XTENSOR_BINARY_MATH_FUNCTOR(atan2);
-        XTENSOR_UNARY_MATH_FUNCTOR(sinh);
-        XTENSOR_UNARY_MATH_FUNCTOR(cosh);
-        XTENSOR_UNARY_MATH_FUNCTOR(tanh);
-        XTENSOR_UNARY_MATH_FUNCTOR(asinh);
-        XTENSOR_UNARY_MATH_FUNCTOR(acosh);
-        XTENSOR_UNARY_MATH_FUNCTOR(atanh);
-        XTENSOR_UNARY_MATH_FUNCTOR(erf);
-        XTENSOR_UNARY_MATH_FUNCTOR(erfc);
-        XTENSOR_UNARY_MATH_FUNCTOR(tgamma);
-        XTENSOR_UNARY_MATH_FUNCTOR(lgamma);
-        XTENSOR_UNARY_MATH_FUNCTOR(ceil);
-        XTENSOR_UNARY_MATH_FUNCTOR(floor);
-        XTENSOR_UNARY_MATH_FUNCTOR(trunc);
-        XTENSOR_UNARY_MATH_FUNCTOR(round);
-        XTENSOR_UNARY_MATH_FUNCTOR(nearbyint);
-        XTENSOR_UNARY_MATH_FUNCTOR(rint);
-        XTENSOR_UNARY_BOOL_FUNCTOR(isfinite);
-        XTENSOR_UNARY_BOOL_FUNCTOR(isinf);
-        XTENSOR_UNARY_BOOL_FUNCTOR(isnan);
-    }
-
-#undef XTENSOR_UNARY_MATH_FUNCTOR
-#undef XTENSOR_UNARY_BOOL_FUNCTOR
-#undef XTENSOR_UNARY_MATH_FUNCTOR_IMPL
-#undef XTENSOR_BINARY_MATH_FUNCTOR
-#undef XTENSOR_BINARY_BOOL_FUNCTOR
-#undef XTENSOR_BINARY_MATH_FUNCTOR_IMPL
-#undef XTENSOR_TERNARY_MATH_FUNCTOR
-#undef XTENSOR_TERNARY_BOOL_FUNCTOR
-#undef XTENSOR_TERNARY_MATH_FUNCTOR_IMPL
-#undef XTENSOR_UNARY_MATH_FUNCTOR_COMPLEX_REDUCING
-#undef XTENSOR_UNSIGNED_ABS_FUNC
-
-#define XTENSOR_REDUCER_FUNCTION(NAME, FUNCTOR, RESULT_TYPE)                                                      \
-    template <class T = void, class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,                            \
-              class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value        \
-                        && !std::is_integral<X>::value, int>>                                                     \
-    inline auto NAME(E&& e, X&& axes, EVS es = EVS())                                                             \
-    {                                                                                                             \
-        using result_type = std::conditional_t<std::is_same<T, void>::value, RESULT_TYPE, T>;                     \
-        using functor_type = FUNCTOR<result_type>;                                                                \
-        return reduce(make_xreducer_functor(functor_type()), std::forward<E>(e),                                  \
-                      std::forward<X>(axes), es);                                                                 \
-    }                                                                                                             \
-                                                                                                                  \
-    template <class T = void, class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,                            \
-              class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value        \
-                        && std::is_integral<X>::value, int>>                                                      \
-    inline auto NAME(E&& e, X axis, EVS es = EVS())                                                                \
-    {                                                                                                             \
-        return NAME(std::forward<E>(e), {axis}, es);                                                               \
-    }                                                                                                             \
-                                                                                                                  \
-    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS,                                     \
-              class = std::enable_if_t<std::is_base_of<evaluation_strategy::base, EVS>::value, int>>              \
-    inline auto NAME(E&& e, EVS es = EVS())                                                                       \
-    {                                                                                                             \
-        using result_type = std::conditional_t<std::is_same<T, void>::value, RESULT_TYPE, T>;                     \
-        using functor_type = FUNCTOR<result_type>;                                                                \
-        return reduce(make_xreducer_functor(functor_type()), std::forward<E>(e), es);                             \
-    }
-
-#define XTENSOR_OLD_CLANG_REDUCER(NAME, FUNCTOR, RESULT_TYPE)                                                     \
-    template <class T = void, class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>                            \
-    inline auto NAME(E&& e, std::initializer_list<I> axes, EVS es = EVS())                                        \
-    {                                                                                                             \
-        using result_type = std::conditional_t<std::is_same<T, void>::value, RESULT_TYPE, T>;                     \
-        using functor_type = FUNCTOR<result_type>;                                                                \
-        return reduce(make_xreducer_functor(functor_type()), std::forward<E>(e), axes, es);                       \
-    }
-
-#define XTENSOR_MODERN_CLANG_REDUCER(NAME, FUNCTOR, RESULT_TYPE)                                                  \
-    template <class T = void, class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>             \
-    inline auto NAME(E&& e, const I (&axes)[N], EVS es = EVS())                                                   \
-    {                                                                                                             \
-        using result_type = std::conditional_t<std::is_same<T, void>::value, RESULT_TYPE, T>;                     \
-        using functor_type = FUNCTOR<result_type>;                                                                \
-        return reduce(make_xreducer_functor(functor_type()), std::forward<E>(e), axes, es);                       \
-    }
-
-    /*******************
-     * basic functions *
-     *******************/
-
-    /**
-     * @defgroup basic_functions Basic functions
-     */
-
-    /**
-     * @ingroup basic_functions
-     * @brief Absolute value function.
-     *
-     * Returns an \ref xfunction for the element-wise absolute value
-     * of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto abs(E&& e) noexcept
-        -> detail::xfunction_type_t<math::abs_fun, E>
-    {
-        return detail::make_xfunction<math::abs_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Absolute value function.
-     *
-     * Returns an \ref xfunction for the element-wise absolute value
-     * of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto fabs(E&& e) noexcept
-        -> detail::xfunction_type_t<math::fabs_fun, E>
-    {
-        return detail::make_xfunction<math::fabs_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Remainder of the floating point division operation.
-     *
-     * Returns an \ref xfunction for the element-wise remainder of
-     * the floating point division operation <em>e1 / e2</em>.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto fmod(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::fmod_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::fmod_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Signed remainder of the division operation.
-     *
-     * Returns an \ref xfunction for the element-wise signed remainder
-     * of the floating point division operation <em>e1 / e2</em>.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto remainder(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::remainder_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::remainder_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Fused multiply-add operation.
-     *
-     * Returns an \ref xfunction for <em>e1 * e2 + e3</em> as if
-     * to infinite precision and rounded only once to fit the result type.
-     * @param e1 an \ref xfunction or a scalar
-     * @param e2 an \ref xfunction or a scalar
-     * @param e3 an \ref xfunction or a scalar
-     * @return an \ref xfunction
-     * @note e1, e2 and e3 can't be scalars every three.
-     */
-    template <class E1, class E2, class E3>
-    inline auto fma(E1&& e1, E2&& e2, E3&& e3) noexcept
-        -> detail::xfunction_type_t<math::fma_fun, E1, E2, E3>
-    {
-        return detail::make_xfunction<math::fma_fun>(std::forward<E1>(e1), std::forward<E2>(e2), std::forward<E3>(e3));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Maximum function.
-     *
-     * Returns an \ref xfunction for the element-wise maximum
-     * of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto fmax(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::fmax_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::fmax_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Minimum function.
-     *
-     * Returns an \ref xfunction for the element-wise minimum
-     * of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto fmin(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::fmin_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::fmin_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Positive difference function.
-     *
-     * Returns an \ref xfunction for the element-wise positive
-     * difference of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto fdim(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::fdim_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::fdim_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    namespace math
-    {
-        template <class T = void>
-        struct minimum
-        {
-            template <class A1, class A2>
-            constexpr auto operator()(const A1& t1, const A2& t2) const noexcept
-            {
-                return (t1 < t2) ? t1 : t2;
-            }
-
-            template <class A1, class A2>
-            constexpr auto simd_apply(const A1& t1, const A2& t2) const noexcept
-            {
-                return xsimd::select(t1 < t2, t1, t2);
-            }
-        };
-
-        template <class T = void>
-        struct maximum
-        {
-            template <class A1, class A2>
-            constexpr auto operator()(const A1& t1, const A2& t2) const noexcept
-            {
-                return (t1 > t2) ? t1 : t2;
-            }
-
-            template <class A1, class A2>
-            constexpr auto simd_apply(const A1& t1, const A2& t2) const noexcept
-            {
-                return xsimd::select(t1 > t2, t1, t2);
-            }
-        };
-
-        struct clamp_fun
-        {
-            template <class A1, class A2, class A3>
-            constexpr auto operator()(const A1& v, const A2& lo, const A3& hi) const
-            {
-                return v < lo ? lo : hi < v ? hi : v;
-            }
-
-            template <class A1, class A2, class A3>
-            constexpr auto simd_apply(const A1& v,
-                                      const A2& lo,
-                                      const A3& hi) const
-            {
-                return xsimd::select(v < lo, lo, xsimd::select(hi < v, hi, v));
-            }
-        };
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Elementwise maximum
-     *
-     * Returns an \ref xfunction for the element-wise
-     * maximum between e1 and e2.
-     * @param e1 an \ref xexpression
-     * @param e2 an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto maximum(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::maximum<void>, E1, E2>
-    {
-        return detail::make_xfunction<math::maximum<void>>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Elementwise minimum
-     *
-     * Returns an \ref xfunction for the element-wise
-     * minimum between e1 and e2.
-     * @param e1 an \ref xexpression
-     * @param e2 an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto minimum(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::minimum<void>, E1, E2>
-    {
-        return detail::make_xfunction<math::minimum<void>>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Maximum element along given axis.
-     *
-     * Returns an \ref xreducer for the maximum of elements over given
-     * \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the maximum is found (optional)
-     * @param es evaluation strategy of the reducer
-     * @return an \ref xreducer
-     */
-    XTENSOR_REDUCER_FUNCTION(amax, math::maximum, typename std::decay_t<E>::value_type)
-#ifdef X_OLD_CLANG
-    XTENSOR_OLD_CLANG_REDUCER(amax, math::maximum, typename std::decay_t<E>::value_type)
-#else
-    XTENSOR_MODERN_CLANG_REDUCER(amax, math::maximum, typename std::decay_t<E>::value_type)
-#endif
-
-    /**
-     * @ingroup basic_functions
-     * @brief Minimum element along given axis.
-     *
-     * Returns an \ref xreducer for the minimum of elements over given
-     * \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the minimum is found (optional)
-     * @param es evaluation strategy of the reducer
-     * @return an \ref xreducer
-     */
-    XTENSOR_REDUCER_FUNCTION(amin, math::minimum, typename std::decay_t<E>::value_type)
-#ifdef X_OLD_CLANG
-    XTENSOR_OLD_CLANG_REDUCER(amin, math::minimum, typename std::decay_t<E>::value_type)
-#else
-    XTENSOR_MODERN_CLANG_REDUCER(amin, math::minimum, typename std::decay_t<E>::value_type)
-#endif
-
-    /**
-     * @ingroup basic_functions
-     * @brief Clip values between hi and lo
-     *
-     * Returns an \ref xfunction for the element-wise clipped
-     * values between lo and hi
-     * @param e1 an \ref xexpression or a scalar
-     * @param lo a scalar
-     * @param hi a scalar
-     *
-     * @return a \ref xfunction
-     */
-    template <class E1, class E2, class E3>
-    inline auto clip(E1&& e1, E2&& lo, E3&& hi) noexcept
-        -> detail::xfunction_type_t<math::clamp_fun, E1, E2, E3>
-    {
-        return detail::make_xfunction<math::clamp_fun>(std::forward<E1>(e1), std::forward<E2>(lo), std::forward<E3>(hi));
-    }
-
-    namespace math
-    {
-        template <class T>
-        struct sign_impl
-        {
-            template <class XT = T>
-            static constexpr std::enable_if_t<std::is_signed<XT>::value, T> run(T x)
-            {
-                return std::isnan(x) ? std::numeric_limits<T>::quiet_NaN() : x == 0 ? T(copysign(T(0), x)) : T(copysign(T(1), x));
-            }
-
-            template <class XT = T>
-            static constexpr std::enable_if_t<xtl::is_complex<XT>::value, T> run(T x)
-            {
-                return T(sign_impl<typename T::value_type>::run((x.real() != typename T::value_type(0)) ? x.real() : x.imag()), 0);
-            }
-
-            template <class XT = T>
-            static constexpr std::enable_if_t<std::is_unsigned<XT>::value, T> run(T x)
-            {
-                return T(x > T(0));
-            }
-        };
-
-        struct sign_fun
-        {
-            template <class T>
-            constexpr auto operator()(const T& x) const
-            {
-                return sign_impl<T>::run(x);
-            }
-        };
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Returns an element-wise indication of the sign of a number
-     *
-     * If the number is positive, returns +1. If negative, -1. If the number
-     * is zero, returns 0.
-     *
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto sign(E&& e) noexcept
-        -> detail::xfunction_type_t<math::sign_fun, E>
-    {
-        return detail::make_xfunction<math::sign_fun>(std::forward<E>(e));
-    }
-
-    /*************************
-     * exponential functions *
-     *************************/
-
-    /**
-     * @defgroup exp_functions Exponential functions
-     */
-
-    /**
-     * @ingroup exp_functions
-     * @brief Natural exponential function.
-     *
-     * Returns an \ref xfunction for the element-wise natural
-     * exponential of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto exp(E&& e) noexcept
-        -> detail::xfunction_type_t<math::exp_fun, E>
-    {
-        return detail::make_xfunction<math::exp_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup exp_functions
-     * @brief Base 2 exponential function.
-     *
-     * Returns an \ref xfunction for the element-wise base 2
-     * exponential of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto exp2(E&& e) noexcept
-        -> detail::xfunction_type_t<math::exp2_fun, E>
-    {
-        return detail::make_xfunction<math::exp2_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup exp_functions
-     * @brief Natural exponential minus one function.
-     *
-     * Returns an \ref xfunction for the element-wise natural
-     * exponential of \em e, minus 1.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto expm1(E&& e) noexcept
-        -> detail::xfunction_type_t<math::expm1_fun, E>
-    {
-        return detail::make_xfunction<math::expm1_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup exp_functions
-     * @brief Natural logarithm function.
-     *
-     * Returns an \ref xfunction for the element-wise natural
-     * logarithm of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto log(E&& e) noexcept
-        -> detail::xfunction_type_t<math::log_fun, E>
-    {
-        return detail::make_xfunction<math::log_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup exp_functions
-     * @brief Base 10 logarithm function.
-     *
-     * Returns an \ref xfunction for the element-wise base 10
-     * logarithm of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto log10(E&& e) noexcept
-        -> detail::xfunction_type_t<math::log10_fun, E>
-    {
-        return detail::make_xfunction<math::log10_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup exp_functions
-     * @brief Base 2 logarithm function.
-     *
-     * Returns an \ref xfunction for the element-wise base 2
-     * logarithm of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto log2(E&& e) noexcept
-        -> detail::xfunction_type_t<math::log2_fun, E>
-    {
-        return detail::make_xfunction<math::log2_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup exp_functions
-     * @brief Natural logarithm of one plus function.
-     *
-     * Returns an \ref xfunction for the element-wise natural
-     * logarithm of \em e, plus 1.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto log1p(E&& e) noexcept
-        -> detail::xfunction_type_t<math::log1p_fun, E>
-    {
-        return detail::make_xfunction<math::log1p_fun>(std::forward<E>(e));
-    }
-
-    /*******************
-     * power functions *
-     *******************/
-
-    /**
-     * @defgroup pow_functions Power functions
-     */
-
-    /**
-     * @ingroup pow_functions
-     * @brief Power function.
-     *
-     * Returns an \ref xfunction for the element-wise value of
-     * of \em e1 raised to the power \em e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto pow(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::pow_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::pow_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    namespace detail
-    {
-        template <class F, class... T, typename = decltype(std::declval<F>()(std::declval<T>()...))>
-        std::true_type  supports_test(const F&, const T&...);
-        std::false_type supports_test(...);
-
-        template <class... T> struct supports;
-
-        template <class F, class... T> struct supports<F(T...)>
-            : decltype(supports_test(std::declval<F>(), std::declval<T>()...))
-        {
-        };
-
-        template <class F>
-        struct lambda_adapt
-        {
-            explicit lambda_adapt(F&& lmbd)
-                : m_lambda(std::move(lmbd))
-            {
-            }
-
-            template <class... T>
-            auto operator()(T... args) const
-            {
-                return m_lambda(args...);
-            }
-
-            template <class... T, class = std::enable_if_t<detail::supports<F(T...)>::value, int>>
-            auto simd_apply(T... args) const
-            {
-                return m_lambda(args...);
-            }
-
-            F m_lambda;
-        };
-    }
-
-    /**
-     * Create a xfunction from a lambda
-     *
-     * This function can be used to easily create performant xfunctions from lambdas:
-     *
-     * \code{cpp}
-     * template <class E1>
-     * inline auto square(E1&& e1) noexcept
-     * {
-     *     auto fnct = [](auto x) -> decltype(x * x) {
-     *         return x * x;
-     *     };
-     *     return make_lambda_xfunction(std::move(fnct), std::forward<E1>(e1));
-     * }
-     * \endcode
-     *
-     * Lambda function allow the reusal of a single arguments in multiple places (otherwise
-     * only correctly possible when using xshared_expressions). ``auto`` lambda functions are
-     * automatically vectorized with ``xsimd`` if possible (note that the trailing
-     * ``-> decltype(...)`` is mandatory for the feature detection to work).
-     *
-     * @param lambda the lambda to be vectorized
-     * @param args forwarded arguments
-     *
-     * @return lazy xfunction
-     */
-    template <class F, class... E>
-    inline auto make_lambda_xfunction(F&& lambda, E&&... args)
-    {
-        using xfunction_type = xfunction<detail::lambda_adapt<F>,
-                                         const_xclosure_t<E>...>;
-        return xfunction_type(detail::lambda_adapt<F>(std::forward<F>(lambda)), std::forward<E>(args)...);
-    }
-
-
-#define XTENSOR_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-
-// Workaround for MSVC 2015 & GCC 4.9
-#if (defined(_MSC_VER) && _MSC_VER < 1910) || (defined(__GNUC__) && GCC_VERSION < 49999)
-    #define XTENSOR_DISABLE_LAMBDA_FCT
-#endif
-
-#ifdef XTENSOR_DISABLE_LAMBDA_FCT
-    struct square_fct
-    {
-        template <class T>
-        auto operator()(T x) const
-            -> decltype(x * x)
-        {
-            return x * x;
-        }
-    };
-
-    struct cube_fct
-    {
-        template <class T>
-        auto operator()(T x) const
-            -> decltype(x * x * x)
-        {
-            return x * x * x;
-        }
-    };
-#endif
-
-    /**
-     * @ingroup pow_functions
-     * @brief Square power function, equivalent to e1 * e1.
-     *
-     * Returns an \ref xfunction for the element-wise value of
-     * of \em e1 * \em e1.
-     * @param e1 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1>
-    inline auto square(E1&& e1) noexcept
-    {
-#ifdef XTENSOR_DISABLE_LAMBDA_FCT
-        return make_lambda_xfunction(square_fct{}, std::forward<E1>(e1));
-#else
-        auto fnct = [](auto x) -> decltype(x * x) {
-            return x * x;
-        };
-        return make_lambda_xfunction(std::move(fnct), std::forward<E1>(e1));
-#endif
-    }
-
-    /**
-     * @ingroup pow_functions
-     * @brief Cube power function, equivalent to e1 * e1 * e1.
-     *
-     * Returns an \ref xfunction for the element-wise value of
-     * of \em e1 * \em e1.
-     * @param e1 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1>
-    inline auto cube(E1&& e1) noexcept
-    {
-#ifdef XTENSOR_DISABLE_LAMBDA_FCT
-        return make_lambda_xfunction(cube_fct{}, std::forward<E1>(e1));
-#else
-        auto fnct = [](auto x) -> decltype(x * x * x) {
-            return x * x * x;
-        };
-        return make_lambda_xfunction(std::move(fnct), std::forward<E1>(e1));
-#endif
-    }
-
-#undef XTENSOR_GCC_VERSION
-#undef XTENSOR_DISABLE_LAMBDA_FCT
-
-    namespace detail
-    {
-        // Thanks to Matt Pharr in http://pbrt.org/hair.pdf
-        template <std::size_t N>
-        struct pow_impl;
-
-        template <std::size_t N>
-        struct pow_impl
-        {
-            template <class T>
-            auto operator()(T v) const
-                -> decltype(v * v)
-            {
-                T temp = pow_impl<N / 2>{}(v);
-                return temp * temp * pow_impl<N & 1>{}(v);
-            }
-        };
-
-        template <>
-        struct pow_impl<1>
-        {
-            template <class T>
-            auto operator()(T v) const
-                -> T
-            {
-                return v;
-            }
-        };
-
-        template <>
-        struct pow_impl<0>
-        {
-            template <class T>
-            auto operator()(T /*v*/) const
-                -> T
-            {
-                return T(1);
-            }
-        };
-    }
-
-    /**
-     * @ingroup pow_functions
-     * @brief Integer power function.
-     *
-     * Returns an \ref xfunction for the element-wise power of e1 to
-     * an integral constant.
-     *
-     * Instead of computing the power by using the (expensive) logarithm, this function
-     * computes the power in a number of straight-forward multiplication steps. This function
-     * is therefore much faster (even for high N) than the generic pow-function.
-     *
-     * For example, `e1^20` can be expressed as `(((e1^2)^2)^2)^2*(e1^2)^2`, which is just 5 multiplications.
-     *
-     * @param e an \ref xexpression
-     * @tparam N the exponent (has to be positive integer)
-     * @return an \ref xfunction
-     */
-    template <std::size_t N, class E>
-    inline auto pow(E&& e) noexcept
-    {
-        static_assert(N > 0, "integer power cannot be negative");
-        return make_lambda_xfunction(detail::pow_impl<N>{}, std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup pow_functions
-     * @brief Square root function.
-     *
-     * Returns an \ref xfunction for the element-wise square
-     * root of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto sqrt(E&& e) noexcept
-        -> detail::xfunction_type_t<math::sqrt_fun, E>
-    {
-        return detail::make_xfunction<math::sqrt_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup pow_functions
-     * @brief Cubic root function.
-     *
-     * Returns an \ref xfunction for the element-wise cubic
-     * root of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto cbrt(E&& e) noexcept
-        -> detail::xfunction_type_t<math::cbrt_fun, E>
-    {
-        return detail::make_xfunction<math::cbrt_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup pow_functions
-     * @brief Hypotenuse function.
-     *
-     * Returns an \ref xfunction for the element-wise square
-     * root of the sum of the square of \em e1 and \em e2, avoiding
-     * overflow and underflow at intermediate stages of computation.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto hypot(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::hypot_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::hypot_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /***************************
-     * trigonometric functions *
-     ***************************/
-
-    /**
-     * @defgroup trigo_functions Trigonometric function
-     */
-
-    /**
-     * @ingroup trigo_functions
-     * @brief Sine function.
-     *
-     * Returns an \ref xfunction for the element-wise sine
-     * of \em e (measured in radians).
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto sin(E&& e) noexcept
-        -> detail::xfunction_type_t<math::sin_fun, E>
-    {
-        return detail::make_xfunction<math::sin_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup trigo_functions
-     * @brief Cosine function.
-     *
-     * Returns an \ref xfunction for the element-wise cosine
-     * of \em e (measured in radians).
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto cos(E&& e) noexcept
-        -> detail::xfunction_type_t<math::cos_fun, E>
-    {
-        return detail::make_xfunction<math::cos_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup trigo_functions
-     * @brief Tangent function.
-     *
-     * Returns an \ref xfunction for the element-wise tangent
-     * of \em e (measured in radians).
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto tan(E&& e) noexcept
-        -> detail::xfunction_type_t<math::tan_fun, E>
-    {
-        return detail::make_xfunction<math::tan_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup trigo_functions
-     * @brief Arcsine function.
-     *
-     * Returns an \ref xfunction for the element-wise arcsine
-     * of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto asin(E&& e) noexcept
-        -> detail::xfunction_type_t<math::asin_fun, E>
-    {
-        return detail::make_xfunction<math::asin_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup trigo_functions
-     * @brief Arccosine function.
-     *
-     * Returns an \ref xfunction for the element-wise arccosine
-     * of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto acos(E&& e) noexcept
-        -> detail::xfunction_type_t<math::acos_fun, E>
-    {
-        return detail::make_xfunction<math::acos_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup trigo_functions
-     * @brief Arctangent function.
-     *
-     * Returns an \ref xfunction for the element-wise arctangent
-     * of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto atan(E&& e) noexcept
-        -> detail::xfunction_type_t<math::atan_fun, E>
-    {
-        return detail::make_xfunction<math::atan_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup trigo_functions
-     * @brief Artangent function, using signs to determine quadrants.
-     *
-     * Returns an \ref xfunction for the element-wise arctangent
-     * of <em>e1 / e2</em>, using the signs of arguments to determine the
-     * correct quadrant.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     * @note e1 and e2 can't be both scalars.
-     */
-    template <class E1, class E2>
-    inline auto atan2(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<math::atan2_fun, E1, E2>
-    {
-        return detail::make_xfunction<math::atan2_fun>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /************************
-     * hyperbolic functions *
-     ************************/
-
-    /**
-     * @defgroup hyper_functions Hyperbolic functions
-     */
-
-    /**
-     * @ingroup hyper_functions
-     * @brief Hyperbolic sine function.
-     *
-     * Returns an \ref xfunction for the element-wise hyperbolic
-     * sine of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto sinh(E&& e) noexcept
-        -> detail::xfunction_type_t<math::sinh_fun, E>
-    {
-        return detail::make_xfunction<math::sinh_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup hyper_functions
-     * @brief Hyperbolic cosine function.
-     *
-     * Returns an \ref xfunction for the element-wise hyperbolic
-     * cosine of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto cosh(E&& e) noexcept
-        -> detail::xfunction_type_t<math::cosh_fun, E>
-    {
-        return detail::make_xfunction<math::cosh_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup hyper_functions
-     * @brief Hyperbolic tangent function.
-     *
-     * Returns an \ref xfunction for the element-wise hyperbolic
-     * tangent of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto tanh(E&& e) noexcept
-        -> detail::xfunction_type_t<math::tanh_fun, E>
-    {
-        return detail::make_xfunction<math::tanh_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup hyper_functions
-     * @brief Inverse hyperbolic sine function.
-     *
-     * Returns an \ref xfunction for the element-wise inverse hyperbolic
-     * sine of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto asinh(E&& e) noexcept
-        -> detail::xfunction_type_t<math::asinh_fun, E>
-    {
-        return detail::make_xfunction<math::asinh_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup hyper_functions
-     * @brief Inverse hyperbolic cosine function.
-     *
-     * Returns an \ref xfunction for the element-wise inverse hyperbolic
-     * cosine of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto acosh(E&& e) noexcept
-        -> detail::xfunction_type_t<math::acosh_fun, E>
-    {
-        return detail::make_xfunction<math::acosh_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup hyper_functions
-     * @brief Inverse hyperbolic tangent function.
-     *
-     * Returns an \ref xfunction for the element-wise inverse hyperbolic
-     * tangent of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto atanh(E&& e) noexcept
-        -> detail::xfunction_type_t<math::atanh_fun, E>
-    {
-        return detail::make_xfunction<math::atanh_fun>(std::forward<E>(e));
-    }
-
-    /*****************************
-     * error and gamma functions *
-     *****************************/
-
-    /**
-     * @defgroup err_functions Error and gamma functions
-     */
-
-    /**
-     * @ingroup err_functions
-     * @brief Error function.
-     *
-     * Returns an \ref xfunction for the element-wise error function
-     * of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto erf(E&& e) noexcept
-        -> detail::xfunction_type_t<math::erf_fun, E>
-    {
-        return detail::make_xfunction<math::erf_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup err_functions
-     * @brief Complementary error function.
-     *
-     * Returns an \ref xfunction for the element-wise complementary
-     * error function of \em e, whithout loss of precision for large argument.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto erfc(E&& e) noexcept
-        -> detail::xfunction_type_t<math::erfc_fun, E>
-    {
-        return detail::make_xfunction<math::erfc_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup err_functions
-     * @brief Gamma function.
-     *
-     * Returns an \ref xfunction for the element-wise gamma function
-     * of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto tgamma(E&& e) noexcept
-        -> detail::xfunction_type_t<math::tgamma_fun, E>
-    {
-        return detail::make_xfunction<math::tgamma_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup err_functions
-     * @brief Natural logarithm of the gamma function.
-     *
-     * Returns an \ref xfunction for the element-wise logarithm of
-     * the asbolute value fo the gamma function of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto lgamma(E&& e) noexcept
-        -> detail::xfunction_type_t<math::lgamma_fun, E>
-    {
-        return detail::make_xfunction<math::lgamma_fun>(std::forward<E>(e));
-    }
-
-    /*********************************************
-     * nearest integer floating point operations *
-     *********************************************/
-
-    /**
-     * @defgroup nearint_functions Nearest integer floating point operations
-     */
-
-    /**
-     * @ingroup nearint_functions
-     * @brief ceil function.
-     *
-     * Returns an \ref xfunction for the element-wise smallest integer value
-     * not less than \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto ceil(E&& e) noexcept
-        -> detail::xfunction_type_t<math::ceil_fun, E>
-    {
-        return detail::make_xfunction<math::ceil_fun>(std::forward<E>(e));
-    }
-
-    /**
-    * @ingroup nearint_functions
-    * @brief floor function.
-    *
-    * Returns an \ref xfunction for the element-wise smallest integer value
-    * not greater than \em e.
-    * @param e an \ref xexpression
-    * @return an \ref xfunction
-    */
-    template <class E>
-    inline auto floor(E&& e) noexcept
-        -> detail::xfunction_type_t<math::floor_fun, E>
-    {
-        return detail::make_xfunction<math::floor_fun>(std::forward<E>(e));
-    }
-
-    /**
-    * @ingroup nearint_functions
-    * @brief trunc function.
-    *
-    * Returns an \ref xfunction for the element-wise nearest integer not greater
-    * in magnitude than \em e.
-    * @param e an \ref xexpression
-    * @return an \ref xfunction
-    */
-    template <class E>
-    inline auto trunc(E&& e) noexcept
-        -> detail::xfunction_type_t<math::trunc_fun, E>
-    {
-        return detail::make_xfunction<math::trunc_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup nearint_functions
-     * @brief round function.
-     *
-     * Returns an \ref xfunction for the element-wise nearest integer value
-     * to \em e, rounding halfway cases away from zero, regardless of the
-     * current rounding mode.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto round(E&& e) noexcept
-        -> detail::xfunction_type_t<math::round_fun, E>
-    {
-        return detail::make_xfunction<math::round_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup nearint_functions
-     * @brief nearbyint function.
-     *
-     * Returns an \ref xfunction for the element-wise rounding of \em e to integer
-     * values in floating point format, using the current rounding mode. nearbyint
-     * never raises FE_INEXACT error.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto nearbyint(E&& e) noexcept
-        -> detail::xfunction_type_t<math::nearbyint_fun, E>
-    {
-        return detail::make_xfunction<math::nearbyint_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup nearint_functions
-     * @brief rint function.
-     *
-     * Returns an \ref xfunction for the element-wise rounding of \em e to integer
-     * values in floating point format, using the current rounding mode. Contrary
-     * to nearbyint, rint may raise FE_INEXACT error.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto rint(E&& e) noexcept
-        -> detail::xfunction_type_t<math::rint_fun, E>
-    {
-        return detail::make_xfunction<math::rint_fun>(std::forward<E>(e));
-    }
-
-    /****************************
-     * classification functions *
-     ****************************/
-
-    /**
-     * @defgroup classif_functions Classification functions
-     */
-
-    /**
-     * @ingroup classif_functions
-     * @brief finite value check
-     *
-     * Returns an \ref xfunction for the element-wise finite value check
-     * tangent of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto isfinite(E&& e) noexcept
-        -> detail::xfunction_type_t<math::isfinite_fun, E>
-    {
-        return detail::make_xfunction<math::isfinite_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup classif_functions
-     * @brief infinity check
-     *
-     * Returns an \ref xfunction for the element-wise infinity check
-     * tangent of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto isinf(E&& e) noexcept
-        -> detail::xfunction_type_t<math::isinf_fun, E>
-    {
-        return detail::make_xfunction<math::isinf_fun>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup classif_functions
-     * @brief NaN check
-     *
-     * Returns an \ref xfunction for the element-wise NaN check
-     * tangent of \em e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto isnan(E&& e) noexcept
-        -> detail::xfunction_type_t<math::isnan_fun, E>
-    {
-        return detail::make_xfunction<math::isnan_fun>(std::forward<E>(e));
-    }
-
-    namespace detail
-    {
-        template <class FUNCTOR, class T, std::size_t... Is>
-        inline auto get_functor(T&& args, std::index_sequence<Is...>)
-        {
-            return FUNCTOR(std::get<Is>(args)...);
-        }
-
-        template <class F, class... A, class... E>
-        inline auto make_xfunction(std::tuple<A...>&& f_args, E&&... e) noexcept
-        {
-            using functor_type = F;
-            using expression_tag = xexpression_tag_t<E...>;
-            using type = select_xfunction_expression_t<expression_tag,
-                                                       functor_type,
-                                                       const_xclosure_t<E>...>;
-            auto functor = get_functor<functor_type>(
-                std::forward<std::tuple<A...>>(f_args),
-                std::make_index_sequence<sizeof...(A)>{}
-            );
-            return type(std::move(functor), std::forward<E>(e)...);
-        }
-
-        struct isclose
-        {
-            using result_type = bool;
-            isclose(double rtol, double atol, bool equal_nan)
-                : m_rtol(rtol), m_atol(atol), m_equal_nan(equal_nan)
-            {
-            }
-
-            template <class A1, class A2>
-            bool operator()(const A1& a, const A2& b) const
-            {
-                using internal_type = promote_type_t<A1, A2, double>;
-                if (math::isnan(a) && math::isnan(b))
-                {
-                    return m_equal_nan;
-                }
-                if (math::isinf(a) && math::isinf(b))
-                {
-                    // check for both infinity signs equal
-                    return a == b;
-                }
-                auto d = math::abs(internal_type(a) - internal_type(b));
-                return d <= m_atol || d <= m_rtol * double((std::max)(math::abs(internal_type(a)), math::abs(internal_type(b))));
-            }
-
-        private:
-
-            double m_rtol;
-            double m_atol;
-            bool m_equal_nan;
-        };
-    }
-
-    /**
-     * @ingroup classif_functions
-     * @brief Element-wise closeness detection
-     *
-     * Returns an \ref xfunction that evaluates to
-     * true if the elements in ``e1`` and ``e2`` are close to each other
-     * according to parameters ``atol`` and ``rtol``.
-     * The equation is: ``std::abs(a - b) <= (m_atol + m_rtol * std::abs(b))``.
-     * @param e1 input array to compare
-     * @param e2 input array to compare
-     * @param rtol the relative tolerance parameter (default 1e-05)
-     * @param atol the absolute tolerance parameter (default 1e-08)
-     * @param equal_nan if true, isclose returns true if both elements of e1 and e2 are NaN
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto isclose(E1&& e1, E2&& e2, double rtol = 1e-05, double atol = 1e-08, bool equal_nan = false) noexcept
-    {
-        return detail::make_xfunction<detail::isclose>(std::make_tuple(rtol, atol, equal_nan),
-                                                       std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup classif_functions
-     * @brief Check if all elements in \em e1 are close to the
-     * corresponding elements in \em e2.
-     *
-     * Returns true if all elements in ``e1`` and ``e2`` are close to each other
-     * according to parameters ``atol`` and ``rtol``.
-     * @param e1 input array to compare
-     * @param e2 input arrays to compare
-     * @param rtol the relative tolerance parameter (default 1e-05)
-     * @param atol the absolute tolerance parameter (default 1e-08)
-     * @return a boolean
-     */
-    template <class E1, class E2>
-    inline auto allclose(E1&& e1, E2&& e2, double rtol = 1e-05, double atol = 1e-08) noexcept
-    {
-        return xt::all(isclose(std::forward<E1>(e1), std::forward<E2>(e2), rtol, atol));
-    }
-
-    /**********************
-     * Reducing functions *
-     **********************/
-
-
-    /**
-     * @defgroup  red_functions reducing functions
-     */
-
-    /**
-     * @ingroup red_functions
-     * @brief Sum of elements over given axes.
-     *
-     * Returns an \ref xreducer for the sum of elements over given
-     * \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the sum is performed (optional)
-     * @param es evaluation strategy of the reducer
-     * @return an \ref xreducer
-     */
-    XTENSOR_REDUCER_FUNCTION(sum, std::plus, big_promote_type_t<typename std::decay_t<E>::value_type>)
-#ifdef X_OLD_CLANG
-    XTENSOR_OLD_CLANG_REDUCER(sum, std::plus, big_promote_type_t<typename std::decay_t<E>::value_type>)
-#else
-    XTENSOR_MODERN_CLANG_REDUCER(sum, std::plus, big_promote_type_t<typename std::decay_t<E>::value_type>)
-#endif
-
-    /**
-     * @ingroup red_functions
-     * @brief Product of elements over given axes.
-     *
-     * Returns an \ref xreducer for the product of elements over given
-     * \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the product is computed (optional)
-     * @param es evaluation strategy of the reducer
-     * @return an \ref xreducer
-     */
-    XTENSOR_REDUCER_FUNCTION(prod, std::multiplies, big_promote_type_t<typename std::decay_t<E>::value_type>)
-#ifdef X_OLD_CLANG
-    XTENSOR_OLD_CLANG_REDUCER(prod, std::multiplies, big_promote_type_t<typename std::decay_t<E>::value_type>)
-#else
-    XTENSOR_MODERN_CLANG_REDUCER(prod, std::multiplies, big_promote_type_t<typename std::decay_t<E>::value_type>)
-#endif
-
-    /**
-     * @ingroup red_functions
-     * @brief Mean of elements over given axes.
-     *
-     * Returns an \ref xreducer for the mean of elements over given
-     * \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the mean is computed (optional)
-     * @return an \ref xexpression
-     */
-    template <class T = void, class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value>>
-    inline auto mean(E&& e, X&& axes, EVS es = EVS())
-    {
-        using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
-        auto size = e.size();
-        // sum cannot always be a double. It could be a complex number which cannot operate on
-        // std::plus<double>.
-        auto s = sum<T>(std::forward<E>(e), std::forward<X>(axes), es);
-        return std::move(s) / static_cast<value_type>(size / s.size());
-    }
-
-    template <class T = void, class E, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<std::is_base_of<evaluation_strategy::base, std::decay_t<EVS>>::value>>
-    inline auto mean(E&& e, EVS es = EVS())
-    {
-        using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
-        auto size = e.size();
-        return sum<T>(std::forward<E>(e), es) / static_cast<value_type>(size);
-    }
-
-#ifdef X_OLD_CLANG
-    template <class T = void, class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto mean(E&& e, std::initializer_list<I> axes, EVS es = EVS())
-    {
-        using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
-        auto size = e.size();
-        auto s = sum<T>(std::forward<E>(e), axes, es);
-        return std::move(s) / static_cast<value_type>(size / s.size());
-    }
-#else
-    template <class T = void, class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto mean(E&& e, const I (&axes)[N], EVS es = EVS())
-    {
-        using value_type = typename std::conditional_t<std::is_same<T, void>::value, double, T>;
-        auto size = e.size();
-        auto s = sum<T>(std::forward<E>(e), axes, es);
-        return std::move(s) / static_cast<value_type>(size / s.size());
-    }
-#endif
-
-    /**
-     * @ingroup red_functions
-     * @brief Average of elements over given axes using weights.
-     *
-     * Returns an \ref xreducer for the mean of elements over given
-     * \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the mean is computed (optional)
-     * @return an \ref xexpression
-     *
-     * @sa mean
-     */
-    template <class E, class W, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<std::is_base_of<evaluation_strategy::base, EVS>::value>,
-              XTENSOR_REQUIRE<!std::is_integral<X>::value>>
-    inline auto average(E&& e, W&& weights, X&& axes, EVS ev = EVS())
-    {
-        xindex_type_t<typename std::decay_t<E>::shape_type> broadcast_shape;
-        xt::resize_container(broadcast_shape, e.dimension());
-        auto ax = normalize_axis(e, axes);
-        if (weights.dimension() == 1)
-        {
-            if (weights.size() != e.shape()[ax[0]])
-            {
-                throw std::runtime_error("Weights need to have the same shape as expression at axes.");
-            }
-
-            std::fill(broadcast_shape.begin(), broadcast_shape.end(), std::size_t(1));
-            broadcast_shape[ax[0]] = weights.size();
-        }
-        else
-        {
-            if (!same_shape(e.shape(), weights.shape()))
-            {
-                throw std::runtime_error("Weights with dim > 1 need to have the same shape as expression.");
-            }
-
-            std::copy(e.shape().begin(), e.shape().end(), broadcast_shape.begin());
-        }
-
-        auto weights_view = reshape_view(std::forward<W>(weights), std::move(broadcast_shape));
-        auto scl = sum(weights_view, ax, xt::evaluation_strategy::immediate{});
-        return sum(std::forward<E>(e) * std::move(weights_view), std::move(ax), ev) / std::move(scl);
-    }
-
-#ifndef X_OLD_CLANG
-    template <class E, class W, class X, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto average(E&& e, W&& weights, const X(&axes)[N], EVS ev = EVS())
-    {
-        // need to select the X&& overload and forward to different type
-        using ax_t = std::array<std::size_t, N>;
-        return average(std::forward<E>(e), std::forward<W>(weights), xt::forward_normalize<ax_t>(e, axes), ev);
-    }
-#else
-    template <class E, class W, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto average(E&& e, W&& weights, std::initializer_list<I> axes, EVS ev = EVS())
-    {
-        using ax_t = dynamic_shape<std::size_t>;
-        return average(std::forward<E>(e), std::forward<W>(weights), xt::forward_normalize<ax_t>(e, axes), ev);
-    }
-#endif
-
-    template <class E, class W, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<std::is_base_of<evaluation_strategy::base, EVS>::value>>
-    inline auto average(E&& e, W&& weights, EVS ev = EVS())
-    {
-        if (weights.dimension() != e.dimension() || !std::equal(weights.shape().begin(), weights.shape().end(), e.shape().begin()))
-        {
-            throw std::runtime_error("Weights need to have the same shape as expression.");
-        }
-
-        auto div = sum(weights, evaluation_strategy::immediate{})();
-        auto s = sum(std::forward<E>(e) * std::forward<W>(weights), ev) / std::move(div);
-        return s;
-    }
-
-    namespace detail
-    {
-        template<typename E>
-        std::enable_if_t<std::is_lvalue_reference<E>::value, E>
-        shared_forward(E e) noexcept
-        {
-            return e;
-        }
-
-        template<typename E>
-        std::enable_if_t<!std::is_lvalue_reference<E>::value, xshared_expression<E>>
-        shared_forward(E e) noexcept
-        {
-            return make_xshared(std::move(e));
-        }
-    }
-
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<std::is_base_of<evaluation_strategy::base, EVS>::value>>
-    inline auto variance(E&& e, EVS es = EVS())
-    {
-        decltype(auto) sc = detail::shared_forward<E>(e);
-        return mean(square(abs(sc - mean(sc, es))), es);
-    }
-
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<std::is_base_of<evaluation_strategy::base, EVS>::value>>
-    inline auto stddev(E&& e, EVS es = EVS())
-    {
-        return sqrt(variance(std::forward<E>(e), es));
-    }
-
-    /**
-     * @ingroup red_functions
-     * @brief Compute the variance along the specified axes
-     *
-     * Returns the variance of the array elements, a measure of the spread of a
-     * distribution. The variance is computed for the flattened array by default,
-     * otherwise over the specified axes.
-     *
-     * Note: this function is not yet specialized for complex numbers.
-     *
-     * @param e an \ref xexpression
-     * @param axes the axes along which the mean is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xexpression
-     *
-     * @sa stddev, mean
-     */
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value>>
-    inline auto variance(E&& e, X&& axes, EVS es = EVS())
-    {
-        decltype(auto) sc = detail::shared_forward<E>(e);
-        // note: forcing copy of first axes argument -- is there a better solution?
-        auto axes_copy = axes;
-        auto inner_mean = mean(sc, std::move(axes_copy));
-
-        // fake keep_dims = 1
-        auto keep_dim_shape = e.shape();
-        for (const auto& el : axes)
-        {
-            keep_dim_shape[el] = 1;
-        }
-        auto mrv = xt::reshape_view(std::move(inner_mean), std::move(keep_dim_shape));
-        return mean(square(abs(sc - std::move(mrv))), std::forward<X>(axes), es);
-    }
-
-    /**
-     * @ingroup red_functions
-     * @brief Compute the standard deviation along the specified axis.
-     *
-     * Returns the standard deviation, a measure of the spread of a distribution,
-     * of the array elements. The standard deviation is computed for the flattened
-     * array by default, otherwise over the specified axis.
-     *
-     * Note: this function is not yet specialized for complex numbers.
-     *
-     * @param e an \ref xexpression
-     * @param axes the axes along which the mean is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xexpression
-     *
-     * @sa variance, mean
-     */
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value>>
-    inline auto stddev(E&& e, X&& axes, EVS es = EVS())
-    {
-        return sqrt(variance(std::forward<E>(e), std::forward<X>(axes), es));
-    }
-
-#ifndef X_OLD_CLANG
-    template <class E, class A, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto stddev(E&& e, const A (&axes)[N], EVS es = EVS())
-    {
-        return stddev(std::forward<E>(e), xtl::forward_sequence<std::array<std::size_t, N>>(axes), es);
-    }
-
-    template <class E, class A, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto variance(E&& e, const A (&axes)[N], EVS es = EVS())
-    {
-        return variance(std::forward<E>(e), xtl::forward_sequence<std::array<std::size_t, N>>(axes), es);
-    }
-#else
-    template <class E, class A, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto stddev(E&& e, std::initializer_list<A> axes, EVS es = EVS())
-    {
-        return stddev(std::forward<E>(e), xtl::forward_sequence<dynamic_shape<std::size_t>>(axes), es);
-    }
-
-    template <class E, class A, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto variance(E&& e, std::initializer_list<A> axes, EVS es = EVS())
-    {
-        return variance(std::forward<E>(e), xtl::forward_sequence<dynamic_shape<std::size_t>>(axes), es);
-    }
-#endif
-    /**
-     * @ingroup red_functions
-     * @brief Minimum and maximum among the elements of an array or expression.
-     *
-     * Returns an \ref xreducer for the minimum and maximum of an expression's elements.
-     * @param e an \ref xexpression
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xexpression of type ``std::array<value_type, 2>``, whose first
-     *         and second element represent the minimum and maximum respectively
-     */
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<std::is_base_of<evaluation_strategy::base, EVS>::value>>
-    inline auto minmax(E&& e, EVS es = EVS())
-    {
-        using std::min;
-        using std::max;
-        using value_type = typename std::decay_t<E>::value_type;
-        using result_type = std::array<value_type, 2>;
-
-        auto reduce_func = [](result_type r, value_type const& v) {
-            r[0] = (min)(r[0], v);
-            r[1] = (max)(r[1], v);
-            return r;
-        };
-        auto init_func = [](value_type const& v) {
-            return result_type{v, v};
-        };
-        auto merge_func = [](result_type r, result_type const& s) {
-            r[0] = (min)(r[0], s[0]);
-            r[1] = (max)(r[1], s[1]);
-            return r;
-        };
-        return reduce(make_xreducer_functor(std::move(reduce_func),
-                                            std::move(init_func),
-                                            std::move(merge_func)),
-                      std::forward<E>(e), arange(e.dimension()), es);
-    }
-
-    /**
-     * @defgroup acc_functions accumulating functions
-     */
-
-    /**
-     * @ingroup acc_functions
-     * @brief Cumulative sum.
-     *
-     * Returns the accumulated sum for the elements over given
-     * \em axis (or flattened).
-     * @param e an \ref xexpression
-     * @param axis the axes along which the cumulative sum is computed (optional)
-     * @return an \ref xarray<T>
-     */
-    template <class E>
-    inline auto cumsum(E&& e, std::ptrdiff_t axis)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(std::plus<result_type>()), std::forward<E>(e), axis);
-    }
-
-    template <class E>
-    inline auto cumsum(E&& e)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(std::plus<result_type>()), std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup acc_functions
-     * @brief Cumulative product.
-     *
-     * Returns the accumulated product for the elements over given
-     * \em axis (or flattened).
-     * @param e an \ref xexpression
-     * @param axis the axes along which the cumulative product is computed (optional)
-     * @return an \ref xarray<T>
-     */
-    template <class E>
-    inline auto cumprod(E&& e, std::ptrdiff_t axis)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(std::multiplies<result_type>()), std::forward<E>(e), axis);
-    }
-
-    template <class E>
-    inline auto cumprod(E&& e)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(std::multiplies<result_type>()), std::forward<E>(e));
-    }
-
-    /*****************
-     * nan functions *
-     *****************/
-
-    namespace detail
-    {
-        struct nan_to_num_functor
-        {
-            template <class A>
-            inline auto operator()(const A& a) const
-            {
-                if (math::isnan(a))
-                {
-                    return A(0);
-                }
-                if (math::isinf(a))
-                {
-                    if (a < 0)
-                    {
-                        return std::numeric_limits<A>::lowest();
-                    }
-                    else
-                    {
-                        return (std::numeric_limits<A>::max)();
-                    }
-                }
-                return a;
-            }
-        };
-
-        template <class T>
-        struct nan_plus
-        {
-            using value_type = T;
-            using result_type = value_type;
-
-            constexpr result_type operator()(const value_type lhs, const value_type rhs) const
-            {
-                return !math::isnan(rhs) ? lhs + rhs : lhs;
-            }
-        };
-
-        template <class T>
-        struct nan_multiplies
-        {
-            using value_type = T;
-            using result_type = value_type;
-
-            constexpr result_type operator()(const value_type lhs, const value_type rhs) const
-            {
-                return !math::isnan(rhs) ? lhs * rhs : lhs;
-            }
-        };
-
-        template <class T, int V>
-        struct nan_init
-        {
-            using value_type = T;
-            using result_type = T;
-            constexpr result_type operator()(const value_type lhs) const
-            {
-                return math::isnan(lhs) ? result_type(V) : lhs;
-            }
-        };
-    }
-
-    /**
-     * @defgroup  nan_functions nan functions
-     */
-
-    /**
-     * @ingroup nan_functions
-     * @brief Convert nan or +/- inf to numbers
-     *
-     * This functions converts nan to 0, and +inf to the highest, -inf to the lowest
-     * floating point value of the same type.
-     *
-     * @param e input \ref xexpression
-     * @return an \ref xexpression
-     */
-    template <class E>
-    inline auto nan_to_num(E&& e)
-    {
-        return detail::make_xfunction<detail::nan_to_num_functor>(std::forward<E>(e));
-    }
-
-#define XTENSOR_NAN_REDUCER_FUNCTION(NAME, FUNCTOR, RESULT_TYPE, NAN)                                             \
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,                                            \
-              class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value, int>> \
-    inline auto NAME(E&& e, X&& axes, EVS es = EVS())                                                             \
-    {                                                                                                             \
-        using result_type = RESULT_TYPE;                                                                          \
-        using functor_type = FUNCTOR<result_type>;                                                                \
-        using init_functor_type = detail::nan_init<result_type, NAN>;                                             \
-        return reduce(make_xreducer_functor(functor_type(), init_functor_type()), std::forward<E>(e),             \
-                      std::forward<X>(axes), es);                                                                 \
-    }                                                                                                             \
-                                                                                                                  \
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS,                                                     \
-              class = std::enable_if_t<std::is_base_of<evaluation_strategy::base, EVS>::value, int>>              \
-    inline auto NAME(E&& e, EVS es = EVS())                                                                       \
-    {                                                                                                             \
-        using result_type = RESULT_TYPE;                                                                          \
-        using functor_type = FUNCTOR<result_type>;                                                                \
-        using init_functor_type = detail::nan_init<result_type, NAN>;                                             \
-        return reduce(make_xreducer_functor(functor_type(), init_functor_type()), std::forward<E>(e), es);        \
-    }
-
-#define OLD_CLANG_NAN_REDUCER(NAME, FUNCTOR, RESULT_TYPE, NAN)                                                       \
-    template <class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>                                               \
-        inline auto NAME(E&& e, std::initializer_list<I> axes, EVS es = EVS())                                       \
-        {                                                                                                            \
-            using result_type = RESULT_TYPE;                                                                         \
-            using functor_type = FUNCTOR<result_type>;                                                               \
-            using init_functor_type = detail::nan_init<result_type, NAN>;                                            \
-            return reduce(make_xreducer_functor(functor_type(), init_functor_type()), std::forward<E>(e), axes, es); \
-        }
-
-#define MODERN_CLANG_NAN_REDUCER(NAME, FUNCTOR, RESULT_TYPE, NAN)                                                 \
-    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>                             \
-    inline auto NAME(E&& e, const I (&axes)[N], EVS es = EVS())                                                   \
-    {                                                                                                             \
-        using result_type = RESULT_TYPE;                                                                          \
-        using functor_type = FUNCTOR<result_type>;                                                                \
-        using init_functor_type = detail::nan_init<result_type, NAN>;                                             \
-        return reduce(make_xreducer_functor(functor_type(), init_functor_type()), std::forward<E>(e), axes, es);  \
-    }
-
-    /**
-     * @ingroup nan_functions
-     * @brief Sum of elements over given axes, replacing nan with 0.
-     *
-     * Returns an \ref xreducer for the sum of elements over given
-     * \em axes, replacing nan with 0.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the sum is performed (optional)
-     * @param es evaluation strategy of the reducer (optional)
-     * @return an \ref xreducer
-     */
-    XTENSOR_NAN_REDUCER_FUNCTION(nansum, detail::nan_plus, typename std::decay_t<E>::value_type, 0)
-#ifdef X_OLD_CLANG
-    OLD_CLANG_NAN_REDUCER(nansum, detail::nan_plus, typename std::decay_t<E>::value_type, 0)
-#else
-    MODERN_CLANG_NAN_REDUCER(nansum, detail::nan_plus, typename std::decay_t<E>::value_type, 0)
-#endif
-
-    /**
-     * @ingroup nan_functions
-     * @brief Product of elements over given axes, replacing nan with 1.
-     *
-     * Returns an \ref xreducer for the sum of elements over given
-     * \em axes, replacing nan with 1.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the sum is performed (optional)
-     * @param es evaluation strategy of the reducer (optional)
-     * @return an \ref xreducer
-     */
-    XTENSOR_NAN_REDUCER_FUNCTION(nanprod, detail::nan_multiplies, typename std::decay_t<E>::value_type, 1)
-#ifdef X_OLD_CLANG
-    OLD_CLANG_NAN_REDUCER(nanprod, detail::nan_multiplies, typename std::decay_t<E>::value_type, 1)
-#else
-    MODERN_CLANG_NAN_REDUCER(nanprod, detail::nan_multiplies, typename std::decay_t<E>::value_type, 1)
-#endif
-
-#undef XTENSOR_NAN_REDUCER_FUNCTION
-#undef OLD_CLANG_NAN_REDUCER
-#undef MODERN_CLANG_NAN_REDUCER
-
-#define COUNT_NON_ZEROS_CONTENT                                                 \
-    using result_type = std::size_t;                                            \
-    using value_type = typename std::decay_t<E>::value_type;                    \
-    auto init_fct = [](value_type const& lhs) -> result_type                    \
-    {                                                                           \
-        return (lhs != value_type(0)) ? result_type(1) : result_type(0);        \
-    };                                                                          \
-    auto reduce_fct = [](const result_type& lhs, const value_type& rhs)         \
-         -> result_type                                                         \
-    {                                                                           \
-        return (rhs != value_type(0)) ? lhs + result_type(1) : lhs;             \
-    };                                                                          \
-    auto merge_func = std::plus<result_type>();                                 \
-
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              class = std::enable_if_t<std::is_base_of<evaluation_strategy::base, EVS>::value, int>>
-    inline auto count_nonzero(E&& e, EVS es = EVS())
-    {
-        COUNT_NON_ZEROS_CONTENT;
-        return reduce(make_xreducer_functor(std::move(reduce_fct), std::move(init_fct), std::move(merge_func)),
-                      std::forward<E>(e), es);
-    }
-
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, X>::value
-                                       && !std::is_integral<X>::value, int>>
-    inline auto count_nonzero(E&& e, X&& axes, EVS es = EVS())
-    {
-        COUNT_NON_ZEROS_CONTENT;
-        return reduce(make_xreducer_functor(std::move(reduce_fct), std::move(init_fct), std::move(merge_func)),
-                      std::forward<E>(e), std::forward<X>(axes), es);
-    }
-
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-            class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, X>::value
-                                     && std::is_integral<X>::value, int>>
-    inline auto count_nonzero(E&& e, X axis, EVS es = EVS())
-    {
-        return count_nonzero(std::forward<E>(e), {axis}, es);
-    }
-
-#ifdef X_OLD_CLANG
-    template <class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto count_nonzero(E&& e, std::initializer_list<I> axes, EVS es = EVS())
-    {
-        COUNT_NON_ZEROS_CONTENT;
-        return reduce(make_xreducer_functor(std::move(reduce_fct), std::move(init_fct), std::move(merge_func)),
-                      std::forward<E>(e), axes, es);
-    }
-#else
-    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto count_nonzero(E&& e, const I (&axes)[N], EVS es = EVS())
-    {
-        COUNT_NON_ZEROS_CONTENT;
-        return reduce(make_xreducer_functor(std::move(reduce_fct), std::move(init_fct), std::move(merge_func)),
-                      std::forward<E>(e), axes, es);
-    }
-#endif
-
-#undef COUNT_NON_ZEROS_CONTENT
-
-    /**
-     * @ingroup nan_functions
-     * @brief Cumulative sum, replacing nan with 0.
-     *
-     * Returns an xaccumulator for the sum of elements over given
-     * \em axis, replacing nan with 0.
-     * @param e an \ref xexpression
-     * @param axis the axis along which the elements are accumulated (optional)
-     * @return an xaccumulator
-     */
-    template <class E>
-    inline auto nancumsum(E&& e, std::ptrdiff_t axis)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(detail::nan_plus<result_type>(), detail::nan_init<result_type, 0>()), std::forward<E>(e), axis);
-    }
-
-    template <class E>
-    inline auto nancumsum(E&& e)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(detail::nan_plus<result_type>(), detail::nan_init<result_type, 0>()), std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup nan_functions
-     * @brief Cumulative product, replacing nan with 1.
-     *
-     * Returns an xaccumulator for the product of elements over given
-     * \em axis, replacing nan with 1.
-     * @param e an \ref xexpression
-     * @param axis the axis along which the elements are accumulated (optional)
-     * @return an xaccumulator
-     */
-    template <class E>
-    inline auto nancumprod(E&& e, std::ptrdiff_t axis)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(detail::nan_multiplies<result_type>(), detail::nan_init<result_type, 1>()), std::forward<E>(e), axis);
-    }
-
-    template <class E>
-    inline auto nancumprod(E&& e)
-    {
-        using result_type = big_promote_type_t<typename std::decay_t<E>::value_type>;
-        return accumulate(make_xaccumulator_functor(detail::nan_multiplies<result_type>(), detail::nan_init<result_type, 1>()), std::forward<E>(e));
-    }
-
-    namespace detail
-    {
-        template <class T>
-        struct diff_impl
-        {
-            template <class Arg>
-            inline void operator()(Arg& ad, const std::size_t& n,
-                                   xstrided_slice_vector& slice1, xstrided_slice_vector& slice2,
-                                   std::size_t saxis)
-            {
-                for (std::size_t i = 0; i < n; ++i)
-                {
-                    slice2[saxis] = range(xnone(), ad.shape()[saxis] - 1);
-                    ad = strided_view(ad, slice1) - strided_view(ad, slice2);
-                }
-            }
-        };
-
-        template <>
-        struct diff_impl<bool>
-        {
-            template <class Arg>
-            inline void operator()(Arg& ad, const std::size_t& n,
-                                   xstrided_slice_vector& slice1, xstrided_slice_vector& slice2,
-                                   std::size_t saxis)
-            {
-                for (std::size_t i = 0; i < n; ++i)
-                {
-                    slice2[saxis] = range(xnone(), ad.shape()[saxis] - 1);
-                    ad = not_equal(strided_view(ad, slice1), strided_view(ad, slice2));
-                }
-            }
-        };
-    }
-
-    /**
-     * @ingroup red_functions
-     * @brief Calculate the n-th discrete difference along the given axis.
-     *
-     * Calculate the n-th discrete difference along the given axis. This function is not lazy (might change in the future).
-     * @param a an \ref xexpression
-     * @param n The number of times values are differenced. If zero, the input is returned as-is. (optional)
-     * @param axis The axis along which the difference is taken, default is the last axis.
-     * @return an xarray
-     */
-    template <class T>
-    auto diff(const xexpression<T>& a, std::size_t n = 1, std::ptrdiff_t axis = -1)
-    {
-        auto ad = a.derived_cast();
-        std::size_t saxis = normalize_axis(ad.dimension(), axis);
-
-        if (n == 0)
-        {
-            return eval(ad);
-        }
-
-        xstrided_slice_vector slice1(ad.dimension(), all());
-        xstrided_slice_vector slice2(ad.dimension(), all());
-        slice1[saxis] = range(1, xnone());
-
-        detail::diff_impl<typename T::value_type> impl;
-        impl(ad, n, slice1, slice2, saxis);
-
-        return eval(ad);
-    }
-
-    /**
-     * @ingroup red_functions
-     * @brief Integrate along the given axis using the composite trapezoidal rule.
-     *
-     * Returns definite integral as approximated by trapezoidal rule. This function is not lazy (might change in the future).
-     * @param y an \ref xexpression
-     * @param dx the spacing between sample points (optional)
-     * @param axis the axis along which to integrate.
-     * @return an xarray
-     */
-    template <class T>
-    auto trapz(const xexpression<T>& y, double dx = 1.0, std::ptrdiff_t axis = -1)
-    {
-        auto& yd = y.derived_cast();
-        std::size_t saxis = normalize_axis(yd.dimension(), axis);
-
-        xstrided_slice_vector slice1(yd.dimension(), all());
-        xstrided_slice_vector slice2(yd.dimension(), all());
-        slice1[saxis] = range(1, xnone());
-        slice2[saxis] = range(xnone(), yd.shape()[saxis] - 1);
-
-        auto trap = dx * (strided_view(yd, slice1) + strided_view(yd, slice2)) * 0.5;
-
-        return eval(sum(trap, {saxis}));
-    }
-
-    /**
-     * @ingroup red_functions
-     * @brief Integrate along the given axis using the composite trapezoidal rule.
-     *
-     * Returns definite integral as approximated by trapezoidal rule. This function is not lazy (might change in the future).
-     * @param y an \ref xexpression
-     * @param x an \ref xexpression representing the sample points corresponding to the y values.
-     * @param axis the axis along which to integrate.
-     * @return an xarray
-     */
-    template <class T, class E>
-    auto trapz(const xexpression<T>& y, const xexpression<E>& x, std::ptrdiff_t axis = -1)
-    {
-        auto& yd = y.derived_cast();
-        auto& xd = x.derived_cast();
-        decltype(diff(x)) dx;
-
-        std::size_t saxis = normalize_axis(yd.dimension(), axis);
-
-        if (xd.dimension() == 1)
-        {
-            dx = diff(x);
-            typename std::decay_t<decltype(yd)>::shape_type shape;
-            resize_container(shape, yd.dimension());
-            std::fill(shape.begin(), shape.end(), 1);
-            shape[saxis] = dx.shape()[0];
-            dx.reshape(shape);
-        }
-        else
-        {
-            dx = diff(x, 1, axis);
-        }
-
-        xstrided_slice_vector slice1(yd.dimension(), all());
-        xstrided_slice_vector slice2(yd.dimension(), all());
-        slice1[saxis] = range(1, xnone());
-        slice2[saxis] = range(xnone(), yd.shape()[saxis] - 1);
-
-        auto trap = dx * (strided_view(yd, slice1) + strided_view(yd, slice2)) * 0.5;
-
-        return eval(sum(trap, {saxis}));
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Returns the one-dimensional piecewise linear interpolant to a function with given discrete data points (xp, fp), evaluated at x.
-     *
-     * @param x The x-coordinates at which to evaluate the interpolated values (sorted).
-     * @param xp The x-coordinates of the data points (sorted).
-     * @param fp The y-coordinates of the data points, same length as xp.
-     * @param left Value to return for x < xp[0].
-     * @param right Value to return for x > xp[-1]
-     * @return an one-dimensional xarray, same length as x.
-     */
-    template<class E1, class E2, class E3, typename T>
-    inline auto interp(const E1 &x, const E2 &xp, const E3 &fp, T left, T right)
-    {
-        using size_type = detail::common_size_type_t<E1,E2,E3>;
-        using value_type = typename E3::value_type;
-
-        // basic checks
-        XTENSOR_ASSERT( xp.dimension() == 1 );
-        XTENSOR_ASSERT( std::is_sorted(x.cbegin(), x.cend()) );
-        XTENSOR_ASSERT( std::is_sorted(xp.cbegin(), xp.cend()) );
-
-        // allocate output
-        auto f = xtensor<value_type, 1>::from_shape(x.shape());
-
-        // counter in "x": from left
-        size_type i = 0;
-
-        // fill f[i] for x[i] <= xp[0]
-        for (; i < x.size() ; ++i)
-        {
-            if (x[i] > xp[0])
-            {
-                break;
-            }
-            f[i] = static_cast<value_type>(left);
-        }
-
-        // counter in "x": from right
-        // (index counts one right, to terminate the reverse loop, without risking being negative)
-        size_type imax = x.size();
-
-        // fill f[i] for x[-1] >= xp[-1]
-        for (; imax > 0 ; --imax)
-        {
-            if (x[imax-1] < xp[xp.size() - 1])
-            {
-                break;
-            }
-            f[imax-1] = static_cast<value_type>(right);
-        }
-
-        // catch edge case: all entries are "right"
-        if (imax == 0)
-        {
-            return f;
-        }
-
-        // set "imax" as actual index
-        // (counted one right, see above)
-        --imax;
-
-        // counter in "xp"
-        size_type ip = 1;
-
-        // fill f[i] for the interior
-        for (; i <= imax ; ++i)
-        {
-            // - search next value in "xp"
-            while (x[i] > xp[ip])
-            {
-                ++ip;
-            }
-            // - distances as doubles
-            double dfp = static_cast<double>(fp[ip] - fp[ip - 1]);
-            double dxp = static_cast<double>(xp[ip] - xp[ip - 1]);
-            double dx  = static_cast<double>(x[i] - xp[ip - 1]);
-            // - interpolate
-            f[i] = fp[ip - 1] + static_cast<value_type>(dfp / dxp * dx);
-        }
-
-        return f;
-    }
-
-    /**
-     * @ingroup basic_functions
-     * @brief Returns the one-dimensional piecewise linear interpolant to a function with given discrete data points (xp, fp), evaluated at x.
-     *
-     * @param x The x-coordinates at which to evaluate the interpolated values (sorted).
-     * @param xp The x-coordinates of the data points (sorted).
-     * @param fp The y-coordinates of the data points, same length as xp.
-     * @return an one-dimensional xarray, same length as x.
-     */
-    template<class E1, class E2, class E3>
-    inline auto interp(const E1 &x, const E2 &xp, const E3 &fp)
-    {
-        return interp(x, xp, fp, fp[0], fp[fp.size() - 1]);
-    }
-
-}
-
-#endif
diff --git a/include/xtensor/xnorm.hpp b/include/xtensor/xnorm.hpp
deleted file mode 100644
index 6d524b2f1..000000000
--- a/include/xtensor/xnorm.hpp
+++ /dev/null
@@ -1,477 +0,0 @@
-/***************************************************************************
-* Copyright (c) 2017, Ullrich Koethe                                       *
-*                                                                          *
-* Distributed under the terms of the BSD 3-Clause License.                 *
-*                                                                          *
-* The full license is in the file LICENSE, distributed with this software. *
-****************************************************************************/
-
-#ifndef XTENSOR_NORM_HPP
-#define XTENSOR_NORM_HPP
-
-#include <cmath>
-// std::abs(int) prior to C++ 17
-#include <complex>
-#include <cstdlib>
-
-#include "xconcepts.hpp"
-#include "xmath.hpp"
-#include "xoperation.hpp"
-#include "xutils.hpp"
-
-namespace xt
-{
-    template <class X>
-    using disable_evaluation_strategy = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value, int>;
-
-    /*************************************
-     * norm functions for built-in types *
-     *************************************/
-
-///@cond DOXYGEN_INCLUDE_SFINAE
-#define XTENSOR_DEFINE_SIGNED_NORMS(T)                            \
-    inline auto                                                   \
-    norm_lp(T t, double p) noexcept                               \
-    {                                                             \
-        using rt = decltype(std::abs(t));                         \
-        return p == 0.0                                           \
-            ? static_cast<rt>(t != 0)                             \
-            : std::abs(t);                                        \
-    }                                                             \
-    inline auto                                                   \
-    norm_lp_to_p(T t, double p) noexcept                          \
-    {                                                             \
-        using rt = real_promote_type_t<T>;                        \
-        return p == 0.0                                           \
-            ? static_cast<rt>(t != 0)                             \
-            : std::pow(static_cast<rt>(std::abs(t)),              \
-                       static_cast<rt>(p));                       \
-    }                                                             \
-    inline std::size_t norm_l0(T t) noexcept { return (t != 0); } \
-    inline auto norm_l1(T t) noexcept { return std::abs(t); }     \
-    inline auto norm_l2(T t) noexcept { return std::abs(t); }     \
-    inline auto norm_linf(T t) noexcept { return std::abs(t); }   \
-    inline auto norm_sq(T t) noexcept { return t * t; }
-
-    XTENSOR_DEFINE_SIGNED_NORMS(signed char)
-    XTENSOR_DEFINE_SIGNED_NORMS(short)
-    XTENSOR_DEFINE_SIGNED_NORMS(int)
-    XTENSOR_DEFINE_SIGNED_NORMS(long)
-    XTENSOR_DEFINE_SIGNED_NORMS(long long)
-    XTENSOR_DEFINE_SIGNED_NORMS(float)
-    XTENSOR_DEFINE_SIGNED_NORMS(double)
-    XTENSOR_DEFINE_SIGNED_NORMS(long double)
-
-#undef XTENSOR_DEFINE_SIGNED_NORMS
-
-#define XTENSOR_DEFINE_UNSIGNED_NORMS(T)                      \
-    inline T norm_lp(T t, double p) noexcept                  \
-    {                                                         \
-        return p == 0.0                                       \
-            ? (t != 0)                                        \
-            : t;                                              \
-    }                                                         \
-    inline auto                                               \
-    norm_lp_to_p(T t, double p) noexcept                      \
-    {                                                         \
-        using rt = real_promote_type_t<T>;                    \
-        return p == 0.0                                       \
-            ? static_cast<rt>(t != 0)                         \
-            : std::pow(static_cast<rt>(t),                    \
-                       static_cast<rt>(p));                   \
-    }                                                         \
-    inline T norm_l0(T t) noexcept { return t != 0 ? 1 : 0; } \
-    inline T norm_l1(T t) noexcept { return t; }              \
-    inline T norm_l2(T t) noexcept { return t; }              \
-    inline T norm_linf(T t) noexcept { return t; }            \
-    inline auto norm_sq(T t) noexcept { return t * t; }
-
-    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned char)
-    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned short)
-    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned int)
-    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned long)
-    XTENSOR_DEFINE_UNSIGNED_NORMS(unsigned long long)
-
-#undef XTENSOR_DEFINE_UNSIGNED_NORMS
-
-    /***********************************
-     * norm functions for std::complex *
-     ***********************************/
-
-    /**
-     * \brief L0 pseudo-norm of a complex number.
-     * Equivalent to <tt>t != 0</tt>.
-     */
-    template <class T>
-    inline uint64_t norm_l0(const std::complex<T>& t) noexcept
-    {
-        return t.real() != 0 || t.imag() != 0;
-    }
-
-    /**
-     * \brief L1 norm of a complex number.
-     */
-    template <class T>
-    inline auto norm_l1(const std::complex<T>& t) noexcept
-    {
-        return std::abs(t.real()) + std::abs(t.imag());
-    }
-
-    /**
-     * \brief L2 norm of a complex number.
-     * Equivalent to <tt>std::abs(t)</tt>.
-     */
-    template <class T>
-    inline auto norm_l2(const std::complex<T>& t) noexcept
-    {
-        return std::abs(t);
-    }
-
-    /**
-     * \brief Squared norm of a complex number.
-     * Equivalent to <tt>std::norm(t)</tt> (yes, the C++ standard really defines
-     * <tt>norm()</tt> to compute the squared norm).
-     */
-    template <class T>
-    inline auto norm_sq(const std::complex<T>& t) noexcept
-    {
-        return std::norm(t);
-    }
-
-    /**
-     * \brief L-infinity norm of a complex number.
-     */
-    template <class T>
-    inline auto norm_linf(const std::complex<T>& t) noexcept
-    {
-        return (std::max)(std::abs(t.real()), std::abs(t.imag()));
-    }
-
-    /**
-     * \brief p-th power of the Lp norm of a complex number.
-     */
-    template <class T>
-    inline auto norm_lp_to_p(const std::complex<T>& t, double p) noexcept
-    {
-        using rt = decltype(std::pow(std::abs(t.real()), static_cast<T>(p)));
-        return p == 0
-            ? static_cast<rt>(t.real() != 0 || t.imag() != 0)
-            : std::pow(std::abs(t.real()), static_cast<T>(p)) +
-                std::pow(std::abs(t.imag()), static_cast<T>(p));
-    }
-
-    /**
-     * \brief Lp norm of a complex number.
-     */
-    template <class T>
-    inline auto norm_lp(const std::complex<T>& t, double p) noexcept
-    {
-        return p == 0
-            ? norm_lp_to_p(t, p)
-            : std::pow(norm_lp_to_p(t, p), 1.0 / p);
-    }
-
-    /***********************************
-     * norm functions for xexpressions *
-     ***********************************/
-
-#ifdef X_OLD_CLANG
-#define XTENSOR_NORM_FUNCTION_AXES(NAME)                                             \
-    template <class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>               \
-    inline auto NAME(E&& e, std::initializer_list<I> axes, EVS es = EVS()) noexcept  \
-    {                                                                                \
-        using axes_type = std::vector<typename std::decay_t<E>::size_type>;          \
-        return NAME(std::forward<E>(e), xtl::forward_sequence<axes_type>(axes), es); \
-    }
-
-#else
-#define XTENSOR_NORM_FUNCTION_AXES(NAME)                                                \
-    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>   \
-    inline auto NAME(E&& e, const I(&axes)[N], EVS es = EVS()) noexcept                 \
-    {                                                                                   \
-        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;           \
-        return NAME(std::forward<E>(e), xtl::forward_sequence<axes_type>(axes), es);    \
-    }
-#endif
-
-
-#define XTENSOR_EMPTY
-#define XTENSOR_COMMA ,
-#define XTENSOR_NORM_FUNCTION(NAME, RESULT_TYPE, REDUCE_EXPR, REDUCE_OP, MERGE_FUNC) \
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,               \
-              class = disable_evaluation_strategy<X>>                                \
-    inline auto NAME(E&& e, X&& axes, EVS es = EVS()) noexcept                       \
-    {                                                                                \
-        using value_type = typename std::decay_t<E>::value_type;                     \
-        using result_type = RESULT_TYPE;                                             \
-                                                                                     \
-        auto reduce_func = [](result_type const& r, value_type const& v) {           \
-            return REDUCE_EXPR(r REDUCE_OP NAME(v));                                 \
-        };                                                                           \
-        auto init_func = [](value_type const& v) {                                   \
-            return NAME(v);                                                          \
-        };                                                                           \
-        return reduce(make_xreducer_functor(std::move(reduce_func),                  \
-                                            std::move(init_func),                    \
-                                            MERGE_FUNC<result_type>()),              \
-                      std::forward<E>(e), std::forward<X>(axes), es);                \
-    }                                                                                \
-                                                                                     \
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS,                        \
-              XTENSOR_REQUIRE<is_xexpression<E>::value>>                             \
-    inline auto NAME(E&& e, EVS es = EVS()) noexcept                                 \
-    {                                                                                \
-        return NAME(std::forward<E>(e), arange(e.dimension()), es);                  \
-    }                                                                                \
-    XTENSOR_NORM_FUNCTION_AXES(NAME)
-
-    XTENSOR_NORM_FUNCTION(norm_l0, unsigned long long, XTENSOR_EMPTY, +, std::plus)
-    XTENSOR_NORM_FUNCTION(norm_l1, big_promote_type_t<value_type>, XTENSOR_EMPTY, +, std::plus)
-    XTENSOR_NORM_FUNCTION(norm_sq, big_promote_type_t<value_type>, XTENSOR_EMPTY, +, std::plus)
-    XTENSOR_NORM_FUNCTION(norm_linf, decltype(norm_linf(std::declval<value_type>())), (std::max<result_type>), XTENSOR_COMMA, math::maximum)
-
-#undef XTENSOR_EMPTY
-#undef XTENSOR_COMMA
-#undef XTENSOR_NORM_FUNCTION
-#undef XTENSOR_NORM_FUNCTION_AXES
-    /// @endcond
-    /**
-     * @ingroup red_functions
-     * @brief L0 (count) pseudo-norm of an array-like argument over given axes.
-     *
-     * Returns an \ref xreducer for the L0 pseudo-norm of the elements across given \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the norm is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     * When no axes are provided, the norm is calculated over the entire array. In this case,
-     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
-     */
-    template <class E, class X, class EVS, class>
-    auto norm_l0(E&& e, X&& axes, EVS es) noexcept;
-
-    /**
-     * @ingroup red_functions
-     * @brief L1 norm of an array-like argument over given axes.
-     *
-     * Returns an \ref xreducer for the L1 norm of the elements across given \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the norm is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     * When no axes are provided, the norm is calculated over the entire array. In this case,
-     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
-     */
-    template <class E, class X, class EVS, class>
-    auto norm_l1(E&& e, X&& axes, EVS es) noexcept;
-
-    /**
-     * @ingroup red_functions
-     * @brief Squared L2 norm of an array-like argument over given axes.
-     *
-     * Returns an \ref xreducer for the squared L2 norm of the elements across given \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the norm is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     * When no axes are provided, the norm is calculated over the entire array. In this case,
-     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
-     */
-    template <class E, class X, class EVS, class>
-    auto norm_sq(E&& e, X&& axes, EVS es) noexcept;
-
-    /**
-     * @ingroup red_functions
-     * @brief L2 norm of a scalar or array-like argument.
-     * @param e an xexpression
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     *  For scalar types: implemented as <tt>abs(t)</tt><br>
-     *  otherwise: implemented as <tt>sqrt(norm_sq(t))</tt>.
-    */
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTENSOR_REQUIRE<is_xexpression<E>::value>>
-    inline auto norm_l2(E&& e, EVS es = EVS()) noexcept
-    {
-        using std::sqrt;
-        return sqrt(norm_sq(std::forward<E>(e), es));
-    }
-
-    /**
-     * @ingroup red_functions
-     * @brief L2 norm of an array-like argument over given axes.
-     *
-     * Returns an \ref xreducer for the L2 norm of the elements across given \em axes.
-     * @param e an \ref xexpression
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @param axes the axes along which the norm is computed
-     * @return an \ref xreducer (specifically: <tt>sqrt(norm_sq(e, axes))</tt>) (or xcontainer, depending on evaluation strategy)
-    */
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              XTENSOR_REQUIRE<is_xexpression<E>::value>, class = disable_evaluation_strategy<X>>
-    inline auto norm_l2(E&& e, X&& axes, EVS es = EVS()) noexcept
-    {
-        return sqrt(norm_sq(std::forward<E>(e), std::forward<X>(axes), es));
-    }
-
-#ifdef X_OLD_CLANG
-    template <class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_l2(E&& e, std::initializer_list<I> axes, EVS es = EVS()) noexcept
-    {
-        using axes_type = std::vector<typename std::decay_t<E>::size_type>;
-        return sqrt(norm_sq(std::forward<E>(e), xtl::forward_sequence<axes_type>(axes), es));
-    }
-#else
-    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_l2(E&& e, const I (&axes)[N], EVS es = EVS()) noexcept
-    {
-        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
-        return sqrt(norm_sq(std::forward<E>(e), xtl::forward_sequence<axes_type>(axes), es));
-    }
-#endif
-
-    /**
-     * @ingroup red_functions
-     * @brief Infinity (maximum) norm of an array-like argument over given axes.
-     *
-     * Returns an \ref xreducer for the infinity norm of the elements across given \em axes.
-     * @param e an \ref xexpression
-     * @param axes the axes along which the norm is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     * When no axes are provided, the norm is calculated over the entire array. In this case,
-     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
-     */
-    template <class E, class X, class EVS, class>
-    auto norm_linf(E&& e, X&& axes, EVS es) noexcept;
-
-    /**
-     * @ingroup red_functions
-     * @brief p-th power of the Lp norm of an array-like argument over given axes.
-     *
-     * Returns an \ref xreducer for the p-th power of the Lp norm of the elements across given \em axes.
-     * @param e an \ref xexpression
-     * @param p
-     * @param axes the axes along which the norm is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     * When no axes are provided, the norm is calculated over the entire array. In this case,
-     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
-     */
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, class = disable_evaluation_strategy<X>>
-    inline auto norm_lp_to_p(E&& e, double p, X&& axes, EVS es = EVS()) noexcept
-    {
-        using value_type = typename std::decay_t<E>::value_type;
-        using result_type = norm_type_t<std::decay_t<E>>;
-
-        auto reduce_func = [p](result_type const& r, value_type const& v) {
-            return r + norm_lp_to_p(v, p);
-        };
-
-        auto init_func = [p](value_type const& v) {
-            return norm_lp_to_p(v, p);
-        };
-        return reduce(make_xreducer_functor(std::move(reduce_func), std::move(init_func), std::plus<result_type>()),
-                      std::forward<E>(e), std::forward<X>(axes), es);
-    }
-
-    template <class E, XTENSOR_REQUIRE<is_xexpression<E>::value>, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_lp_to_p(E&& e, double p, EVS es = EVS()) noexcept
-    {
-        return norm_lp_to_p(std::forward<E>(e), p, arange(e.dimension()), es);
-    }
-
-#ifdef X_OLD_CLANG
-    template <class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_lp_to_p(E&& e, double p, std::initializer_list<I> axes, EVS es = EVS()) noexcept
-    {
-        using axes_type = std::vector<typename std::decay_t<E>::size_type>;
-        return norm_lp_to_p(std::forward<E>(e), p, xtl::forward_sequence<axes_type>(axes), es);
-    }
-#else
-    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_lp_to_p(E&& e, double p, const I (&axes)[N], EVS es = EVS()) noexcept
-    {
-        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
-        return norm_lp_to_p(std::forward<E>(e), p, xtl::forward_sequence<axes_type>(axes), es);
-    }
-#endif
-
-    /**
-     * @ingroup red_functions
-     * @brief Lp norm of an array-like argument over given axes.
-     *
-     * Returns an \ref xreducer for the Lp norm (p != 0) of the elements across given \em axes.
-     * @param e an \ref xexpression
-     * @param p
-     * @param axes the axes along which the norm is computed (optional)
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     * When no axes are provided, the norm is calculated over the entire array. In this case,
-     * the reducer represents a scalar result, otherwise an array of appropriate dimension.
-     */
-    template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, class = disable_evaluation_strategy<X>>
-    inline auto norm_lp(E&& e, double p, X&& axes, EVS es = EVS())
-    {
-        XTENSOR_PRECONDITION(p != 0,
-                             "norm_lp(): p must be nonzero, use norm_l0() instead.");
-        return pow(norm_lp_to_p(std::forward<E>(e), p, std::forward<X>(axes), es), 1.0 / p);
-    }
-
-    template <class E, XTENSOR_REQUIRE<is_xexpression<E>::value>, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_lp(E&& e, double p, EVS es = EVS())
-    {
-        return norm_lp(std::forward<E>(e), p, arange(e.dimension()), es);
-    }
-
-#ifdef X_OLD_CLANG
-    template <class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_lp(E&& e, double p, std::initializer_list<I> axes, EVS es = EVS())
-    {
-        using axes_type = std::vector<typename std::decay_t<E>::size_type>;
-        return norm_lp(std::forward<E>(e), p, xtl::forward_sequence<axes_type>(axes), es);
-    }
-#else
-    template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_lp(E&& e, double p, const I (&axes)[N], EVS es = EVS())
-    {
-        using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
-        return norm_lp(std::forward<E>(e), p, xtl::forward_sequence<axes_type>(axes), es);
-    }
-#endif
-
-    /**
-     * @ingroup red_functions
-     * @brief Induced L1 norm of a matrix.
-     *
-     * Returns an \ref xreducer for the induced L1 norm (i.e. the maximum of the L1 norms of e's columns).
-     * @param e a 2D \ref xexpression
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     */
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTENSOR_REQUIRE<is_xexpression<E>::value>>
-    inline auto norm_induced_l1(E&& e, EVS es = EVS())
-    {
-        XTENSOR_PRECONDITION(e.dimension() == 2,
-                             "norm_induced_l1(): only applicable to matrices (e.dimension() must be 2).");
-        return norm_linf(norm_l1(std::forward<E>(e), {0}, es), es);
-    }
-
-    /**
-     * @ingroup red_functions
-     * @brief Induced L-infinity norm of a matrix.
-     *
-     * Returns an \ref xreducer for the induced L-infinity norm (i.e. the maximum of the L1 norms of e's rows).
-     * @param e a 2D \ref xexpression
-     * @param es evaluation strategy to use (lazy (default), or immediate)
-     * @return an \ref xreducer (or xcontainer, depending on evaluation strategy)
-     */
-    template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTENSOR_REQUIRE<is_xexpression<E>::value>>
-    inline auto norm_induced_linf(E&& e, EVS es = EVS())
-    {
-        XTENSOR_PRECONDITION(e.dimension() == 2,
-                             "norm_induced_linf(): only applicable to matrices (e.dimension() must be 2).");
-        return norm_linf(norm_l1(std::forward<E>(e), {1}, es), es);
-    }
-
-}  // namespace xt
-
-#endif
diff --git a/include/xtensor/xoffset_view.hpp b/include/xtensor/xoffset_view.hpp
deleted file mode 100644
index 02c0ffb6e..000000000
--- a/include/xtensor/xoffset_view.hpp
+++ /dev/null
@@ -1,41 +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 XTENSOR_OFFSET_VIEW_HPP
-#define XTENSOR_OFFSET_VIEW_HPP
-
-#include <xtl/xcomplex.hpp>
-
-#include "xtensor/xfunctor_view.hpp"
-
-namespace xt
-{
-    namespace detail
-    {
-        template <class M, std::size_t I>
-        struct offset_forwarder
-        {
-            using value_type = M;
-            using reference = M&;
-            using const_reference = const M&;
-            using pointer = M*;
-            using const_pointer = const M*;
-
-            template <class T>
-            decltype(auto) operator()(T&& t) const
-            {
-                return xtl::forward_offset<M, I>(t);
-            }
-        };
-    }
-
-    template <class CT, class M, std::size_t I>
-    using xoffset_view = xfunctor_view<detail::offset_forwarder<M, I>, CT>;
-}
-
-#endif
diff --git a/include/xtensor/xoperation.hpp b/include/xtensor/xoperation.hpp
deleted file mode 100644
index 45b8bfdc8..000000000
--- a/include/xtensor/xoperation.hpp
+++ /dev/null
@@ -1,817 +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 XTENSOR_OPERATION_HPP
-#define XTENSOR_OPERATION_HPP
-
-#include <algorithm>
-#include <functional>
-#include <type_traits>
-
-#include <xtl/xsequence.hpp>
-
-#include "xconcepts.hpp"
-#include "xfunction.hpp"
-#include "xscalar.hpp"
-#include "xstrides.hpp"
-#include "xstrided_view.hpp"
-#include "xmanipulation.hpp"
-
-namespace xt
-{
-
-    /***********
-     * helpers *
-     ***********/
-
-#define UNARY_OPERATOR_FUNCTOR_IMPL(NAME, OP, R)                                \
-    struct NAME                                                                 \
-    {                                                                           \
-        template <class A1>                                                     \
-        constexpr auto operator()(const A1& arg) const                          \
-        {                                                                       \
-            return OP arg;                                                      \
-        }                                                                       \
-        template <class B>                                                      \
-        constexpr auto simd_apply(const B& arg) const                           \
-        {                                                                       \
-            return OP arg;                                                      \
-        }                                                                       \
-    }
-
-#define UNARY_OPERATOR_FUNCTOR(NAME, OP) UNARY_OPERATOR_FUNCTOR_IMPL(NAME, OP, T)
-#define UNARY_BOOL_OPERATOR_FUNCTOR(NAME, OP) UNARY_OPERATOR_FUNCTOR_IMPL(NAME, OP, bool)
-
-    /* In this macro, T is assumed to be the promote_type of all arguments.
-       Nonetheless, operator() is implemented as a function template,
-       because automatic conversion of the actual argument types to T may
-       cause 'possible loss of data' warnings, e.g. when T is double and an
-       argument is uint64_t.
-    */
-#define BINARY_OPERATOR_FUNCTOR_IMPL(NAME, OP, R)                                \
-    struct NAME                                                                  \
-    {                                                                            \
-        template <class T1, class T2>                                            \
-        constexpr auto operator()(const T1& arg1, const T2& arg2) const          \
-        {                                                                        \
-            return (arg1 OP arg2);                                               \
-        }                                                                        \
-        template <class B>                                                       \
-        constexpr auto simd_apply(const B& arg1, const B& arg2) const            \
-        {                                                                        \
-            return (arg1 OP arg2);                                               \
-        }                                                                        \
-    }
-
-#define BINARY_OPERATOR_FUNCTOR(NAME, OP) BINARY_OPERATOR_FUNCTOR_IMPL(NAME, OP, T)
-#define BINARY_BOOL_OPERATOR_FUNCTOR(NAME, OP) BINARY_OPERATOR_FUNCTOR_IMPL(NAME, OP, bool)
-
-    namespace detail
-    {
-
-        UNARY_OPERATOR_FUNCTOR(identity, +);
-        UNARY_OPERATOR_FUNCTOR(negate, -);
-        BINARY_OPERATOR_FUNCTOR(plus, +);
-        BINARY_OPERATOR_FUNCTOR(minus, -);
-        BINARY_OPERATOR_FUNCTOR(multiplies, *);
-        BINARY_OPERATOR_FUNCTOR(divides, /);
-        BINARY_OPERATOR_FUNCTOR(modulus, %);
-        BINARY_BOOL_OPERATOR_FUNCTOR(logical_or, ||);
-        BINARY_BOOL_OPERATOR_FUNCTOR(logical_and, &&);
-        UNARY_BOOL_OPERATOR_FUNCTOR(logical_not, !);
-        BINARY_OPERATOR_FUNCTOR(bitwise_or, |);
-        BINARY_OPERATOR_FUNCTOR(bitwise_and, &);
-        BINARY_OPERATOR_FUNCTOR(bitwise_xor, ^);
-        UNARY_OPERATOR_FUNCTOR(bitwise_not, ~);
-        BINARY_OPERATOR_FUNCTOR(left_shift, <<);
-        BINARY_OPERATOR_FUNCTOR(right_shift, >>);
-        BINARY_BOOL_OPERATOR_FUNCTOR(less, <);
-        BINARY_BOOL_OPERATOR_FUNCTOR(less_equal, <=);
-        BINARY_BOOL_OPERATOR_FUNCTOR(greater, >);
-        BINARY_BOOL_OPERATOR_FUNCTOR(greater_equal, >=);
-        BINARY_BOOL_OPERATOR_FUNCTOR(equal_to, ==);
-        BINARY_BOOL_OPERATOR_FUNCTOR(not_equal_to, !=);
-
-        struct conditional_ternary
-        {
-            template <class B>
-            using get_batch_bool = typename xsimd::simd_traits<typename xsimd::revert_simd_traits<B>::type>::bool_type;
-
-            template <class A1, class A2>
-            constexpr auto operator()(bool t1, const A1& t2, const A2& t3) const noexcept
-            {
-                return t1 ? t2 : t3;
-            }
-            template <class B>
-            constexpr B simd_apply(const get_batch_bool<B>& t1,
-                                   const B& t2,
-                                   const B& t3) const noexcept
-            {
-                return xsimd::select(t1, t2, t3);
-            }
-        };
-
-        template <class R>
-        struct cast
-        {
-            struct functor
-            {
-                using result_type = R;
-
-                template <class A1>
-                constexpr result_type operator()(const A1& arg) const
-                {
-                    return static_cast<R>(arg);
-                }
-                // SIMD conversion disabled for now since it does not make sense
-                // in most of the cases
-                /*constexpr simd_result_type simd_apply(const simd_value_type& arg) const
-                {
-                    return static_cast<R>(arg);
-                }*/
-            };
-        };
-
-        template <class Tag, class F, class... E>
-        struct select_xfunction_expression;
-
-        template <class F, class... E>
-        struct select_xfunction_expression<xtensor_expression_tag, F, E...>
-        {
-            using type = xfunction<F, E...>;
-        };
-
-        template <class F, class... E>
-        struct select_xfunction_expression<xoptional_expression_tag, F, E...>
-        {
-            using type = xfunction<F, E...>;
-        };
-
-        template <class Tag, class F, class... E>
-        using select_xfunction_expression_t = typename select_xfunction_expression<Tag, F, E...>::type;
-
-        template <class F, class... E>
-        struct xfunction_type
-        {
-            using expression_tag = xexpression_tag_t<E...>;
-            using functor_type = F;
-            using type = select_xfunction_expression_t<expression_tag,
-                                                       functor_type,
-                                                       const_xclosure_t<E>...>;
-        };
-
-        template <class F, class... E>
-        inline auto make_xfunction(E&&... e) noexcept
-        {
-            using function_type = xfunction_type<F, E...>;
-            using functor_type = typename function_type::functor_type;
-            using type = typename function_type::type;
-            return type(functor_type(), std::forward<E>(e)...);
-        }
-
-        // On MSVC, the second argument of enable_if_t is always evaluated, even if the condition is false.
-        // Wrapping the xfunction type in the xfunction_type metafunction avoids this evaluation when
-        // the condition is false, since it leads to a tricky bug preventing from using operator+ and operator-
-        // on vector and arrays iterators.
-        template <class F, class... E>
-        using xfunction_type_t = typename std::enable_if_t<has_xexpression<std::decay_t<E>...>::value,
-                                                           xfunction_type<F, E...>>::type;
-    }
-
-#undef UNARY_OPERATOR_FUNCTOR
-#undef UNARY_BOOL_OPERATOR_FUNCTOR
-#undef UNARY_OPERATOR_FUNCTOR_IMPL
-#undef BINARY_OPERATOR_FUNCTOR
-#undef BINARY_BOOL_OPERATOR_FUNCTOR
-#undef BINARY_OPERATOR_FUNCTOR_IMPL
-
-    /*************
-     * operators *
-     *************/
-
-    /**
-     * @defgroup arithmetic_operators Arithmetic operators
-     */
-
-    /**
-     * @ingroup arithmetic_operators
-     * @brief Identity
-     *
-     * Returns an \ref xfunction for the element-wise identity
-     * of \a e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto operator+(E&& e) noexcept
-        -> detail::xfunction_type_t<detail::identity, E>
-    {
-        return detail::make_xfunction<detail::identity>(std::forward<E>(e));
-    }
-
-    /**
-    * @ingroup arithmetic_operators
-    * @brief Opposite
-    *
-    * Returns an \ref xfunction for the element-wise opposite
-    * of \a e.
-    * @param e an \ref xexpression
-    * @return an \ref xfunction
-    */
-    template <class E>
-    inline auto operator-(E&& e) noexcept
-        -> detail::xfunction_type_t<detail::negate, E>
-    {
-        return detail::make_xfunction<detail::negate>(std::forward<E>(e));
-    }
-
-    /**
-    * @ingroup arithmetic_operators
-    * @brief Addition
-    *
-    * Returns an \ref xfunction for the element-wise addition
-    * of \a e1 and \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator+(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::plus, E1, E2>
-    {
-        return detail::make_xfunction<detail::plus>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup arithmetic_operators
-    * @brief Substraction
-    *
-    * Returns an \ref xfunction for the element-wise substraction
-    * of \a e2 to \a e1.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator-(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::minus, E1, E2>
-    {
-        return detail::make_xfunction<detail::minus>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup arithmetic_operators
-    * @brief Multiplication
-    *
-    * Returns an \ref xfunction for the element-wise multiplication
-    * of \a e1 by \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator*(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::multiplies, E1, E2>
-    {
-        return detail::make_xfunction<detail::multiplies>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup arithmetic_operators
-    * @brief Division
-    *
-    * Returns an \ref xfunction for the element-wise division
-    * of \a e1 by \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator/(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::divides, E1, E2>
-    {
-        return detail::make_xfunction<detail::divides>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup arithmetic_operators
-     * @brief Modulus
-     *
-     * Returns an \ref xfunction for the element-wise modulus
-     * of \a e1 by \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto operator%(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::modulus, E1, E2>
-    {
-        return detail::make_xfunction<detail::modulus>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @defgroup logical_operators Logical operators
-     */
-
-    /**
-     * @ingroup logical_operators
-     * @brief Or
-     *
-     * Returns an \ref xfunction for the element-wise or
-     * of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto operator||(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::logical_or, E1, E2>
-    {
-        return detail::make_xfunction<detail::logical_or>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup logical_operators
-    * @brief And
-    *
-    * Returns an \ref xfunction for the element-wise and
-    * of \a e1 and \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator&&(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::logical_and, E1, E2>
-    {
-        return detail::make_xfunction<detail::logical_and>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup logical_operators
-    * @brief Not
-    *
-    * Returns an \ref xfunction for the element-wise not
-    * of \a e.
-    * @param e an \ref xexpression
-    * @return an \ref xfunction
-    */
-    template <class E>
-    inline auto operator!(E&& e) noexcept
-        -> detail::xfunction_type_t<detail::logical_not, E>
-    {
-        return detail::make_xfunction<detail::logical_not>(std::forward<E>(e));
-    }
-
-    /**
-     * @defgroup bitwise_operators Bitwise operators
-     */
-
-    /**
-     * @ingroup bitwise_operators
-     * @brief Bitwise and
-     *
-     * Returns an \ref xfunction for the element-wise bitwise and
-     * of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto operator&(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::bitwise_and, E1, E2>
-    {
-        return detail::make_xfunction<detail::bitwise_and>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup bitwise_operators
-     * @brief Bitwise or
-     *
-     * Returns an \ref xfunction for the element-wise bitwise or
-     * of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto operator|(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::bitwise_or, E1, E2>
-    {
-        return detail::make_xfunction<detail::bitwise_or>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup bitwise_operators
-     * @brief Bitwise xor
-     *
-     * Returns an \ref xfunction for the element-wise bitwise xor
-     * of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto operator^(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::bitwise_xor, E1, E2>
-    {
-        return detail::make_xfunction<detail::bitwise_xor>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup bitwise_operators
-     * @brief Bitwise not
-     *
-     * Returns an \ref xfunction for the element-wise bitwise not
-     * of \a e.
-     * @param e an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E>
-    inline auto operator~(E&& e) noexcept
-        -> detail::xfunction_type_t<detail::bitwise_not, E>
-    {
-        return detail::make_xfunction<detail::bitwise_not>(std::forward<E>(e));
-    }
-
-    /**
-     * @ingroup bitwise_operators
-     * @brief Bitwise left shift
-     *
-     * Returns an \ref xfunction for the element-wise bitwise left shift of e1
-     * by e2.
-     * @param e1 an \ref xexpression
-     * @param e2 an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto left_shift(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::left_shift, E1, E2>
-    {
-        return detail::make_xfunction<detail::left_shift>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup bitwise_operators
-     * @brief Bitwise left shift
-     *
-     * Returns an \ref xfunction for the element-wise bitwise left shift of e1
-     * by e2.
-     * @param e1 an \ref xexpression
-     * @param e2 an \ref xexpression
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto right_shift(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::right_shift, E1, E2>
-    {
-        return detail::make_xfunction<detail::right_shift>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @defgroup comparison_operators Comparison operators
-     */
-
-    /**
-     * @ingroup comparison_operators
-     * @brief Lesser than
-     *
-     * Returns an \ref xfunction for the element-wise
-     * lesser than comparison of \a e1 and \a e2.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-    template <class E1, class E2>
-    inline auto operator<(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::less, E1, E2>
-    {
-        return detail::make_xfunction<detail::less>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup comparison_operators
-    * @brief Lesser or equal
-    *
-    * Returns an \ref xfunction for the element-wise
-    * lesser or equal comparison of \a e1 and \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator<=(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::less_equal, E1, E2>
-    {
-        return detail::make_xfunction<detail::less_equal>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup comparison_operators
-    * @brief Greater than
-    *
-    * Returns an \ref xfunction for the element-wise
-    * greater than comparison of \a e1 and \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator>(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::greater, E1, E2>
-    {
-        return detail::make_xfunction<detail::greater>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup comparison_operators
-    * @brief Greater or equal
-    *
-    * Returns an \ref xfunction for the element-wise
-    * greater or equal comparison of \a e1 and \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto operator>=(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::greater_equal, E1, E2>
-    {
-        return detail::make_xfunction<detail::greater_equal>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-     * @ingroup comparison_operators
-     * @brief Equality
-     *
-     * Returns true if \a e1 and \a e2 have the same shape
-     * and hold the same values. Unlike other comparison
-     * operators, this does not return an \ref xfunction.
-     * @param e1 an \ref xexpression or a scalar
-     * @param e2 an \ref xexpression or a scalar
-     * @return a boolean
-     */
-    template <class E1, class E2>
-    inline std::enable_if_t<xoptional_comparable<E1, E2>::value, bool>
-    operator==(const xexpression<E1>& e1, const xexpression<E2>& e2)
-    {
-        const E1& de1 = e1.derived_cast();
-        const E2& de2 = e2.derived_cast();
-        bool res = de1.dimension() == de2.dimension() && std::equal(de1.shape().begin(), de1.shape().end(), de2.shape().begin());
-        auto iter1 = de1.begin();
-        auto iter2 = de2.begin();
-        auto iter_end = de1.end();
-        while (res && iter1 != iter_end)
-        {
-            res = (*iter1++ == *iter2++);
-        }
-        return res;
-    }
-
-    /**
-    * @ingroup comparison_operators
-    * @brief Inequality
-    *
-    * Returns true if \a e1 and \a e2 have different shapes
-    * or hold the different values. Unlike other comparison
-    * operators, this does not return an \ref xfunction.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return a boolean
-    */
-    template <class E1, class E2>
-    inline bool operator!=(const xexpression<E1>& e1, const xexpression<E2>& e2)
-    {
-        return !(e1 == e2);
-    }
-
-    /**
-    * @ingroup comparison_operators
-    * @brief Element-wise equality
-    *
-    * Returns an \ref xfunction for the element-wise
-    * equality of \a e1 and \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto equal(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::equal_to, E1, E2>
-    {
-        return detail::make_xfunction<detail::equal_to>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup comparison_operators
-    * @brief Element-wise inequality
-    *
-    * Returns an \ref xfunction for the element-wise
-    * inequality of \a e1 and \a e2.
-    * @param e1 an \ref xexpression or a scalar
-    * @param e2 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2>
-    inline auto not_equal(E1&& e1, E2&& e2) noexcept
-        -> detail::xfunction_type_t<detail::not_equal_to, E1, E2>
-    {
-        return detail::make_xfunction<detail::not_equal_to>(std::forward<E1>(e1), std::forward<E2>(e2));
-    }
-
-    /**
-    * @ingroup logical_operators
-    * @brief Ternary selection
-    *
-    * Returns an \ref xfunction for the element-wise
-    * ternary selection (i.e. operator ? :) of \a e1,
-    * \a e2 and \a e3.
-    * @param e1 a boolean \ref xexpression
-    * @param e2 an \ref xexpression or a scalar
-    * @param e3 an \ref xexpression or a scalar
-    * @return an \ref xfunction
-    */
-    template <class E1, class E2, class E3>
-    inline auto where(E1&& e1, E2&& e2, E3&& e3) noexcept
-        -> detail::xfunction_type_t<detail::conditional_ternary, E1, E2, E3>
-    {
-        return detail::make_xfunction<detail::conditional_ternary>(std::forward<E1>(e1), std::forward<E2>(e2), std::forward<E3>(e3));
-    }
-
-    namespace detail
-    {
-        template <class S, class I>
-        inline auto next_idx(const S& shape, I& idx)
-        {
-            for (std::size_t j = shape.size(); j > 0; --j)
-            {
-                std::size_t i = j - 1;
-                if (idx[i] >= shape[i] - 1)
-                {
-                    idx[i] = 0;
-                }
-                else
-                {
-                    idx[i]++;
-                    return idx;
-                }
-            }
-            // return empty index, happens at last iteration step, but remains unused
-            return I();
-        }
-    }
-
-    /**
-     * @ingroup logical_operators
-     * @brief return vector of indices where T is not zero
-     *
-     * @param arr input array
-     * @return vector of vectors, one for each dimension of arr, containing
-     * the indices of the non-zero elements in that dimension
-     */
-    template <class T>
-    inline auto nonzero(const T& arr)
-    {
-        auto shape = arr.shape();
-        using index_type = xindex_type_t<typename T::shape_type>;
-        using size_type = typename T::size_type;
-
-        auto idx = xtl::make_sequence<index_type>(arr.dimension(), 0);
-        std::vector<std::vector<size_type>> indices(arr.dimension());
-
-        size_type total_size = compute_size(shape);
-        for (size_type i = 0; i < total_size; i++, detail::next_idx(shape, idx))
-        {
-            if (arr.element(std::begin(idx), std::end(idx)))
-            {
-                for (std::size_t n = 0; n < indices.size(); ++n)
-                {
-                    indices.at(n).push_back(idx[n]);
-                }
-            }
-        }
-
-        return indices;
-    }
-
-    /**
-     * @ingroup logical_operators
-     * @brief return indices that are non-zero in the flattened version of arr,
-     * equivalent to nonzero(ravel<layout_type>(arr))[0];
-     *
-     * @param arr input array
-     * @return indices that are non-zero in the flattened version of arr
-     */
-    template <layout_type L, class T>
-    inline auto flatnonzero(const T& arr)
-    {
-        return nonzero(ravel<L>(arr))[0];
-    }
-
-    /**
-     * @ingroup logical_operators
-     * @brief return vector of indices where condition is true
-     *        (equivalent to \a nonzero(condition))
-     *
-     * @param condition input array
-     * @return vector of \a index_types where condition is not equal to zero
-     */
-    template <class T>
-    inline auto where(const T& condition)
-    {
-        return nonzero(condition);
-    }
-
-    /**
-     * @ingroup logical_operators
-     * @brief return vector of indices where arr is not zero
-     *
-     * @param arr input array
-     * @return vector of index_types where arr is not equal to zero
-     */
-    template <class T>
-    inline auto argwhere(const T& arr)
-    {
-        auto shape = arr.shape();
-        using index_type = xindex_type_t<typename T::shape_type>;
-        using size_type = typename T::size_type;
-
-        auto idx = xtl::make_sequence<index_type>(arr.dimension(), 0);
-        std::vector<index_type> indices;
-
-        size_type total_size = compute_size(shape);
-        for (size_type i = 0; i < total_size; i++, detail::next_idx(shape, idx))
-        {
-            if (arr.element(std::begin(idx), std::end(idx)))
-            {
-                indices.push_back(idx);
-            }
-        }
-
-        return indices;
-    }
-
-    /**
-    * @ingroup logical_operators
-    * @brief Any
-    *
-    * Returns true if any of the values of \a e is truthy,
-    * false otherwise.
-    * @param e an \ref xexpression
-    * @return a boolean
-    */
-    template <class E>
-    inline bool any(E&& e)
-    {
-        using xtype = std::decay_t<E>;
-        using value_type = typename xtype::value_type;
-        return std::any_of(e.cbegin(), e.cend(), [](const value_type& el) { return el; });
-    }
-
-    /**
-    * @ingroup logical_operators
-    * @brief Any
-    *
-    * Returns true if all of the values of \a e are truthy,
-    * false otherwise.
-    * @param e an \ref xexpression
-    * @return a boolean
-    */
-    template <class E>
-    inline bool all(E&& e)
-    {
-        using xtype = std::decay_t<E>;
-        using value_type = typename xtype::value_type;
-        return std::all_of(e.cbegin(), e.cend(), [](const value_type& el) { return el; });
-    }
-
-    /**
-     * @defgroup casting_operators Casting operators
-     */
-
-    /**
-     * @ingroup casting_operators
-     * @brief Element-wise ``static_cast``.
-     *
-     * Returns an \ref xfunction for the element-wise
-     * static_cast of \a e to type R.
-     *
-     * @param e an \ref xexpression or a scalar
-     * @return an \ref xfunction
-     */
-
-    template <class R, class E>
-    inline auto cast(E&& e) noexcept
-        -> detail::xfunction_type_t<typename detail::cast<R>::functor, E>
-    {
-        return detail::make_xfunction<typename detail::cast<R>::functor>(std::forward<E>(e));
-    }
-}
-
-#endif
diff --git a/include/xtensor/xrandom.hpp b/include/xtensor/xrandom.hpp
deleted file mode 100644
index 2f26e26e0..000000000
--- a/include/xtensor/xrandom.hpp
+++ /dev/null
@@ -1,390 +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. *
-****************************************************************************/
-
-/**
- * @brief functions to obtain xgenerators generating random numbers with given shape
- */
-
-#ifndef XTENSOR_RANDOM_HPP
-#define XTENSOR_RANDOM_HPP
-
-#include <functional>
-#include <random>
-#include <utility>
-
-#include "xbuilder.hpp"
-#include "xgenerator.hpp"
-#include "xtensor.hpp"
-#include "xview.hpp"
-
-namespace xt
-{
-    /*********************
-     * Random generators *
-     *********************/
-
-    namespace random
-    {
-        using default_engine_type = std::mt19937;
-        using seed_type = default_engine_type::result_type;
-
-        default_engine_type& get_default_random_engine();
-        void seed(seed_type seed);
-
-        template <class T, class S, class E = random::default_engine_type>
-        auto rand(const S& shape, T lower = 0, T upper = 1,
-                  E& engine = random::get_default_random_engine());
-
-        template <class T, class S, class E = random::default_engine_type>
-        auto randint(const S& shape, T lower = 0, T upper = (std::numeric_limits<T>::max)(),
-                     E& engine = random::get_default_random_engine());
-
-        template <class T, class S, class E = random::default_engine_type>
-        auto randn(const S& shape, T mean = 0, T std_dev = 1,
-                   E& engine = random::get_default_random_engine());
-
-#ifdef X_OLD_CLANG
-        template <class T, class I, class E = random::default_engine_type>
-        auto rand(std::initializer_list<I> shape, T lower = 0, T upper = 1,
-                  E& engine = random::get_default_random_engine());
-
-        template <class T, class I, class E = random::default_engine_type>
-        auto randint(std::initializer_list<I> shape,
-                     T lower = 0, T upper = (std::numeric_limits<T>::max)(),
-                     E& engine = random::get_default_random_engine());
-
-        template <class T, class I, class E = random::default_engine_type>
-        auto randn(std::initializer_list<I>, T mean = 0, T std_dev = 1,
-                   E& engine = random::get_default_random_engine());
-#else
-        template <class T, class I, std::size_t L, class E = random::default_engine_type>
-        auto rand(const I (&shape)[L], T lower = 0, T upper = 1,
-                  E& engine = random::get_default_random_engine());
-
-        template <class T, class I, std::size_t L, class E = random::default_engine_type>
-        auto randint(const I (&shape)[L], T lower = 0, T upper = (std::numeric_limits<T>::max)(),
-                     E& engine = random::get_default_random_engine());
-
-        template <class T, class I, std::size_t L, class E = random::default_engine_type>
-        auto randn(const I (&shape)[L], T mean = 0, T std_dev = 1,
-                   E& engine = random::get_default_random_engine());
-#endif
-
-        template <class T, class E = random::default_engine_type>
-        void shuffle(xexpression<T>& e, E& engine = random::get_default_random_engine());
-
-        template <class T, class E = random::default_engine_type>
-        std::enable_if_t<std::is_integral<T>::value, xtensor<T, 1>>
-        permutation(T e, E& engine = random::get_default_random_engine());
-
-        template <class T, class E = random::default_engine_type>
-        std::enable_if_t<is_xexpression<std::decay_t<T>>::value, std::decay_t<T>>
-        permutation(T&& e, E& engine = random::get_default_random_engine());
-
-        template <class T, class E = random::default_engine_type>
-        xtensor<typename T::value_type, 1> choice(const xexpression<T>& e, std::size_t n, bool replace = true,
-                                                  E& engine = random::get_default_random_engine());
-    }
-
-    namespace detail
-    {
-        template <class T, class E, class D>
-        struct random_impl
-        {
-            using value_type = T;
-
-            random_impl(E& engine, D&& dist)
-                : m_engine(engine), m_dist(std::move(dist))
-            {
-            }
-
-            template <class... Args>
-            inline value_type operator()(Args...) const
-            {
-                return m_dist(m_engine);
-            }
-
-            template <class It>
-            inline value_type element(It, It) const
-            {
-                return m_dist(m_engine);
-            }
-
-            template <class EX>
-            inline void assign_to(xexpression<EX>& e) const noexcept
-            {
-                // Note: we're not going row/col major here
-                auto& ed = e.derived_cast();
-                for (auto& el : ed.storage())
-                {
-                    el = m_dist(m_engine);
-                }
-            }
-
-        private:
-
-            E& m_engine;
-            mutable D m_dist;
-        };
-    }
-
-    namespace random
-    {
-        /**
-         * Returns a reference to the default random number engine
-         */
-        inline default_engine_type& get_default_random_engine()
-        {
-            static default_engine_type mt;
-            return mt;
-        }
-
-        /**
-         * Seeds the default random number generator with @p seed
-         * @param seed The seed
-         */
-        inline void seed(seed_type seed)
-        {
-            get_default_random_engine().seed(seed);
-        }
-
-        /**
-         * xexpression with specified @p shape containing uniformly distributed random numbers
-         * in the interval from @p lower to @p upper, excluding upper.
-         *
-         * Numbers are drawn from @c std::uniform_real_distribution.
-         *
-         * @param shape shape of resulting xexpression
-         * @param lower lower bound
-         * @param upper upper bound
-         * @param engine random number engine
-         * @tparam T number type to use
-         */
-        template <class T, class S, class E>
-        inline auto rand(const S& shape, T lower, T upper, E& engine)
-        {
-            std::uniform_real_distribution<T> dist(lower, upper);
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-
-        /**
-         * xexpression with specified @p shape containing uniformly distributed
-         * random integers in the interval from @p lower to @p upper, excluding upper.
-         *
-         * Numbers are drawn from @c std::uniform_int_distribution.
-         *
-         * @param shape shape of resulting xexpression
-         * @param lower lower bound
-         * @param upper upper bound
-         * @param engine random number engine
-         * @tparam T number type to use
-         */
-        template <class T, class S, class E>
-        inline auto randint(const S& shape, T lower, T upper, E& engine)
-        {
-            std::uniform_int_distribution<T> dist(lower, T(upper - 1));
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-
-        /**
-         * xexpression with specified @p shape containing numbers sampled from
-         * the Normal (Gaussian) random number distribution with mean @p mean and
-         * standard deviation @p std_dev.
-         *
-         * Numbers are drawn from @c std::normal_distribution.
-         *
-         * @param shape shape of resulting xexpression
-         * @param mean mean of normal distribution
-         * @param std_dev standard deviation of normal distribution
-         * @param engine random number engine
-         * @tparam T number type to use
-         */
-        template <class T, class S, class E>
-        inline auto randn(const S& shape, T mean, T std_dev, E& engine)
-        {
-            std::normal_distribution<T> dist(mean, std_dev);
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-
-#ifdef X_OLD_CLANG
-        template <class T, class I, class E>
-        inline auto rand(std::initializer_list<I> shape, T lower, T upper, E& engine)
-        {
-            std::uniform_real_distribution<T> dist(lower, upper);
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-
-        template <class T, class I, class E>
-        inline auto randint(std::initializer_list<I> shape, T lower, T upper, E& engine)
-        {
-            std::uniform_int_distribution<T> dist(lower, T(upper - 1));
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-
-        template <class T, class I, class E>
-        inline auto randn(std::initializer_list<I> shape, T mean, T std_dev, E& engine)
-        {
-            std::normal_distribution<T> dist(mean, std_dev);
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-#else
-        template <class T, class I, std::size_t L, class E>
-        inline auto rand(const I (&shape)[L], T lower, T upper, E& engine)
-        {
-            std::uniform_real_distribution<T> dist(lower, upper);
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-
-        template <class T, class I, std::size_t L, class E>
-        inline auto randint(const I (&shape)[L], T lower, T upper, E& engine)
-        {
-            std::uniform_int_distribution<T> dist(lower, T(upper - 1));
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-
-        template <class T, class I, std::size_t L, class E>
-        inline auto randn(const I (&shape)[L], T mean, T std_dev, E& engine)
-        {
-            std::normal_distribution<T> dist(mean, std_dev);
-            return detail::make_xgenerator(detail::random_impl<T, E, decltype(dist)>(engine, std::move(dist)), shape);
-        }
-#endif
-
-        /**
-         * Randomly shuffle elements inplace in xcontainer along first axis.
-         * The order of sub-arrays is changed but their contents remain the same.
-         *
-         * @param e xcontainer to shuffle inplace
-         * @param engine random number engine
-         */
-        template <class T, class E>
-        void shuffle(xexpression<T>& e, E& engine)
-        {
-            T& de = e.derived_cast();
-
-            if (de.dimension() == 1)
-            {
-                using size_type = typename T::size_type;
-                auto first = de.begin();
-                auto last = de.end();
-
-                for (size_type i = std::size_t((last - first) - 1); i > 0; --i)
-                {
-                    std::uniform_int_distribution<size_type> dist(0, i);
-                    auto j = dist(engine);
-                    using std::swap;
-                    swap(first[i], first[j]);
-                }
-            }
-            else
-            {
-                using size_type = typename T::size_type;
-                decltype(auto) buf = empty_like(view(de, 0));
-
-                for (size_type i = de.shape()[0] - 1; i > 0; --i)
-                {
-                    std::uniform_int_distribution<size_type> dist(0, i);
-                    size_type j = dist(engine);
-
-                    buf = view(de, j);
-                    view(de, j) = view(de, i);
-                    view(de, i) = buf;
-                }
-            }
-        }
-
-        /**
-         * Randomly permute a sequence, or return a permuted range.
-         *
-         * If the first parameter is an integer, this function creates a new
-         * ``arange(e)`` and returns it randomly permuted. Otherwise, this
-         * function creates a copy of the input, passes it to @sa shuffle and
-         * returns the result.
-         *
-         * @param e input xexpression or integer
-         * @param engine random number engine to use (optional)
-         *
-         * @return randomly permuted copy of container or arange.
-         */
-        template <class T, class E>
-        std::enable_if_t<std::is_integral<T>::value, xtensor<T, 1>>
-        permutation(T e, E& engine)
-        {
-            xt::xtensor<T, 1> res = xt::arange<T>(e);
-            shuffle(res, engine);
-            return res;
-        }
-
-        /// @cond DOXYGEN_INCLUDE_SFINAE
-        template <class T, class E>
-        std::enable_if_t<is_xexpression<std::decay_t<T>>::value, std::decay_t<T>>
-        permutation(T&& e, E& engine)
-        {
-            using copy_type = std::decay_t<T>;
-            copy_type res = e;
-            shuffle(res, engine);
-            return res;
-        }
-        /// @endcond
-
-        /**
-         * Randomly select n unique elements from xexpression e.
-         * Note: this function makes a copy of your data, and only 1D data is accepted.
-         *
-         * @param e expression to sample from
-         * @param n number of elements to sample
-         * @param replace whether to sample with or without replacement
-         * @param engine random number engine
-         *
-         * @return xtensor containing 1D container of sampled elements
-         */
-        template <class T, class E>
-        xtensor<typename T::value_type, 1> choice(const xexpression<T>& e, std::size_t n, bool replace, E& engine)
-        {
-            const auto& de = e.derived_cast();
-            if (de.dimension() != 1)
-            {
-                throw std::runtime_error("Sample expression must be 1 dimensional");
-            }
-            if (de.size() < n && !replace)
-            {
-                throw std::runtime_error("If replace is false, then the sample expression's size must be > n");
-            }
-            using result_type = xtensor<typename T::value_type, 1>;
-            using size_type = typename result_type::size_type;
-            result_type result;
-            result.resize({n});
-
-            if (replace)
-            {
-                auto dist = std::uniform_int_distribution<size_type>(0, de.size() - 1);
-                for (size_type i = 0; i < n; ++i)
-                {
-                    result[i] = de.storage()[dist(engine)];
-                }
-            }
-            else
-            {
-                // Naive resevoir sampling without weighting:
-                std::copy(de.storage().begin(), de.storage().begin() + n, result.begin());
-                size_type i = n;
-                for(auto it = de.storage().begin() + n; it != de.storage().end(); ++it, ++i)
-                {
-                    auto idx = std::uniform_int_distribution<size_type>(0, i)(engine);
-                    if (idx < n)
-                    {
-                        result.storage()[idx] = *it;
-                    }
-                }
-            }
-            return result;
-        }
-    }
-}
-
-#endif
diff --git a/include/xtensor/xreducer.hpp b/include/xtensor/xreducer.hpp
deleted file mode 100644
index 7bdf77940..000000000
--- a/include/xtensor/xreducer.hpp
+++ /dev/null
@@ -1,1177 +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 XTENSOR_REDUCER_HPP
-#define XTENSOR_REDUCER_HPP
-
-#include <algorithm>
-#include <cstddef>
-#include <initializer_list>
-#include <iterator>
-#include <stdexcept>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#ifdef X_OLD_CLANG
-#include <vector>
-#endif
-
-#include <xtl/xfunctional.hpp>
-#include <xtl/xsequence.hpp>
-
-#include "xbuilder.hpp"
-#include "xeval.hpp"
-#include "xexpression.hpp"
-#include "xgenerator.hpp"
-#include "xiterable.hpp"
-#include "xreducer.hpp"
-#include "xutils.hpp"
-
-namespace xt
-{
-    /**********
-     * reduce *
-     **********/
-
-#define DEFAULT_STRATEGY_REDUCERS evaluation_strategy::lazy
-
-    template <class F, class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              class = std::enable_if_t<!std::is_base_of<evaluation_strategy::base, std::decay_t<X>>::value, int>>
-    auto reduce(F&& f, E&& e, X&& axes, EVS es = EVS());
-
-    template <class F, class E, class EVS = DEFAULT_STRATEGY_REDUCERS,
-              class = std::enable_if_t<std::is_base_of<evaluation_strategy::base, EVS>::value, int>>
-    auto reduce(F&& f, E&& e, EVS es = EVS());
-
-#ifdef X_OLD_CLANG
-    template <class F, class E, class I, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    auto reduce(F&& f, E&& e, std::initializer_list<I> axes, EVS es = EVS());
-#else
-    template <class F, class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    auto reduce(F&& f, E&& e, const I (&axes)[N], EVS es = EVS());
-#endif
-
-    template <class ST, class X>
-    struct xreducer_shape_type;
-
-    template <class S1, class S2>
-    struct fixed_xreducer_shape_type;
-
-    template <class E, class X, class result_type>
-    struct xreducer_result_container
-    {
-        using type = xarray<result_type, std::decay_t<E>::static_layout>;
-    };
-
-    template <class T, std::size_t N, layout_type L, class A, class X, std::size_t NX, class result_type>
-    struct xreducer_result_container<xtensor<T, N, L, A>, std::array<X, NX>, result_type>
-    {
-        using type = xtensor<result_type, N - NX, L>;
-    };
-
-    template <class T, std::size_t... N, layout_type L, class X, std::size_t NX, class result_type>
-    struct xreducer_result_container<xtensor_fixed<T, xshape<N...>, L>, std::array<X, NX>, result_type>
-    {
-        using type = xtensor<result_type, sizeof...(N) - NX, L>;
-    };
-
-    template <class T, std::size_t... I, layout_type L, std::size_t... X, class result_type>
-    struct xreducer_result_container<xtensor_fixed<T, xshape<I...>, L>, xshape<X...>, result_type>
-    {
-        using type = xtensor_fixed<result_type, typename fixed_xreducer_shape_type<fixed_shape<I...>, fixed_shape<X...>>::type, L>;
-    };
-
-    template <class F, class E, class X>
-    inline auto reduce_immediate(F&& f, E&& e, X&& axes)
-    {
-        using shape_type = typename xreducer_shape_type<typename std::decay_t<E>::shape_type, std::decay_t<X>>::type;
-
-        using reduce_functor_type = typename std::decay_t<F>::reduce_functor_type;
-        using init_functor_type = typename std::decay_t<F>::init_functor_type;
-
-        using expr_value_type = typename std::decay_t<E>::value_type;
-
-        using result_type = std::decay_t<decltype(std::declval<reduce_functor_type>()(
-            std::declval<init_functor_type>()(std::declval<expr_value_type>()), std::declval<expr_value_type>()))>;
-
-        // retrieve functors from triple struct
-        auto reduce_fct = std::get<0>(f);
-        auto init_fct = std::get<1>(f);
-        auto merge_fct = std::get<2>(f);
-
-        shape_type result_shape{};
-        resize_container(result_shape, e.dimension() - axes.size());
-
-        dynamic_shape<std::size_t> iter_shape = xtl::forward_sequence<dynamic_shape<std::size_t>>(e.shape());
-        dynamic_shape<std::size_t> iter_strides(e.dimension());
-
-        using result_container_type = typename xreducer_result_container<std::decay_t<E>, X, result_type>::type;
-        result_container_type result;
-
-        if (!std::is_sorted(axes.cbegin(), axes.cend()))
-        {
-            throw std::runtime_error("Reducing axes should be sorted");
-        }
-        if (axes.size() != 0 && axes[axes.size() - 1] > e.dimension() - 1)
-        {
-            throw std::runtime_error("Axis " + std::to_string(axes[axes.size() - 1]) + " out of bounds for reduction.");
-        }
-
-        // Fast track for complete reduction
-        if (e.dimension() == axes.size())
-        {
-            auto begin = e.storage().begin();
-            result_type tmp = init_fct(*begin);
-            ++begin;
-            result.data()[0] = std::accumulate(begin, e.storage().end(), tmp, reduce_fct);
-            return result;
-        }
-
-        // axis wise reductions:
-        for (std::size_t i = 0, idx = 0; i < e.dimension(); ++i)
-        {
-            if (std::find(axes.begin(), axes.end(), i) == axes.end())
-            {
-                // i not in axes!
-                result_shape[idx] = e.shape()[i];
-                ++idx;
-            }
-        }
-
-        result.resize(result_shape, e.layout());
-
-        std::size_t leading_ax = axes[(e.layout() == layout_type::row_major) ? axes.size() - 1 : 0];
-        auto strides_finder = e.strides().begin() + static_cast<std::ptrdiff_t>(leading_ax);
-        // The computed strides contain "0" where the shape is 1 -- therefore find the next none-zero number
-        std::size_t inner_stride = static_cast<std::size_t>(*strides_finder);
-        while (inner_stride == 0)
-        {
-            (e.layout() == layout_type::row_major) ? --strides_finder : ++strides_finder;
-            inner_stride = static_cast<std::size_t>(*strides_finder);
-        }
-        std::size_t inner_loop_size = static_cast<std::size_t>(inner_stride);
-        std::size_t outer_loop_size = e.shape()[leading_ax];
-
-        // The following code merges reduction axes "at the end" (or the beginning for col_major)
-        // together by increasing the size of the outer loop where appropriate
-        auto merge_loops = [&outer_loop_size, &e](auto it, auto end) {
-            auto last_ax = *it;
-            ++it;
-            for (; it != end; ++it)
-            {
-                // note that we check is_sorted, so this condition is valid
-                if (std::abs(std::ptrdiff_t(*it) - std::ptrdiff_t(last_ax)) == 1)
-                {
-                    last_ax = *it;
-                    outer_loop_size *= e.shape()[last_ax];
-                }
-            }
-            return last_ax;
-        };
-
-        for (std::size_t i = 0, idx = 0; i < e.dimension(); ++i)
-        {
-            if (std::find(axes.begin(), axes.end(), i) == axes.end())
-            {
-                // i not in axes!
-                iter_strides[i] = static_cast<std::size_t>(result.strides()[idx]);
-                ++idx;
-            }
-        }
-
-        if (e.layout() == layout_type::row_major)
-        {
-            std::size_t last_ax = merge_loops(axes.rbegin(), axes.rend());
-
-            iter_shape.erase(iter_shape.begin() + std::ptrdiff_t(last_ax), iter_shape.end());
-            iter_strides.erase(iter_strides.begin() + std::ptrdiff_t(last_ax), iter_strides.end());
-        }
-        else if (e.layout() == layout_type::column_major)
-        {
-            // we got column_major here
-            std::size_t last_ax = merge_loops(axes.begin(), axes.end());
-
-            // erasing the front vs the back
-            iter_shape.erase(iter_shape.begin(), iter_shape.begin() + std::ptrdiff_t(last_ax + 1));
-            iter_strides.erase(iter_strides.begin(), iter_strides.begin() + std::ptrdiff_t(last_ax + 1));
-
-            // and reversing, to make it work with the same next_idx function
-            std::reverse(iter_shape.begin(), iter_shape.end());
-            std::reverse(iter_strides.begin(), iter_strides.end());
-        }
-        else
-        {
-            throw std::runtime_error("Layout not supported in immediate reduction.");
-        }
-
-        xindex temp_idx(iter_shape.size());
-        auto next_idx = [&iter_shape, &iter_strides, &temp_idx]() {
-            std::size_t i = iter_shape.size();
-            for (; i > 0; --i)
-            {
-                if (std::ptrdiff_t(temp_idx[i - 1]) >= std::ptrdiff_t(iter_shape[i - 1]) - 1)
-                {
-                    temp_idx[i - 1] = 0;
-                }
-                else
-                {
-                    temp_idx[i - 1]++;
-                    break;
-                }
-            }
-            return std::make_pair(i == 0,
-                                  std::inner_product(temp_idx.begin(), temp_idx.end(),
-                                                     iter_strides.begin(), std::ptrdiff_t(0)));
-        };
-
-        auto begin = e.data();
-        auto out = result.data();
-        auto out_begin = result.data();
-
-        std::ptrdiff_t next_stride = 0;
-
-        std::pair<bool, std::ptrdiff_t> idx_res(false, 0);
-
-        // Remark: eventually some modifications here to make conditions faster where merge + accumulate is the
-        // same function (e.g. check std::is_same<decltype(merge_fct), decltype(reduce_fct)>::value) ...
-
-        auto merge_border = out;
-        bool merge = false;
-
-        // TODO there could be some performance gain by removing merge checking
-        //      when axes.size() == 1 and even next_idx could be removed for something simpler (next_stride always the same)
-        //      best way to do this would be to create a function that takes (begin, out, outer_loop_size, inner_loop_size, next_idx_lambda)
-        // Decide if going about it row-wise or col-wise
-        if (inner_stride == 1)
-        {
-            while (idx_res.first != true)
-            {
-                // for unknown reasons it's much faster to use a temporary variable and
-                // std::accumulate here -- probably some cache behavior
-                result_type tmp;
-                tmp = init_fct(*begin);
-                tmp = std::accumulate(begin + 1, begin + outer_loop_size, tmp, reduce_fct);
-
-                // use merge function if necessary
-                *out = merge ? merge_fct(*out, tmp) : tmp;
-
-                begin += outer_loop_size;
-
-                idx_res = next_idx();
-                next_stride = idx_res.second;
-                out = out_begin + next_stride;
-
-                if (out > merge_border)
-                {
-                    // looped over once
-                    merge = false;
-                    merge_border = out;
-                }
-                else
-                {
-                    merge = true;
-                }
-            };
-        }
-        else
-        {
-            while (idx_res.first != true)
-            {
-                std::transform(out, out + inner_loop_size, begin, out,
-                               [merge, &init_fct, &reduce_fct](auto&& v1, auto&& v2) {
-                                    return merge ?
-                                        reduce_fct(v1, v2) :
-                                        // cast because return type of identity function is not upcasted
-                                        static_cast<result_type>(init_fct(v2));
-                               });
-
-                begin += inner_stride;
-                for (std::size_t i = 1; i < outer_loop_size; ++i)
-                {
-                    std::transform(out, out + inner_loop_size, begin, out, reduce_fct);
-                    begin += inner_stride;
-                }
-
-                idx_res = next_idx();
-                next_stride = idx_res.second;
-                out = out_begin + next_stride;
-
-                if (out > merge_border)
-                {
-                    // looped over once
-                    merge = false;
-                    merge_border = out;
-                }
-                else
-                {
-                    merge = true;
-                }
-            };
-        }
-        return result;
-    }
-
-    /*********************
-     * xreducer functors *
-     *********************/
-
-    template <class REDUCE_FUNC, class INIT_FUNC = xtl::identity, class MERGE_FUNC = REDUCE_FUNC>
-    struct xreducer_functors
-        : public std::tuple<REDUCE_FUNC, INIT_FUNC, MERGE_FUNC>
-    {
-        using self_type = xreducer_functors<REDUCE_FUNC, INIT_FUNC, MERGE_FUNC>;
-        using base_type = std::tuple<REDUCE_FUNC, INIT_FUNC, MERGE_FUNC>;
-        using reduce_functor_type = REDUCE_FUNC;
-        using init_functor_type = INIT_FUNC;
-        using merge_functor_type = MERGE_FUNC;
-
-        xreducer_functors()
-            : base_type()
-        {
-        }
-
-        template <class RF>
-        xreducer_functors(RF&& reduce_func)
-            : base_type(std::forward<RF>(reduce_func), INIT_FUNC(), reduce_func)
-        {
-        }
-
-        template <class RF, class IF>
-        xreducer_functors(RF&& reduce_func, IF&& init_func)
-            : base_type(std::forward<RF>(reduce_func), std::forward<IF>(init_func), reduce_func)
-        {
-        }
-
-        template <class RF, class IF, class MF>
-        xreducer_functors(RF&& reduce_func, IF&& init_func, MF&& merge_func)
-            : base_type(std::forward<RF>(reduce_func), std::forward<IF>(init_func), std::forward<MF>(merge_func))
-        {
-        }
-    };
-
-    template <class RF>
-    auto make_xreducer_functor(RF&& reduce_func)
-    {
-        using reducer_type = xreducer_functors<std::remove_reference_t<RF>>;
-        return reducer_type(std::forward<RF>(reduce_func));
-    }
-
-    template <class RF, class IF>
-    auto make_xreducer_functor(RF&& reduce_func, IF&& init_func)
-    {
-        using reducer_type = xreducer_functors<std::remove_reference_t<RF>, std::remove_reference_t<IF>>;
-        return reducer_type(std::forward<RF>(reduce_func), std::forward<IF>(init_func));
-    }
-
-    template <class RF, class IF, class MF>
-    auto make_xreducer_functor(RF&& reduce_func, IF&& init_func, MF&& merge_func)
-    {
-        using reducer_type = xreducer_functors<std::remove_reference_t<RF>,
-                                               std::remove_reference_t<IF>,
-                                               std::remove_reference_t<MF>>;
-        return reducer_type(std::forward<RF>(reduce_func), std::forward<IF>(init_func), std::forward<MF>(merge_func));
-    }
-
-    /**********************
-     * xreducer extension *
-     **********************/
-
-    namespace extension
-    {
-        template <class Tag, class F, class CT, class X>
-        struct xreducer_base_impl;
-
-        template <class F, class CT, class X>
-        struct xreducer_base_impl<xtensor_expression_tag, F, CT, X>
-        {
-            using type = xtensor_empty_base;
-        };
-
-        template <class F, class CT, class X>
-        struct xreducer_base
-            : xreducer_base_impl<xexpression_tag_t<CT>, F, CT, X>
-        {
-        };
-
-        template <class F, class CT, class X>
-        using xreducer_base_t = typename xreducer_base<F, CT, X>::type;
-    }
-
-    /************
-     * xreducer *
-     ************/
-
-    template <class F, class CT, class X>
-    class xreducer;
-
-    template <class F, class CT, class X>
-    class xreducer_stepper;
-
-    template <class F, class CT, class X>
-    struct xiterable_inner_types<xreducer<F, CT, X>>
-    {
-        using xexpression_type = std::decay_t<CT>;
-        using inner_shape_type = typename xreducer_shape_type<typename xexpression_type::shape_type, std::decay_t<X>>::type;
-        using const_stepper = xreducer_stepper<F, CT, X>;
-        using stepper = const_stepper;
-    };
-
-    /**
-     * @class xreducer
-     * @brief Reducing function operating over specified axes.
-     *
-     * The xreducer class implements an \ref xexpression applying
-     * a reducing function to an \ref xexpression over the specified
-     * axes.
-     *
-     * @tparam F a tuple of functors (class \ref xreducer_functors or compatible)
-     * @tparam CT the closure type of the \ref xexpression to reduce
-     * @tparam X the list of axes
-     *
-     * The reducer's result_type is deduced from the result type of function
-     * <tt>F::reduce_functor_type</tt> when called with elements of the expression @tparam CT.
-     *
-     * @sa reduce
-     */
-    template <class F, class CT, class X>
-    class xreducer : public xexpression<xreducer<F, CT, X>>,
-                     public xconst_iterable<xreducer<F, CT, X>>,
-                     public extension::xreducer_base_t<F, CT, X>
-    {
-    public:
-
-        using self_type = xreducer<F, CT, X>;
-        using reduce_functor_type = typename std::decay_t<F>::reduce_functor_type;
-        using init_functor_type = typename std::decay_t<F>::init_functor_type;
-        using merge_functor_type = typename std::decay_t<F>::merge_functor_type;
-        using xexpression_type = std::decay_t<CT>;
-        using axes_type = X;
-
-        using extension_base = extension::xreducer_base_t<F, CT, X>;
-        using expression_tag = typename extension_base::expression_tag;
-
-        using substepper_type = typename xexpression_type::const_stepper;
-        using value_type = std::decay_t<decltype(std::declval<reduce_functor_type>()(
-            std::declval<init_functor_type>()(*std::declval<substepper_type>()), *std::declval<substepper_type>()))>;
-        using reference = value_type;
-        using const_reference = value_type;
-        using pointer = value_type*;
-        using const_pointer = const value_type*;
-
-        using size_type = typename xexpression_type::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;
-
-        static constexpr layout_type static_layout = layout_type::dynamic;
-        static constexpr bool contiguous_layout = false;
-
-        template <class Func, class CTA, class AX>
-        xreducer(Func&& func, CTA&& e, AX&& axes);
-
-        size_type size() const noexcept;
-        size_type dimension() const noexcept;
-        const inner_shape_type& shape() const noexcept;
-        layout_type layout() const noexcept;
-
-        template <class... Args>
-        const_reference operator()(Args... args) const;
-        template <class... Args>
-        const_reference at(Args... args) const;
-        template <class... Args>
-        const_reference unchecked(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 It>
-        const_reference element(It first, It last) const;
-
-        const xexpression_type& expression() const noexcept;
-
-        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>
-        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, class Func = F>
-        using rebind_t = xreducer<Func, E, X>;
-
-        template <class E>
-        rebind_t<E> build_reducer(E&& e) const;
-
-        template <class E, class Func>
-        rebind_t<E, Func> build_reducer(E&& e, Func&& func) const;
-
-    private:
-
-        CT m_e;
-        reduce_functor_type m_reduce;
-        init_functor_type m_init;
-        merge_functor_type m_merge;
-        axes_type m_axes;
-        inner_shape_type m_shape;
-        shape_type m_dim_mapping;
-
-        friend class xreducer_stepper<F, CT, X>;
-    };
-
-    /*************************
-     * reduce implementation *
-     *************************/
-
-    namespace detail
-    {
-        template <class F, class E, class X>
-        inline auto reduce_impl(F&& f, E&& e, X&& axes, evaluation_strategy::lazy)
-        {
-            decltype(auto) normalized_axes = normalize_axis(e, std::forward<X>(axes));
-            using reducer_type = xreducer<F, const_xclosure_t<E>, xtl::const_closure_type_t<decltype(normalized_axes)>>;
-            return reducer_type(std::forward<F>(f), std::forward<E>(e), std::forward<decltype(normalized_axes)>(normalized_axes));
-        }
-
-
-        template <class F, class E, class X>
-        inline auto reduce_impl(F&& f, E&& e, X&& axes, evaluation_strategy::immediate)
-        {
-            decltype(auto) normalized_axes = normalize_axis(e, std::forward<X>(axes));
-            return reduce_immediate(std::forward<F>(f), eval(std::forward<E>(e)), std::forward<decltype(normalized_axes)>(normalized_axes));
-        }
-    }
-
-    /**
-     * @brief Returns an \ref xexpression applying the specified reducing
-     * function to an expression over the given axes.
-     *
-     * @param f the reducing function to apply.
-     * @param e the \ref xexpression to reduce.
-     * @param axes the list of axes.
-     * @param evaluation_strategy evaluation strategy to use (lazy (default), or immediate)
-     *
-     * The returned expression either hold a const reference to \p e or a copy
-     * depending on whether \p e is an lvalue or an rvalue.
-     */
-
-    template <class F, class E, class X, class EVS, class>
-    inline auto reduce(F&& f, E&& e, X&& axes, EVS evaluation_strategy)
-    {
-        return detail::reduce_impl(std::forward<F>(f), std::forward<E>(e), std::forward<X>(axes), evaluation_strategy);
-    }
-
-    template <class F, class E, class EVS, class>
-    inline auto reduce(F&& f, E&& e, EVS evaluation_strategy)
-    {
-        xindex_type_t<typename std::decay_t<E>::shape_type> ar;
-        resize_container(ar, e.dimension());
-        std::iota(ar.begin(), ar.end(), 0);
-        return detail::reduce_impl(std::forward<F>(f), std::forward<E>(e), std::move(ar), evaluation_strategy);
-    }
-
-#ifdef X_OLD_CLANG
-    template <class F, class E, class I, class EVS>
-    inline auto reduce(F&& f, E&& e, std::initializer_list<I> axes, EVS evaluation_strategy)
-    {
-        using axes_type = std::vector<std::size_t>;
-        auto ax = xt::forward_normalize<axes_type>(e, axes);
-        using reducer_type = xreducer<F, const_xclosure_t<E>, axes_type>;
-        return detail::reduce_impl(std::forward<F>(f), std::forward<E>(e), std::move(ax), evaluation_strategy);
-    }
-#else
-    template <class F, class E, class I, std::size_t N, class EVS>
-    inline auto reduce(F&& f, E&& e, const I (&axes)[N], EVS evaluation_strategy)
-    {
-        using axes_type = std::array<std::size_t, N>;
-        auto ax = xt::forward_normalize<axes_type>(e, axes);
-        return detail::reduce_impl(std::forward<F>(f), std::forward<E>(e), std::move(ax), evaluation_strategy);
-    }
-#endif
-
-    /********************
-     * xreducer_stepper *
-     ********************/
-
-    template <class F, class CT, class X>
-    class xreducer_stepper
-    {
-    public:
-
-        using self_type = xreducer_stepper<F, CT, X>;
-        using xreducer_type = xreducer<F, CT, X>;
-
-        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;
-
-        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);
-
-    private:
-
-        reference aggregate(size_type dim) const;
-
-        substepper_type get_substepper_begin() const;
-        size_type get_dim(size_type dim) const noexcept;
-        size_type shape(size_type i) const noexcept;
-        size_type axis(size_type i) const noexcept;
-
-        const xreducer_type* m_reducer;
-        size_type m_offset;
-        mutable substepper_type m_stepper;
-    };
-
-    /******************
-     * xreducer utils *
-     ******************/
-
-    namespace detail
-    {
-        template <std::size_t X, std::size_t... I>
-        struct in
-        {
-            constexpr static bool value = xtl::disjunction<std::integral_constant<bool, X == I>...>::value;
-        };
-
-        template <std::size_t Z, class S1, class S2, class R>
-        struct fixed_xreducer_shape_type_impl;
-
-        template <std::size_t Z, std::size_t... I, std::size_t... J, std::size_t... R>
-        struct fixed_xreducer_shape_type_impl<Z, fixed_shape<I...>, fixed_shape<J...>, fixed_shape<R...>>
-        {
-            using type = std::conditional_t<in<Z, J...>::value,
-                                            typename fixed_xreducer_shape_type_impl<Z - 1, fixed_shape<I...>, fixed_shape<J...>,
-                                                                                    fixed_shape<R...>>::type,
-                                            typename fixed_xreducer_shape_type_impl<Z - 1, fixed_shape<I...>, fixed_shape<J...>,
-                                                                                    fixed_shape<detail::at<Z, I...>::value, R...>>::type>;
-        };
-
-        template <std::size_t... I, std::size_t... J, std::size_t... R>
-        struct fixed_xreducer_shape_type_impl<0, fixed_shape<I...>, fixed_shape<J...>, fixed_shape<R...>>
-        {
-            using type = std::conditional_t<in<0, J...>::value,
-                                            fixed_shape<R...>,
-                                            fixed_shape<detail::at<0, I...>::value, R...>>;
-        };
-    }
-
-    template <class S1, class S2>
-    struct fixed_xreducer_shape_type;
-
-    template <std::size_t... I, std::size_t... J>
-    struct fixed_xreducer_shape_type<fixed_shape<I...>, fixed_shape<J...>>
-    {
-        using type = typename detail::fixed_xreducer_shape_type_impl<sizeof...(I) - 1, 
-                                                                    fixed_shape<I...>,
-                                                                    fixed_shape<J...>,
-                                                                    fixed_shape<>>::type;
-    };
-
-
-    // meta-function returning the shape type for an xreducer
-    template <class ST, class X>
-    struct xreducer_shape_type
-    {
-        using type = promote_shape_t<ST, std::decay_t<X>>;
-    };
-
-    template <class I1, std::size_t N1, class I2, std::size_t N2>
-    struct xreducer_shape_type<std::array<I1, N1>, std::array<I2, N2>>
-    {
-        using type = std::array<I2, N1 - N2>;
-    };
-
-    template <std::size_t... I, class I2, std::size_t N2>
-    struct xreducer_shape_type<fixed_shape<I...>, std::array<I2, N2>>
-    {
-        using type = std::array<I2, sizeof...(I) - N2>;
-    };
-
-    // Note adding "A" to prevent compilation in case nothing else matches 
-    template <std::size_t... I, std::size_t... J>
-    struct xreducer_shape_type<fixed_shape<I...>, fixed_shape<J...>>
-    {
-        using type = std::array<std::size_t, sizeof...(I) - sizeof...(J)>;
-    };
-
-    namespace detail
-    {
-        template <class InputIt, class ExcludeIt, class OutputIt>
-        inline void excluding_copy(InputIt first, InputIt last,
-                                   ExcludeIt e_first, ExcludeIt e_last,
-                                   OutputIt d_first, OutputIt map_first)
-        {
-            using difference_type = typename std::iterator_traits<InputIt>::difference_type;
-            using value_type = typename std::iterator_traits<OutputIt>::value_type;
-            InputIt iter = first;
-            while (iter != last && e_first != e_last)
-            {
-                auto diff = std::distance(first, iter);
-                if (diff != difference_type(*e_first))
-                {
-                    *d_first++ = *iter++;
-                    *map_first++ = value_type(diff);
-                }
-                else
-                {
-                    ++iter;
-                    ++e_first;
-                }
-            }
-            auto diff = std::distance(first, iter);
-            auto end = std::distance(iter, last);
-            std::iota(map_first, map_first + end, diff);
-            std::copy(iter, last, d_first);
-        }
-    }
-
-    /***************************
-     * xreducer implementation *
-     ***************************/
-
-    /**
-     * @name Constructor
-     */
-    //@{
-    /**
-     * Constructs an xreducer expression applying the specified
-     * function to the given expression over the given axes.
-     *
-     * @param func the function to apply
-     * @param e the expression to reduce
-     * @param axes the axes along which the reduction is performed
-     */
-    template <class F, class CT, class X>
-    template <class Func, class CTA, class AX>
-    inline xreducer<F, CT, X>::xreducer(Func&& func, CTA&& e, AX&& axes)
-        : m_e(std::forward<CTA>(e))
-        , m_reduce(std::get<0>(func))
-        , m_init(std::get<1>(func))
-        , m_merge(std::get<2>(func))
-        , m_axes(std::forward<AX>(axes))
-        , m_shape(xtl::make_sequence<inner_shape_type>(m_e.dimension() - m_axes.size(), 0))
-        , m_dim_mapping(xtl::make_sequence<shape_type>(m_e.dimension() - m_axes.size(), 0))
-    {
-        if (!std::is_sorted(m_axes.cbegin(), m_axes.cend()))
-        {
-            throw std::runtime_error("Reducing axes should be sorted");
-        }
-        if (m_axes.size() != 0 && m_axes[m_axes.size() - 1] > m_e.dimension() - 1)
-        {
-            throw std::runtime_error("Axis " + std::to_string(m_axes[m_axes.size() - 1]) + " out of bounds for reduction.");
-        }
-        detail::excluding_copy(m_e.shape().cbegin(), m_e.shape().cend(),
-                               m_axes.cbegin(), m_axes.cend(),
-                               m_shape.begin(), m_dim_mapping.begin());
-    }
-    //@}
-
-    /**
-     * @name Size and shape
-     */
-    /**
-     * Returns the size of the expression.
-     */
-    template <class F, class CT, class X>
-    inline auto xreducer<F, CT, X>::size() const noexcept -> size_type
-    {
-        return compute_size(shape());
-    }
-
-    /**
-     * Returns the number of dimensions of the expression.
-     */
-    template <class F, class CT, class X>
-    inline auto xreducer<F, CT, X>::dimension() const noexcept -> size_type
-    {
-        return m_shape.size();
-    }
-
-    /**
-     * Returns the shape of the expression.
-     */
-    template <class F, class CT, class X>
-    inline auto xreducer<F, CT, X>::shape() const noexcept -> const inner_shape_type&
-    {
-        return m_shape;
-    }
-
-    /**
-     * Returns the shape of the expression.
-     */
-    template <class F, class CT, class X>
-    inline layout_type xreducer<F, CT, X>::layout() const noexcept
-    {
-        return static_layout;
-    }
-    //@}
-
-    /**
-     * @name Data
-     */
-    /**
-     * Returns a constant reference to the element at the specified position in the reducer.
-     * @param args a 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.
-     */
-    template <class F, class CT, class X>
-    template <class... Args>
-    inline auto xreducer<F, CT, X>::operator()(Args... args) const -> const_reference
-    {
-        XTENSOR_TRY(check_index(shape(), args...));
-        XTENSOR_CHECK_DIMENSION(shape(), args...);
-        std::array<std::size_t, sizeof...(Args)> arg_array = {{static_cast<std::size_t>(args)...}};
-        return element(arg_array.cbegin(), arg_array.cend());
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the expression,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the function. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the expression.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class F, class CT, class X>
-    template <class... Args>
-    inline auto xreducer<F, CT, X>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the reducer.
-     * @param args a 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 prefered whenever
-     * it is possible.
-     * @warning This method is NOT compatible with broadcasting, meaning the following
-     * code has undefined behavior:
-     * \code{.cpp}
-     * xt::xarray<double> a = {{0, 1}, {2, 3}};
-     * xt::xarray<double> b = {0, 1};
-     * auto fd = a + b;
-     * double res = fd.uncheked(0, 1);
-     * \endcode
-     */
-    template <class F, class CT, class X>
-    template <class... Args>
-    inline auto xreducer<F, CT, X>::unchecked(Args... args) const -> const_reference
-    {
-        std::array<std::size_t, sizeof...(Args)> arg_array = { { static_cast<std::size_t>(args)... } };
-        return element(arg_array.cbegin(), arg_array.cend());
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the reducer.
-     * @param index a sequence of indices specifying the position in the reducer. Indices
-     * must be unsigned integers, the number of indices in the sequence should be equal or greater
-     * than the number of dimensions of the reducer.
-     */
-    template <class F, class CT, class X>
-    template <class S>
-    inline auto xreducer<F, CT, X>::operator[](const S& index) const
-        -> disable_integral_t<S, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class F, class CT, class X>
-    template <class I>
-    inline auto xreducer<F, CT, X>::operator[](std::initializer_list<I> index) const
-        -> const_reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class F, class CT, class X>
-    inline auto xreducer<F, CT, X>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the reducer.
-     * @param first iterator starting the sequence of indices
-     * @param last iterator 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.
-     */
-    template <class F, class CT, class X>
-    template <class It>
-    inline auto xreducer<F, CT, X>::element(It first, It last) const -> const_reference
-    {
-        XTENSOR_TRY(check_element_index(shape(), first, last));
-        auto stepper = const_stepper(*this, 0);
-        size_type dim = 0;
-        // drop left most elements
-        auto size = std::ptrdiff_t(dimension()) - std::distance(first, last);
-        auto begin = first - size;
-        while (begin != last)
-        {
-            if (begin < first)
-            {
-                stepper.step(dim++, std::size_t(0));
-                begin++;
-            }
-            else
-            {
-                stepper.step(dim++, std::size_t(*begin++));
-            }
-        }
-        return *stepper;
-    }
-
-    /**
-     * Returns a constant reference to the underlying expression of the reducer.
-     */
-    template <class F, class CT, class X>
-    inline auto xreducer<F, CT, X>::expression() const noexcept -> const xexpression_type&
-    {
-        return m_e;
-    }
-    //@}
-
-    /**
-     * @name Broadcasting
-     */
-    //@{
-    /**
-     * Broadcast the shape of the reducer to the specified parameter.
-     * @param shape the result shape
-     * @param reuse_cache parameter for internal optimization
-     * @return a boolean indicating whether the broadcasting is trivial
-     */
-    template <class F, class CT, class X>
-    template <class S>
-    inline bool xreducer<F, CT, X>::broadcast_shape(S& shape, bool) const
-    {
-        return xt::broadcast_shape(m_shape, shape);
-    }
-
-    /**
-    * Checks whether the xreducer can be linearly assigned to an expression
-    * with the specified strides.
-    * @return a boolean indicating whether a linear assign is possible
-    */
-    template <class F, class CT, class X>
-    template <class S>
-    inline bool xreducer<F, CT, X>::has_linear_assign(const S& /*strides*/) const noexcept
-    {
-        return false;
-    }
-    //@}
-
-    template <class F, class CT, class X>
-    template <class S>
-    inline auto xreducer<F, CT, X>::stepper_begin(const S& shape) const noexcept -> const_stepper
-    {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(*this, offset);
-    }
-
-    template <class F, class CT, class X>
-    template <class S>
-    inline auto xreducer<F, CT, X>::stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
-    {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(*this, offset, true, l);
-    }
-
-    template <class F, class CT, class X>
-    template <class E>
-    inline auto xreducer<F, CT, X>::build_reducer(E&& e) const -> rebind_t<E>
-    {
-        return rebind_t<E>(std::make_tuple(m_reduce, m_init, m_merge), std::forward<E>(e), axes_type(m_axes));
-    }
-
-    template <class F, class CT, class X>
-    template <class E, class Func>
-    inline auto xreducer<F, CT, X>::build_reducer(E&& e, Func&& func) const -> rebind_t<E, Func>
-    {
-        return rebind_t<E, Func>(std::forward<Func>(func), std::forward<E>(e), axes_type(m_axes));
-    }
-
-    /***********************************
-     * xreducer_stepper implementation *
-     ***********************************/
-
-    template <class F, class CT, class X>
-    inline xreducer_stepper<F, CT, X>::xreducer_stepper(const xreducer_type& red, size_type offset, bool end, layout_type l)
-        : m_reducer(&red), m_offset(offset),
-          m_stepper(get_substepper_begin())
-    {
-        if (end)
-        {
-            to_end(l);
-        }
-    }
-
-    template <class F, class CT, class X>
-    inline auto xreducer_stepper<F, CT, X>::operator*() const -> reference
-    {
-        reference r = aggregate(0);
-        return r;
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::step(size_type dim)
-    {
-        if (dim >= m_offset)
-        {
-            m_stepper.step(get_dim(dim - m_offset));
-        }
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::step_back(size_type dim)
-    {
-        if (dim >= m_offset)
-        {
-            m_stepper.step_back(get_dim(dim - m_offset));
-        }
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::step(size_type dim, size_type n)
-    {
-        if (dim >= m_offset)
-        {
-            m_stepper.step(get_dim(dim - m_offset), n);
-        }
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::step_back(size_type dim, size_type n)
-    {
-        if (dim >= m_offset)
-        {
-            m_stepper.step_back(get_dim(dim - m_offset), n);
-        }
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::reset(size_type dim)
-    {
-        if (dim >= m_offset)
-        {
-            m_stepper.reset(get_dim(dim - m_offset));
-        }
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::reset_back(size_type dim)
-    {
-        if (dim >= m_offset)
-        {
-            m_stepper.reset_back(get_dim(dim - m_offset));
-        }
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::to_begin()
-    {
-        m_stepper.to_begin();
-    }
-
-    template <class F, class CT, class X>
-    inline void xreducer_stepper<F, CT, X>::to_end(layout_type l)
-    {
-        m_stepper.to_end(l);
-    }
-
-    template <class F, class CT, class X>
-    inline auto xreducer_stepper<F, CT, X>::aggregate(size_type dim) const -> reference
-    {
-        size_type index = axis(dim);
-        size_type size = shape(index);
-        reference res;
-        if (dim != m_reducer->m_axes.size() - 1)
-        {
-            res = aggregate(dim + 1);
-            for (size_type i = 1; i != size; ++i)
-            {
-                m_stepper.step(index);
-                res = m_reducer->m_merge(res, aggregate(dim + 1));
-            }
-        }
-        else
-        {
-            res = m_reducer->m_init(*m_stepper);
-            for (size_type i = 1; i != size; ++i)
-            {
-                m_stepper.step(index);
-                res = m_reducer->m_reduce(res, *m_stepper);
-            }
-        }
-        m_stepper.reset(index);
-        return res;
-    }
-
-    template <class F, class CT, class X>
-    inline auto xreducer_stepper<F, CT, X>::get_substepper_begin() const -> substepper_type
-    {
-        return m_reducer->m_e.stepper_begin(m_reducer->m_e.shape());
-    }
-
-    template <class F, class CT, class X>
-    inline auto xreducer_stepper<F, CT, X>::get_dim(size_type dim) const noexcept -> size_type
-    {
-        return m_reducer->m_dim_mapping[dim];
-    }
-
-    template <class F, class CT, class X>
-    inline auto xreducer_stepper<F, CT, X>::shape(size_type i) const noexcept -> size_type
-    {
-        return m_reducer->m_e.shape()[i];
-    }
-
-    template <class F, class CT, class X>
-    inline auto xreducer_stepper<F, CT, X>::axis(size_type i) const noexcept -> size_type
-    {
-        return m_reducer->m_axes[i];
-    }
-}
-
-#endif
diff --git a/include/xtensor/xshape.hpp b/include/xtensor/xshape.hpp
deleted file mode 100644
index f7acab5de..000000000
--- a/include/xtensor/xshape.hpp
+++ /dev/null
@@ -1,323 +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 XTENSOR_XSHAPE_HPP
-#define XTENSOR_XSHAPE_HPP
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <initializer_list>
-#include <iterator>
-#include <memory>
-
-#include "xexception.hpp"
-#include "xstorage.hpp"
-
-namespace xt
-{
-    template <class T>
-    using dynamic_shape = svector<T, 4>;
-
-    template <class T, std::size_t N>
-    using static_shape = std::array<T, N>;
-
-    template <std::size_t... X>
-    class fixed_shape;
-
-    using xindex = dynamic_shape<std::size_t>;
-}
-
-namespace xtl
-{
-    namespace detail
-    {
-        template <class S>
-        struct sequence_builder;
-
-        template <std::size_t... I>
-        struct sequence_builder<xt::fixed_shape<I...>>
-        {
-            using sequence_type = xt::fixed_shape<I...>;
-            using value_type = typename sequence_type::value_type;
-
-            inline static sequence_type make(std::size_t /*size*/)
-            {
-                return sequence_type{};
-            }
-
-            inline static sequence_type make(std::size_t /*size*/, value_type /*v*/)
-            {
-                return sequence_type{};
-            }
-        };
-    }
-}
-
-namespace xt
-{
-
-    /***********************************
-     * static_dimension implementation *
-     ***********************************/
-
-    namespace detail
-    {
-        template <class T, class E = void>
-        struct static_dimension_impl
-        {
-            static constexpr std::ptrdiff_t value = -1;
-        };
-
-        template <class T>
-        struct static_dimension_impl<T, void_t<decltype(std::tuple_size<T>::value)>>
-        {
-            static constexpr std::ptrdiff_t value = static_cast<std::ptrdiff_t>(std::tuple_size<T>::value);
-        };
-    }
-
-    template <class S>
-    struct static_dimension
-    {
-        static constexpr std::ptrdiff_t value = detail::static_dimension_impl<S>::value;
-    };
-
-    /*************************************
-     * promote_shape and promote_strides *
-     *************************************/
-
-    namespace detail
-    {
-        template <class T1, class T2>
-        constexpr std::common_type_t<T1, T2> imax(const T1& a, const T2& b)
-        {
-            return a > b ? a : b;
-        }
-
-        // Variadic meta-function returning the maximal size of std::arrays.
-        template <class... T>
-        struct max_array_size;
-
-        template <>
-        struct max_array_size<>
-        {
-            static constexpr std::size_t value = 0;
-        };
-
-        template <class T, class... Ts>
-        struct max_array_size<T, Ts...> : std::integral_constant<std::size_t, imax(std::tuple_size<T>::value, max_array_size<Ts...>::value)>
-        {
-        };
-
-        // Broadcasting for fixed shapes
-        template <std::size_t IDX, std::size_t... X>
-        struct at
-        {
-            constexpr static std::size_t arr[sizeof...(X)] = {X...};
-            constexpr static std::size_t value = (IDX < sizeof...(X)) ? arr[IDX] : 0;
-        };
-
-        template <class S1, class S2>
-        struct broadcast_fixed_shape;
-
-        template <class IX, class A, class B>
-        struct broadcast_fixed_shape_impl;
-
-        template <std::size_t IX, class A, class B>
-        struct broadcast_fixed_shape_cmp_impl;
-
-        template <std::size_t JX, std::size_t... I, std::size_t... J>
-        struct broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>
-        {
-            //We line the shapes up from the last index
-            //IX may underflow, thus being a very large number
-            static constexpr std::size_t IX = JX - (sizeof...(J) - sizeof...(I));
-
-            //Out of bounds access gives value 0
-            static constexpr std::size_t I_v = at<IX, I...>::value;
-            static constexpr std::size_t J_v = at<JX, J...>::value;
-
-            // we're statically checking if the broadcast shapes are either one on either of them or equal
-            static_assert(!I_v ||  I_v == 1 || J_v == 1 || J_v == I_v, "broadcast shapes do not match.");
-
-            static constexpr std::size_t ordinate = (I_v > J_v) ? I_v : J_v;
-            static constexpr bool value = (I_v == J_v);
-        };
-
-        template <std::size_t... JX, std::size_t... I, std::size_t... J>
-        struct broadcast_fixed_shape_impl<std::index_sequence<JX...>, fixed_shape<I...>, fixed_shape<J...>>
-        {
-            static_assert(sizeof... (J) >= sizeof... (I), "broadcast shapes do not match.");
-
-            using type = xt::fixed_shape<broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>::ordinate...>;
-            static constexpr bool value = xtl::conjunction<broadcast_fixed_shape_cmp_impl<JX, fixed_shape<I...>, fixed_shape<J...>>...>::value;
-        };
-
-        /* broadcast_fixed_shape<fixed_shape<I...>, fixed_shape<J...>>
-         * Just like a call to broadcast_shape(cont S1& input, S2& output),
-         * except that the result shape is alised as type, and the returned
-         * bool is the member value. Asserts on an illegal broadcast, including
-         * the case where pack I is strictly longer than pack J. */
-
-        template <std::size_t... I, std::size_t... J>
-        struct broadcast_fixed_shape<fixed_shape<I...>, fixed_shape<J...>>
-            : broadcast_fixed_shape_impl<std::make_index_sequence<sizeof...(J)>, fixed_shape<I...>, fixed_shape<J...>> {};
-
-        // Simple is_array and only_array meta-functions
-        template <class S>
-        struct is_array
-        {
-            static constexpr bool value = false;
-        };
-
-        template <class T, std::size_t N>
-        struct is_array<std::array<T, N>>
-        {
-            static constexpr bool value = true;
-        };
-
-        template <class S>
-        struct is_fixed
-        {
-            static constexpr bool value = false;
-        };
-
-        template <std::size_t... N>
-        struct is_fixed<fixed_shape<N...>>
-        {
-            static constexpr bool value = true;
-        };
-
-        template <class S>
-        struct is_scalar_shape
-        {
-            static constexpr bool value = false;
-        };
-
-        template <class T>
-        struct is_scalar_shape<std::array<T, 0>>
-        {
-            static constexpr bool value = true;
-        };
-
-        template <class... S>
-        using only_array = xtl::conjunction<xtl::disjunction<is_array<S>, is_fixed<S>>...>;
-
-        // test that at least one argument is a fixed shape. If yes, then either argument has to be fixed or scalar
-        template <class... S>
-        using only_fixed = std::integral_constant<bool, xtl::disjunction<is_fixed<S>...>::value &&
-                                                        xtl::conjunction<xtl::disjunction<is_fixed<S>, is_scalar_shape<S>>...>::value>;
-
-        // The promote_index meta-function returns std::vector<promoted_value_type> in the
-        // general case and an array of the promoted value type and maximal size if all
-        // arguments are of type std::array
-
-        template <class... S>
-        struct promote_array
-        {
-            using type = std::array<typename std::common_type<typename S::value_type...>::type, max_array_size<S...>::value>;
-        };
-
-        template <>
-        struct promote_array<>
-        {
-            using type = std::array<std::size_t, 0>;
-        };
-
-        template <class S>
-        struct filter_scalar
-        {
-            using type = S;
-        };
-
-        template <class T>
-        struct filter_scalar<std::array<T, 0>>
-        {
-            using type = fixed_shape<1>;
-        };
-
-        template <class S>
-        using filter_scalar_t = typename filter_scalar<S>::type;
-
-        template <class... S>
-        struct promote_fixed : promote_fixed<filter_scalar_t<S>...> {};
-
-        template <std::size_t... I>
-        struct promote_fixed<fixed_shape<I...>>
-        {
-            using type = fixed_shape<I...>;
-            static constexpr bool value = true;
-        };
-
-        template <std::size_t... I, std::size_t... J, class... S>
-        struct promote_fixed<fixed_shape<I...>, fixed_shape<J...>, S...>
-        {
-        private:
-
-            using intermediate = std::conditional_t< (sizeof... (I) > sizeof... (J)),
-                broadcast_fixed_shape<fixed_shape<J...>, fixed_shape<I...>>,
-                broadcast_fixed_shape<fixed_shape<I...>, fixed_shape<J...>>>;
-            using result = promote_fixed<typename intermediate::type, S...>;
-
-        public:
-
-            using type = typename result::type;
-            static constexpr bool value = xtl::conjunction<intermediate, result>::value;
-        };
-
-        template <bool all_index, bool all_array, class... S>
-        struct select_promote_index;
-
-        template <class... S>
-        struct select_promote_index<true, true, S...> : promote_fixed<S...> {};
-
-        template <>
-        struct select_promote_index<true, true>
-        {
-            // todo correct? used in xvectorize
-            using type = dynamic_shape<std::size_t>;
-        };
-
-        template <class... S>
-        struct select_promote_index<false, true, S...> : promote_array<S...> {};
-
-        template <class... S>
-        struct select_promote_index<false, false, S...>
-        {
-            using type = dynamic_shape<typename std::common_type<typename S::value_type...>::type>;
-        };
-
-        template <class... S>
-        struct promote_index : select_promote_index<only_fixed<S...>::value, only_array<S...>::value, S...> {};
-
-        template <class T>
-        struct index_from_shape_impl
-        {
-            using type = T;
-        };
-
-        template <std::size_t... N>
-        struct index_from_shape_impl<fixed_shape<N...>>
-        {
-            using type = std::array<std::size_t, sizeof...(N)>;
-        };
-    }
-
-    template <class... S>
-    using promote_shape_t = typename detail::promote_index<S...>::type;
-
-    template <class... S>
-    using promote_strides_t = typename detail::promote_index<S...>::type;
-
-    template <class S>
-    using index_from_shape_t = typename detail::index_from_shape_impl<S>::type;
-}
-
-#endif
diff --git a/include/xtensor/xsort.hpp b/include/xtensor/xsort.hpp
deleted file mode 100644
index 59d725878..000000000
--- a/include/xtensor/xsort.hpp
+++ /dev/null
@@ -1,563 +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 XTENSOR_SORT_HPP
-#define XTENSOR_SORT_HPP
-
-#include <algorithm>
-#include <utility>
-
-#include "xarray.hpp"
-#include "xeval.hpp"
-#include "xslice.hpp"  // for xnone
-#include "xmanipulation.hpp"
-#include "xtensor.hpp"
-
-namespace xt
-{
-    namespace detail
-    {
-        constexpr std::size_t normalize_axis(std::ptrdiff_t axis, std::size_t dim)
-        {
-            return axis >= 0 ? static_cast<std::size_t>(axis) : static_cast<std::size_t>(static_cast<std::ptrdiff_t>(dim) + axis);
-        }
-
-        template <class E, class F>
-        inline void call_over_leading_axis(E& ev, F&& fct)
-        {
-            std::size_t n_iters = 1;
-            std::ptrdiff_t secondary_stride;
-            if (ev.layout() == layout_type::row_major)
-            {
-                n_iters = std::accumulate(ev.shape().begin(), ev.shape().end() - 1,
-                                          std::size_t(1), std::multiplies<>());
-                secondary_stride = static_cast<std::ptrdiff_t>(ev.strides()[ev.dimension() - 2]);
-            }
-            else
-            {
-                n_iters = std::accumulate(ev.shape().begin() + 1, ev.shape().end(),
-                                          std::size_t(1), std::multiplies<>());
-                secondary_stride = static_cast<std::ptrdiff_t>(ev.strides()[1]);
-            }
-
-            std::ptrdiff_t offset = 0;
-
-            for (std::size_t i = 0; i < n_iters; ++i, offset += secondary_stride)
-            {
-                size_t adj_secondary_stride = (std::max)(secondary_stride, std::ptrdiff_t(1));
-                fct(ev.data() + offset, ev.data() + offset + adj_secondary_stride);
-            }
-        }
-
-        template <class E>
-        inline std::size_t leading_axis(const E& e)
-        {
-            if (e.layout() == layout_type::row_major)
-            {
-                return e.dimension() - 1;
-            }
-            else if (e.layout() == layout_type::column_major)
-            {
-                return 0;
-            }
-            throw std::runtime_error("Layout not supported.");
-        }
-
-        // get permutations to transpose and reverse-transpose array
-        inline std::pair<dynamic_shape<std::size_t>, dynamic_shape<std::size_t>>
-        get_permutations(std::size_t dim, std::size_t ax, layout_type layout)
-        {
-            dynamic_shape<std::size_t> permutation(dim);
-            std::iota(permutation.begin(), permutation.end(), std::size_t(0));
-            permutation.erase(permutation.begin() + std::ptrdiff_t(ax));
-
-            if (layout == layout_type::row_major)
-            {
-                permutation.push_back(ax);
-            }
-            else
-            {
-                permutation.insert(permutation.begin(), ax);
-            }
-
-            // TODO find a more clever way to get reverse permutation?
-            dynamic_shape<std::size_t> reverse_permutation;
-            for (std::size_t i = 0; i < dim; ++i)
-            {
-                auto it = std::find(permutation.begin(), permutation.end(), i);
-                reverse_permutation.push_back(std::size_t(std::distance(permutation.begin(), it)));
-            }
-
-            return std::make_pair(std::move(permutation), std::move(reverse_permutation));
-        }
-
-        template <class E, class R, class F>
-        inline auto run_lambda_over_axis(const E& e, R& res, std::size_t axis, F&& lambda)
-        {
-            if (axis != detail::leading_axis(res))
-            {
-                dynamic_shape<std::size_t> permutation, reverse_permutation;
-                std::tie(permutation, reverse_permutation) = get_permutations(e.dimension(), axis, e.layout());
-
-                res = transpose(e, permutation);
-                detail::call_over_leading_axis(res, std::forward<F>(lambda));
-                res = transpose(res, reverse_permutation);
-            }
-            else
-            {
-                res = e;
-                detail::call_over_leading_axis(res, std::forward<F>(lambda));
-            }
-        }
-
-        template <class VT>
-        struct flatten_sort_result_type
-        {
-            using type = VT;
-        };
-
-        template <class VT, std::size_t N, layout_type L>
-        struct flatten_sort_result_type<xtensor<VT, N, L>>
-        {
-            using type = xtensor<VT, 1, L>;
-        };
-
-        template <class VT, class S, layout_type L>
-        struct flatten_sort_result_type<xtensor_fixed<VT, S, L>>
-        {
-            using type = xtensor_fixed<VT, xshape<fixed_compute_size<S>::value>, L>;
-        };
-
-
-        template <class E, class R = typename flatten_sort_result_type<E>::type>
-        inline auto flat_sort_impl(const xexpression<E>& e)
-        {
-            const auto& de = e.derived_cast();
-            R ev;
-            ev.resize({de.size()});
-
-            std::copy(de.cbegin(), de.cend(), ev.begin());
-            std::sort(ev.begin(), ev.end());
-
-            return ev;
-        }
-    }
-
-    template <class E>
-    inline auto sort(const xexpression<E>& e, placeholders::xtuph /*t*/)
-    {
-        return detail::flat_sort_impl(e);
-    }
-
-    namespace detail
-    {
-        template <class T>
-        struct sort_eval_type
-        {
-            using type = typename T::temporary_type;
-        };
-
-        template <class T, std::size_t... I, layout_type L>
-        struct sort_eval_type<xtensor_fixed<T, fixed_shape<I...>, L>>
-        {
-            using type = xtensor<T, sizeof...(I), L>;
-        };
-    }
-
-    /**
-     * Sort xexpression (optionally along axis)
-     * The sort is performed using the ``std::sort`` functions.
-     * A copy of the xexpression is created and returned.
-     *
-     * @param e xexpression to sort
-     * @param axis axis along which sort is performed
-     *
-     * @return sorted array (copy)
-     */
-    template <class E>
-    inline auto sort(const xexpression<E>& e, std::ptrdiff_t axis = -1)
-    {
-        using eval_type = typename detail::sort_eval_type<E>::type;
-
-        const auto& de = e.derived_cast();
-
-        if (de.dimension() == 1)
-        {
-            return detail::flat_sort_impl<std::decay_t<decltype(de)>, eval_type>(de);
-        }
-
-        std::size_t ax = detail::normalize_axis(axis, de.dimension());
-
-        eval_type res;
-        detail::run_lambda_over_axis(de, res, ax, [](auto begin, auto end) { std::sort(begin, end); });
-        return res;
-    }
-
-    namespace detail
-    {
-        template <class VT, class T>
-        struct rebind_value_type
-        {
-            using type = xarray<VT, xt::layout_type::dynamic>;
-        };
-
-        template <class VT, class EC, layout_type L>
-        struct rebind_value_type<VT, xarray<EC, L>>
-        {
-            using type = xarray<VT, L>;
-        };
-
-        template <class VT, class EC, std::size_t N, layout_type L>
-        struct rebind_value_type<VT, xtensor<EC, N, L>>
-        {
-            using type = xtensor<VT, N, L>;
-        };
-
-        template <class VT, class ET, class S, layout_type L>
-        struct rebind_value_type<VT, xtensor_fixed<ET, S, L>>
-        {
-            using type = xtensor_fixed<VT, S, L>;
-        };
-
-        template <class VT, class T>
-        struct flatten_rebind_value_type
-        {
-            using type = typename rebind_value_type<VT, T>::type;
-        };
-
-        template <class VT, class EC, std::size_t N, layout_type L>
-        struct flatten_rebind_value_type<VT, xtensor<EC, N, L>>
-        {
-            using type = xtensor<VT, 1, L>;
-        };
-
-        template <class VT, class ET, class S, layout_type L>
-        struct flatten_rebind_value_type<VT, xtensor_fixed<ET, S, L>>
-        {
-            using type = xtensor_fixed<VT, xshape<fixed_compute_size<S>::value>, L>;
-        };
-
-        template <class T>
-        struct argsort_result_type
-        {
-            using type = typename rebind_value_type<typename T::temporary_type::size_type,
-                                                    typename T::temporary_type>::type;
-        };
-
-        template <class T>
-        struct linear_argsort_result_type
-        {
-            using type = typename flatten_rebind_value_type<typename T::temporary_type::size_type,
-                                                            typename T::temporary_type>::type;
-        };
-
-        template <class Ed, class Ei>
-        inline void argsort_over_leading_axis(const Ed& data, Ei& inds)
-        {
-            std::size_t n_iters = 1;
-            std::ptrdiff_t data_secondary_stride;
-            std::ptrdiff_t inds_secondary_stride;
-            if (data.layout() == layout_type::row_major)
-            {
-                n_iters = std::accumulate(data.shape().begin(), data.shape().end() - 1,
-                                          std::size_t(1), std::multiplies<>());
-                data_secondary_stride = static_cast<std::ptrdiff_t>(data.strides()[data.dimension() - 2]);
-                inds_secondary_stride = static_cast<std::ptrdiff_t>(inds.strides()[inds.dimension() - 2]);
-            }
-            else
-            {
-                n_iters = std::accumulate(data.shape().begin() + 1, data.shape().end(),
-                                          std::size_t(1), std::multiplies<>());
-                data_secondary_stride = static_cast<std::ptrdiff_t>(data.strides()[1]);
-                inds_secondary_stride = static_cast<std::ptrdiff_t>(inds.strides()[1]);
-            }
-
-            std::ptrdiff_t data_offset = 0;
-            std::ptrdiff_t inds_offset = 0;
-
-            for (std::size_t i = 0; i < n_iters; ++i, data_offset += data_secondary_stride,
-                    inds_offset += inds_secondary_stride)
-            {
-                auto comp = [&data, &data_offset](std::size_t x, std::size_t y) {
-                    return (*(data.data() + data_offset + x) <
-                            *(data.data() + data_offset + y));
-                };
-                std::iota(inds.data() + inds_offset, inds.data() + inds_offset + inds_secondary_stride, 0);
-                std::sort(inds.data() + inds_offset, inds.data() + inds_offset + inds_secondary_stride, comp);
-            }
-        }
-
-        template <class E, class R = typename detail::linear_argsort_result_type<E>::type>
-        inline auto flatten_argsort_impl(const xexpression<E>& e)
-        {
-            using result_type = R;
-
-            const auto& de = e.derived_cast();
-
-            result_type result;
-            result.resize({de.size()});
-            auto comp = [&de](std::size_t x, std::size_t y) {
-                return de[x] < de[y];
-            };
-            std::iota(result.begin(), result.end(), 0);
-            std::sort(result.begin(), result.end(), comp);
-
-            return result;
-        }
-    }
-
-    template <class E>
-    inline auto argsort(const xexpression<E>& e, placeholders::xtuph /*t*/)
-    {
-        return detail::flatten_argsort_impl(e);
-    }
-
-    /**
-     * Argsort xexpression (optionally along axis)
-     * Performs an indirect sort along the given axis. Returns an xarray
-     * of indices of the same shape as e that index data along the given axis in
-     * sorted order.
-     *
-     * @param e xexpression to argsort
-     * @param axis axis along which argsort is performed
-     *
-     * @return argsorted index array
-     */
-    template <class E>
-    inline auto argsort(const xexpression<E>& e, std::ptrdiff_t axis = -1)
-    {
-        using eval_type = typename detail::sort_eval_type<E>::type;
-        using result_type = typename detail::argsort_result_type<eval_type>::type;
-
-        const auto& de = e.derived_cast();
-
-        std::size_t ax = detail::normalize_axis(axis, de.dimension());
-
-        if (de.dimension() == 1)
-        {
-            return detail::flatten_argsort_impl<E, result_type>(e);
-        }
-
-        if (ax != detail::leading_axis(de))
-        {
-            dynamic_shape<std::size_t> permutation, reverse_permutation;
-            std::tie(permutation, reverse_permutation) = detail::get_permutations(de.dimension(), ax, de.layout());
-
-            eval_type ev = transpose(de, permutation);
-            result_type res = result_type::from_shape(ev.shape());
-            detail::argsort_over_leading_axis(ev, res);
-            res = transpose(res, reverse_permutation);
-            return res;
-        }
-        else
-        {
-            result_type res = result_type::from_shape(de.shape());
-            detail::argsort_over_leading_axis(de, res);
-            return res;
-        }
-    }
-
-    namespace detail
-    {
-        template <class T>
-        struct argfunc_result_type
-        {
-            using type = xarray<std::size_t>;
-        };
-
-        template <class T, std::size_t N>
-        struct argfunc_result_type<xtensor<T, N>>
-        {
-            using type = xtensor<std::size_t, N - 1>;
-        };
-
-        template <class IT, class F>
-        inline std::size_t cmp_idx(IT iter, IT end, std::ptrdiff_t inc, F&& cmp)
-        {
-            std::size_t idx = 0;
-            auto min = *iter;
-            iter += inc;
-            for (std::size_t i = 1; iter < end; iter += inc, ++i)
-            {
-                if (cmp(*iter, min))
-                {
-                    min = *iter;
-                    idx = i;
-                }
-            }
-            return idx;
-        }
-
-        template <class E, class F>
-        inline xtensor<std::size_t, 0> arg_func_impl(const E& e, F&& f)
-        {
-            return cmp_idx(e.template begin<XTENSOR_DEFAULT_LAYOUT>(),
-                           e.template end<XTENSOR_DEFAULT_LAYOUT>(), 1,
-                           std::forward<F>(f));
-        }
-
-        template <class E, class F>
-        inline typename argfunc_result_type<E>::type
-        arg_func_impl(const E& e, std::size_t axis, F&& cmp)
-        {
-            using eval_type = typename detail::sort_eval_type<E>::type;
-            using value_type = typename E::value_type;
-            using result_type = typename argfunc_result_type<E>::type;
-            using result_shape_type = typename result_type::shape_type;
-
-            if (e.dimension() == 1)
-            {
-                return arg_func_impl(e, std::forward<F>(cmp));
-            }
-
-            result_shape_type alt_shape;
-            xt::resize_container(alt_shape, e.dimension() - 1);
-
-            // Excluding copy, copy all of shape except for axis
-            std::copy(e.shape().cbegin(), e.shape().cbegin() + std::ptrdiff_t(axis), alt_shape.begin());
-            std::copy(e.shape().cbegin() + std::ptrdiff_t(axis) + 1, e.shape().cend(), alt_shape.begin() + std::ptrdiff_t(axis));
-
-            result_type result = result_type::from_shape(std::move(alt_shape));
-            auto result_iter = result.begin();
-
-            auto arg_func_lambda = [&result_iter, &cmp](auto begin, auto end) {
-                std::size_t idx = 0;
-                value_type val = *begin;
-                ++begin;
-                for (std::size_t i = 1; begin != end; ++begin, ++i)
-                {
-                    if (cmp(*begin, val))
-                    {
-                        val = *begin;
-                        idx = i;
-                    }
-                }
-                *result_iter = idx;
-                ++result_iter;
-            };
-
-            if (axis != detail::leading_axis(e))
-            {
-                dynamic_shape<std::size_t> permutation, reverse_permutation;
-                std::tie(permutation, reverse_permutation) = detail::get_permutations(e.dimension(), axis, e.layout());
-
-                // note: creating copy
-                eval_type input = transpose(e, permutation);
-                detail::call_over_leading_axis(input, arg_func_lambda);
-                return result;
-            }
-            else
-            {
-                auto&& input = eval(e);
-                detail::call_over_leading_axis(input, arg_func_lambda);
-                return result;
-            }
-        }
-    }
-
-    template <class E>
-    inline auto argmin(const xexpression<E>& e)
-    {
-        using value_type = typename E::value_type;
-        auto&& ed = eval(e.derived_cast());
-        return detail::arg_func_impl(ed, std::less<value_type>());
-    }
-
-    /**
-     * Find position of minimal value in xexpression
-     *
-     * @param e input xexpression
-     * @param axis select axis (or none)
-     *
-     * @return returns xarray with positions of minimal value
-     */
-    template <class E>
-    inline auto argmin(const xexpression<E>& e, std::size_t axis)
-    {
-        using value_type = typename E::value_type;
-        auto&& ed = eval(e.derived_cast());
-        return detail::arg_func_impl(ed, axis, std::less<value_type>());
-    }
-
-    template <class E>
-    inline auto argmax(const xexpression<E>& e)
-    {
-        using value_type = typename E::value_type;
-        auto&& ed = eval(e.derived_cast());
-        return detail::arg_func_impl(ed, std::greater<value_type>());
-    }
-
-    /**
-     * Find position of maximal value in xexpression
-     *
-     * @param e input xexpression
-     * @param axis select axis (or none)
-     *
-     * @return returns xarray with positions of maximal value
-     */
-    template <class E>
-    inline auto argmax(const xexpression<E>& e, std::size_t axis)
-    {
-        using value_type = typename E::value_type;
-        auto&& ed = eval(e.derived_cast());
-        return detail::arg_func_impl(ed, axis, std::greater<value_type>());
-    }
-
-    /**
-     * Find unique elements of a xexpression. This returns a flattened xtensor with
-     * sorted, unique elements from the original expression.
-     *
-     * @param e input xexpression (will be flattened)
-     */
-    template <class E>
-    inline auto unique(const xexpression<E>& e)
-    {
-        auto sorted = sort(e, xnone());
-        auto end = std::unique(sorted.begin(), sorted.end());
-        std::size_t sz = static_cast<std::size_t>(std::distance(sorted.begin(), end));
-        // TODO check if we can shrink the vector without reallocation
-        using value_type = typename E::value_type;
-        auto result = xtensor<value_type, 1>::from_shape({sz});
-        std::copy(sorted.begin(), end, result.begin());
-        return result;
-    }
-
-    /**
-     * Find the set difference of two xexpressions. This returns a flattened xtensor with
-     * the sorted, unique values in ar1 that are not in ar2.
-     *
-     * @param ar1 input xexpression (will be flattened)
-     * @param ar2 input xexpression
-     */
-    template <class E1, class E2>
-    inline auto setdiff1d(const xexpression<E1>& ar1, const xexpression<E2>& ar2)
-    {
-        using value_type = typename E1::value_type;
-
-        auto unique1 = unique(ar1);
-        auto unique2 = unique(ar2);
-
-        auto tmp = xtensor<value_type, 1>::from_shape({unique1.size()});
-
-        auto end = std::set_difference(
-            unique1.begin(), unique1.end(),
-            unique2.begin(), unique2.end(),
-            tmp.begin()
-        );
-
-        std::size_t sz = static_cast<std::size_t>(std::distance(tmp.begin(), end));
-
-        auto result = xtensor<value_type, 1>::from_shape({sz});
-
-        std::copy(tmp.begin(), end, result.begin());
-
-        return result;
-    }
-}
-
-#endif
diff --git a/include/xtensor/xstrided_view.hpp b/include/xtensor/xstrided_view.hpp
deleted file mode 100644
index 4d55d18f8..000000000
--- a/include/xtensor/xstrided_view.hpp
+++ /dev/null
@@ -1,720 +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 XTENSOR_STRIDED_VIEW_HPP
-#define XTENSOR_STRIDED_VIEW_HPP
-
-#include <algorithm>
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include <xtl/xsequence.hpp>
-#include <xtl/xvariant.hpp>
-
-#include "xexpression.hpp"
-#include "xiterable.hpp"
-#include "xlayout.hpp"
-#include "xsemantic.hpp"
-#include "xstorage.hpp"
-#include "xstrided_view_base.hpp"
-
-namespace xt
-{
-    /***************************
-     * xstrided_view extension *
-     ***************************/
-
-    namespace extension
-    {
-        template <class Tag, class CT, class S, layout_type L, class FST>
-        struct xstrided_view_base_impl;
-
-        template <class CT, class S, layout_type L, class FST>
-        struct xstrided_view_base_impl<xtensor_expression_tag, CT, S, L, FST>
-        {
-            using type = xtensor_empty_base;
-        };
-
-        template <class CT, class S, layout_type L, class FST>
-        struct xstrided_view_base
-            : xstrided_view_base_impl<xexpression_tag_t<CT>, CT, S, L, FST>
-        {
-        };
-
-        template <class CT, class S, layout_type L, class FST>
-        using xstrided_view_base_t = typename xstrided_view_base<CT, S, L, FST>::type;
-    }
-
-    namespace detail
-    {
-        template <class S>
-        struct xtype_for_shape
-        {
-            template <class T, layout_type L>
-            using type = xarray<T, L>;
-        };
-
-        template <template <class, std::size_t> class S, class X, std::size_t N>
-        struct xtype_for_shape<S<X, N>>
-        {
-            template <class T, layout_type L>
-            using type = xtensor<T, N, L>;
-        };
-
-        template <template <std::size_t...> class S, std::size_t... X>
-        struct xtype_for_shape<S<X...>>
-        {
-            template <class T, layout_type L>
-            using type = xtensor_fixed<T, xshape<X...>, L>;
-        };
-
-        template <class T, class S, layout_type L>
-        using temporary_type_t = typename xtype_for_shape<S>::template type<T, L>;
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    class xstrided_view;
-
-    template <class CT, class S, layout_type L, class FST>
-    struct xcontainer_inner_types<xstrided_view<CT, S, L, FST>>
-    {
-        using xexpression_type = std::decay_t<CT>;
-        using temporary_type = detail::temporary_type_t<typename xexpression_type::value_type, S, L>;
-    };
-
-    template <class CT, class S, layout_type L, class FST>
-    struct xiterable_inner_types<xstrided_view<CT, S, L, FST>>
-    {
-        using inner_shape_type = S;
-        using inner_strides_type = get_strides_t<inner_shape_type>;
-        using inner_backstrides_type_type = inner_strides_type;
-
-        using const_stepper = std::conditional_t<
-            is_indexed_stepper<typename std::decay_t<CT>::stepper>::value,
-            xindexed_stepper<const xstrided_view<CT, S, L, FST>, true>,
-            xstepper<const xstrided_view<CT, S, L, FST>>>;
-
-        using stepper = std::conditional_t<
-            is_indexed_stepper<typename std::decay_t<CT>::stepper>::value,
-            xindexed_stepper<xstrided_view<CT, S, L, FST>, false>,
-            xstepper<xstrided_view<CT, S, L, FST>>>;
-    };
-
-    /*****************
-     * xstrided_view *
-     *****************/
-
-    /**
-     * @class xstrided_view
-     * @brief View of an xexpression using strides
-     *
-     * The xstrided_view class implements a view utilizing an initial offset
-     * and strides.
-     *
-     * @tparam CT the closure type of the \ref xexpression type underlying this view
-     * @tparam L the layout of the strided view
-     * @tparam S the strides type of the strided view
-     * @tparam FST the flat storage type used for the strided view
-     *
-     * @sa strided_view, transpose
-     */
-    template <class CT, class S, layout_type L = layout_type::dynamic, class FST = typename detail::flat_storage_type<CT>::type>
-    class xstrided_view : public xview_semantic<xstrided_view<CT, S, L, FST>>,
-                          public xiterable<xstrided_view<CT, S, L, FST>>,
-                          private xstrided_view_base<CT, S, L, FST>,
-                          public extension::xstrided_view_base_t<CT, S, L, FST>
-    {
-    public:
-
-        using self_type = xstrided_view<CT, S, L, FST>;
-        using base_type = xstrided_view_base<CT, S, L, FST>;
-        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 base_type::is_const;
-
-        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 storage_iterator = typename storage_type::iterator;
-        using const_storage_iterator = typename storage_type::const_iterator;
-
-        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 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 base_type::static_layout;
-        using base_type::contiguous_layout;
-
-        using temporary_type = typename xcontainer_inner_types<self_type>::temporary_type;
-        using base_index_type = xindex_type_t<shape_type>;
-
-        using simd_value_type = xsimd::simd_type<value_type>;
-
-        template <class CTA>
-        xstrided_view(CTA&& e, S&& shape, strides_type&& strides, std::size_t offset, layout_type layout) noexcept;
-
-        template <class CTA, class FLS>
-        xstrided_view(CTA&& e, S&& shape, strides_type&& strides, std::size_t offset,
-                      layout_type layout, FLS&& flatten_strides, layout_type flatten_layout) noexcept;
-
-        xstrided_view(const xstrided_view& rhs) = default;
-        xstrided_view& operator=(const xstrided_view& rhs);
-
-        template <class E>
-        self_type& operator=(const xexpression<E>& e);
-
-        template <class E>
-        disable_xexpression<E, self_type>& operator=(const E& e);
-
-        using base_type::size;
-        using base_type::dimension;
-        using base_type::shape;
-        using base_type::strides;
-        using base_type::backstrides;
-        using base_type::layout;
-
-        using base_type::operator();
-        using base_type::at;
-        using base_type::unchecked;
-        using base_type::operator[];
-        using base_type::element;
-        using base_type::storage;
-        using base_type::data;
-        using base_type::data_offset;
-        using base_type::expression;
-
-        using base_type::broadcast_shape;
-        using base_type::has_linear_assign;
-
-        template <class T>
-        void fill(const T& value);
-
-        storage_iterator storage_begin();
-        storage_iterator storage_end();
-        const_storage_iterator storage_cbegin() const;
-        const_storage_iterator storage_cend() 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, class STEP = const_stepper>
-        std::enable_if_t<!is_indexed_stepper<STEP>::value, STEP>
-        stepper_begin(const ST& shape) const;
-        template <class ST, class STEP = const_stepper>
-        std::enable_if_t<!is_indexed_stepper<STEP>::value, STEP>
-        stepper_end(const ST& shape, layout_type l) const;
-
-        template <class ST, class STEP = const_stepper>
-        std::enable_if_t<is_indexed_stepper<STEP>::value, STEP>
-        stepper_begin(const ST& shape) const;
-        template <class ST, class STEP = const_stepper>
-        std::enable_if_t<is_indexed_stepper<STEP>::value, STEP>
-        stepper_end(const ST& shape, layout_type l) const;
-
-        using container_iterator = std::conditional_t<is_const,
-                                                      typename storage_type::const_iterator,
-                                                      typename storage_type::iterator>;
-        using const_container_iterator = typename storage_type::const_iterator;
-
-        template <class E>
-        using rebind_t = xstrided_view<E, S, L, detail::flat_storage_type_t<E>>;
-
-        template <class E>
-        rebind_t<E> build_view(E&& e) const;
-
-    private:
-
-        container_iterator data_xbegin() noexcept;
-        const_container_iterator data_xbegin() const noexcept;
-        container_iterator data_xend(layout_type l) noexcept;
-        const_container_iterator data_xend(layout_type l) const noexcept;
-
-        template <class It>
-        It data_xbegin_impl(It begin) const noexcept;
-
-        template <class It>
-        It data_xend_impl(It end, layout_type l) const noexcept;
-
-        void assign_temporary_impl(temporary_type&& tmp);
-
-        template <class C>
-        friend class xstepper;
-        friend class xview_semantic<xstrided_view<CT, S, L, FST>>;
-    };
-
-    /**************************
-     * xstrided_view builders *
-     **************************/
-
-    template <class T>
-    using xstrided_slice = xtl::variant<
-        T,
-
-        xrange_adaptor<placeholders::xtuph, T, T>,
-        xrange_adaptor<T, placeholders::xtuph, T>,
-        xrange_adaptor<T, T, placeholders::xtuph>,
-
-        xrange_adaptor<T, placeholders::xtuph, placeholders::xtuph>,
-        xrange_adaptor<placeholders::xtuph, T, placeholders::xtuph>,
-        xrange_adaptor<placeholders::xtuph, placeholders::xtuph, T>,
-
-        xrange_adaptor<T, T, T>,
-        xrange_adaptor<placeholders::xtuph, placeholders::xtuph, placeholders::xtuph>,
-
-        xrange<T>,
-        xstepped_range<T>,
-
-        xall_tag,
-        xellipsis_tag,
-        xnewaxis_tag
-    >;
-
-    /**
-    * @typedef xstrided_slice_vector
-    * @brief vector of slices used to build a `xstrided_view`
-    */
-    using xstrided_slice_vector = std::vector<xstrided_slice<std::ptrdiff_t>>;
-
-    // TODO: remove this type used for backward compatibility only
-    using slice_vector = xstrided_slice_vector;
-
-    template <layout_type L = layout_type::dynamic, class E, class S, class X>
-    auto strided_view(E&& e, S&& shape, X&& stride, std::size_t offset = 0, layout_type layout = L) noexcept;
-
-    template <class E>
-    auto strided_view(E&& e, const xstrided_slice_vector& slices);
-
-    /********************************
-     * xstrided_view implementation *
-     ********************************/
-
-    /**
-     * @name Constructor
-     */
-    //@{
-    /**
-     * Constructs an xstrided_view
-     *
-     * @param e the underlying xexpression for this view
-     * @param shape the shape of the view
-     * @param strides the strides of the view
-     * @param offset the offset of the first element in the underlying container
-     * @param layout the layout of the view
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class CTA>
-    inline xstrided_view<CT, S, L, FST>::xstrided_view(CTA&& e, S&& shape, strides_type&& strides, std::size_t offset, layout_type layout) noexcept
-        : base_type(std::forward<CTA>(e), std::move(shape), std::move(strides), offset, layout)
-    {
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class CTA, class FLS>
-    inline xstrided_view<CT, S, L, FST>::xstrided_view(CTA&& e, S&& shape, strides_type&& strides, std::size_t offset,
-                                                       layout_type layout, FLS&& flatten_strides, layout_type flatten_layout) noexcept
-        : base_type(std::forward<CTA>(e), std::move(shape), std::move(strides), offset, layout, std::forward<FLS>(flatten_strides), flatten_layout)
-    {
-    }
-    //@}
-
-    template <class CT, class S, layout_type L, class FST>
-    inline xstrided_view<CT, S, L, FST>& xstrided_view<CT, S, L, FST>::operator=(const xstrided_view<CT, S, L, FST>& rhs)
-    {
-        temporary_type tmp(rhs);
-        return this->assign_temporary(std::move(tmp));
-    }
-
-    /**
-     * @name Extended copy semantic
-     */
-    //@{
-    /**
-     * The extended assignment operator.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class E>
-    inline auto xstrided_view<CT, S, L, FST>::operator=(const xexpression<E>& e) -> self_type&
-    {
-        return semantic_base::operator=(e);
-    }
-    //@}
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class E>
-    inline auto xstrided_view<CT, S, L, FST>::operator=(const E& e) -> disable_xexpression<E, self_type>&
-    {
-        this->fill(e);
-        return *this;
-    }
-
-    namespace xstrided_view_detail
-    {
-        template <class V, class T>
-        inline void run_assign_temporary_impl(V& v, const T& t, std::true_type /* enable strided assign */)
-        {
-            strided_loop_assigner<true>::run(v, t);
-        }
-
-        template <class V, class T>
-        inline void run_assign_temporary_impl(V& v, const T& t, std::false_type /* fallback to iterator assign */)
-        {
-            std::copy(t.cbegin(), t.cend(), v.begin());
-        }
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline void xstrided_view<CT, S, L, FST>::assign_temporary_impl(temporary_type&& tmp)
-    {
-        constexpr bool fast_assign = xassign_traits<xstrided_view<CT, S, L, FST>, temporary_type>::simd_strided_loop();
-        xstrided_view_detail::run_assign_temporary_impl(*this, tmp, std::integral_constant<bool, fast_assign>{});
-    }
-
-    /**
-     * @name Data
-     */
-    //@{
-
-    /**
-     * Fills the view with the given value.
-     * @param value the value to fill the view with.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class T>
-    inline void xstrided_view<CT, S, L, FST>::fill(const T& value)
-    {
-        if (layout() != layout_type::dynamic)
-        {
-            std::fill(this->storage_begin(), this->storage_end(), value);
-        }
-        else
-        {
-            std::fill(this->begin(), this->end(), value);
-        }
-    }
-    //@}
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::storage_begin() -> storage_iterator
-    {
-        return this->storage().begin() + static_cast<std::ptrdiff_t>(data_offset());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::storage_end() -> storage_iterator
-    {
-        return this->storage().begin() + static_cast<std::ptrdiff_t>(data_offset() + size());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::storage_cbegin() const -> const_storage_iterator
-    {
-        return this->storage().cbegin() + static_cast<std::ptrdiff_t>(data_offset());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::storage_cend() const -> const_storage_iterator
-    {
-        return this->storage().cbegin() + static_cast<std::ptrdiff_t>(data_offset() + size());
-    }
-
-    /***************
-     * stepper api *
-     ***************/
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class ST>
-    inline auto xstrided_view<CT, S, L, FST>::stepper_begin(const ST& shape) -> stepper
-    {
-        size_type offset = shape.size() - dimension();
-        return stepper(this, data_xbegin(), offset);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class ST>
-    inline auto xstrided_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type l) -> stepper
-    {
-        size_type offset = shape.size() - dimension();
-        return stepper(this, data_xend(l), offset);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class ST, class STEP>
-    inline auto xstrided_view<CT, S, L, FST>::stepper_begin(const ST& shape) const -> std::enable_if_t<!is_indexed_stepper<STEP>::value, STEP>
-    {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(this, data_xbegin(), offset);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class ST, class STEP>
-    inline auto xstrided_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type l) const -> std::enable_if_t<!is_indexed_stepper<STEP>::value, STEP>
-    {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(this, data_xend(l), offset);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class ST, class STEP>
-    inline auto xstrided_view<CT, S, L, FST>::stepper_begin(const ST& shape) const -> std::enable_if_t<is_indexed_stepper<STEP>::value, STEP>
-    {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(this, offset);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class ST, class STEP>
-    inline auto xstrided_view<CT, S, L, FST>::stepper_end(const ST& shape, layout_type /*l*/) const -> std::enable_if_t<is_indexed_stepper<STEP>::value, STEP>
-    {
-        size_type offset = shape.size() - dimension();
-        return const_stepper(this, offset, true);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class It>
-    inline It xstrided_view<CT, S, L, FST>::data_xbegin_impl(It begin) const noexcept
-    {
-        return begin + static_cast<std::ptrdiff_t>(this->data_offset());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class It>
-    inline It xstrided_view<CT, S, L, FST>::data_xend_impl(It begin, layout_type l) const noexcept
-    {
-        std::ptrdiff_t end_offset = static_cast<std::ptrdiff_t>(std::accumulate(this->backstrides().begin(), this->backstrides().end(), std::size_t(0)));
-        return strided_data_end(*this, begin + std::ptrdiff_t(this->data_offset()) + end_offset + 1, l);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::data_xbegin() noexcept -> container_iterator
-    {
-        return data_xbegin_impl(this->storage().begin());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::data_xbegin() const noexcept -> const_container_iterator
-    {
-        return data_xbegin_impl(this->storage().cbegin());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::data_xend(layout_type l) noexcept -> container_iterator
-    {
-        return data_xend_impl(this->storage().begin(), l);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view<CT, S, L, FST>::data_xend(layout_type l) const noexcept -> const_container_iterator
-    {
-        return data_xend_impl(this->storage().cbegin(), l);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class E>
-    inline auto xstrided_view<CT, S, L, FST>::build_view(E&& e) const -> rebind_t<E>
-    {
-        inner_shape_type sh(this->shape());
-        inner_strides_type str(this->strides());
-        return rebind_t<E>(std::forward<E>(e), std::move(sh), std::move(str), base_type::data_offset(), this->layout());
-    }
-
-    /*****************************************
-     * xstrided_view builders implementation *
-     *****************************************/
-
-    /**
-     * Construct a strided view from an xexpression, shape, strides and offset.
-     *
-     * @param e xexpression
-     * @param shape the shape of the view
-     * @param strides the new strides of the view
-     * @param offset the offset of the first element in the underlying container
-     * @param layout the new layout of the expression
-     *
-     * @tparam L the static layout type of the view (default: dynamic)
-     * @tparam E type of xexpression
-     * @tparam S strides type
-     * @tparam X strides type
-     *
-     * @return the view
-     */
-    template <layout_type L, class E, class S, class X>
-    inline auto strided_view(E&& e, S&& shape, X&& strides, std::size_t offset, layout_type layout) noexcept
-    {
-        using view_type = xstrided_view<xclosure_t<E>, S, L>;
-        return view_type(std::forward<E>(e), std::forward<S>(shape), std::forward<X>(strides), offset, layout);
-    }
-
-    template <class T>
-    struct select_strided_view
-    {
-        template <class CT, class S, layout_type L = layout_type::dynamic>
-        using type = xstrided_view<CT, S, L>;
-    };
-
-    template <class T>
-    using select_strided_view_t = typename select_strided_view<T>::type;
-
-    namespace detail
-    {
-        struct no_adj_strides_policy
-        {
-        protected:
-
-            inline void resize(std::size_t) {}
-            inline void set_fake_slice(std::size_t) {}
-
-            template <class ST, class S>
-            bool fill_args(const xstrided_slice_vector& /*slices*/, std::size_t /*sl_idx*/,
-                           std::size_t /*i*/, std::size_t /*old_shape*/,
-                           const ST& /*old_stride*/,
-                           S& /*shape*/, get_strides_t<S>& /*strides*/)
-            {
-                return false;
-            }
-        };
-    }
-
-    /**
-     * Function to create a dynamic view from
-     * an xexpression and an xstrided_slice_vector.
-     *
-     * @param e xexpression
-     * @param slices the slice vector
-     *
-     * @return initialized strided_view according to slices
-     *
-     * \code{.cpp}
-     * xt::xarray<double> a = {{1, 2, 3}, {4, 5, 6}};
-     * xt::slice_vector sv({xt::range(0, 1)});
-     * sv.push_back(xt::range(0, 3, 2));
-     * auto v = xt::strided_view(a, sv);
-     * // ==> {{1, 3}}
-     * \endcode
-     *
-     * You can also achieve the same with the following short-hand syntax:
-     *
-     * \code{.cpp}
-     * xt::xarray<double> a = {{1, 2, 3}, {4, 5, 6}};
-     * auto v = xt::strided_view(a, {xt::range(0, 1), xt::range(0, 3, 2)});
-     * // ==> {{1, 3}}
-     * \endcode
-     */
-    template <class E>
-    inline auto strided_view(E&& e, const xstrided_slice_vector& slices)
-    {
-        detail::strided_view_args<detail::no_adj_strides_policy> args;
-        args.fill_args(e.shape(), detail::get_strides(e), detail::get_offset(e), e.layout(), slices);
-        using view_type = xstrided_view<xclosure_t<E>, decltype(args.new_shape)>;
-        return view_type(std::forward<E>(e), std::move(args.new_shape), std::move(args.new_strides), args.new_offset, args.new_layout);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    auto strided_view(const xstrided_view<CT, S, L, FST>& e, const xstrided_slice_vector& slices)
-    {
-        detail::strided_view_args<detail::no_adj_strides_policy> args;
-        args.fill_args(e.shape(), detail::get_strides(e), detail::get_offset(e), e.layout(), slices);
-        using view_type = xstrided_view<xclosure_t<decltype(e.expression())>, decltype(args.new_shape)>;
-        return view_type(e.expression(), std::move(args.new_shape), std::move(args.new_strides), args.new_offset, args.new_layout);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    auto strided_view(xstrided_view<CT, S, L, FST>& e, const xstrided_slice_vector& slices)
-    {
-        detail::strided_view_args<detail::no_adj_strides_policy> args;
-        args.fill_args(e.shape(), detail::get_strides(e), detail::get_offset(e), e.layout(), slices);
-        using view_type = xstrided_view<xclosure_t<decltype(e.expression())>, decltype(args.new_shape)>;
-        return view_type(e.expression(), std::move(args.new_shape), std::move(args.new_strides), args.new_offset, args.new_layout);
-    }
-
-    template <class E, class S>
-    inline auto reshape_view(E&& e, S&& shape)
-    {
-        using shape_type = std::decay_t<S>;
-        get_strides_t<shape_type> strides;
-
-        xt::resize_container(strides, shape.size());
-        compute_strides(shape, default_assignable_layout(std::decay_t<E>::static_layout), strides);
-        return strided_view<std::decay_t<E>::static_layout>(std::forward<E>(e), std::forward<S>(shape), std::move(strides), 0);
-    }
-
-    /**
-     * @brief Return a view on a container with a new shape
-     *
-     * Note: if you resize the underlying container, this view becomes
-     * invalidated.
-     *
-     * @param e xexpression to reshape
-     * @param shape new shape
-     * @param layout new layout (optional)
-     *
-     * @return view on xexpression with new shape
-     */
-    template <class E, class S>
-    inline auto reshape_view(E&& e, S&& shape, layout_type layout)
-    {
-        using shape_type = std::decay_t<S>;
-        get_strides_t<shape_type> strides;
-
-        xt::resize_container(strides, shape.size());
-        compute_strides(shape, layout, strides);
-
-        return strided_view(std::forward<E>(e), std::forward<S>(shape), std::move(strides), 0);
-    }
-
-#if !defined(X_OLD_CLANG)
-    template <class E, class I, std::size_t N>
-    inline auto reshape_view(E&& e, const I(&shape)[N], layout_type l)
-    {
-        using shape_type = std::array<std::size_t, N>;
-        return reshape_view(std::forward<E>(e), xtl::forward_sequence<shape_type>(shape), l);
-    }
-
-    template <class E, class I, std::size_t N>
-    inline auto reshape_view(E&& e, const I(&shape)[N])
-    {
-        using shape_type = std::array<std::size_t, N>;
-        return reshape_view(std::forward<E>(e), xtl::forward_sequence<shape_type>(shape));
-    }
-#else
-    template <class E, class I>
-    inline auto reshape_view(E&& e, const std::initializer_list<I>& shape)
-    {
-        using shape_type = xt::dynamic_shape<std::size_t>;
-        return reshape_view(std::forward<E>(e), xtl::forward_sequence<shape_type>(shape));
-    }
-
-    template <class E, class I>
-    inline auto reshape_view(E&& e, const std::initializer_list<I>& shape, layout_type l)
-    {
-        using shape_type = xt::dynamic_shape<std::size_t>;
-        return reshape_view(std::forward<E>(e), xtl::forward_sequence<shape_type>(shape), l);
-    }
-#endif
-}
-
-#endif
diff --git a/include/xtensor/xstrided_view_base.hpp b/include/xtensor/xstrided_view_base.hpp
deleted file mode 100644
index 19078e457..000000000
--- a/include/xtensor/xstrided_view_base.hpp
+++ /dev/null
@@ -1,1042 +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 XTENSOR_STRIDED_VIEW_BASE_HPP
-#define XTENSOR_STRIDED_VIEW_BASE_HPP
-
-#include <type_traits>
-
-#include <xtl/xsequence.hpp>
-
-#include "xtensor_forward.hpp"
-#include "xslice.hpp"
-#include "xstrides.hpp"
-#include "xutils.hpp"
-
-namespace xt
-{
-    template <class CT, class S, layout_type L, class FST>
-    class xstrided_view_base
-    {
-    public:
-
-        using xexpression_type = std::decay_t<CT>;
-        static constexpr bool is_const = std::is_const<std::remove_reference_t<CT>>::value;
-
-        using value_type = typename xexpression_type::value_type;
-        using reference = std::conditional_t<is_const,
-                                             typename xexpression_type::const_reference,
-                                             typename xexpression_type::reference>;
-        using const_reference = typename xexpression_type::const_reference;
-        using pointer = std::conditional_t<is_const,
-                                           typename xexpression_type::const_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 inner_storage_type = FST;
-        using storage_type = std::remove_reference_t<inner_storage_type>;
-
-        using shape_type = S;
-        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;
-
-        static constexpr layout_type static_layout = L;
-        static constexpr bool contiguous_layout = static_layout != layout_type::dynamic && xexpression_type::contiguous_layout;
-
-        template <class CTA>
-        xstrided_view_base(CTA&& e, S&& shape, strides_type&& strides, size_type offset, layout_type layout) noexcept;
-
-        template <class CTA, class FLS>
-        xstrided_view_base(CTA&& e, S&& shape, strides_type&& strides, size_type offset,
-                           layout_type layout, FLS&& flatten_strides, layout_type flatten_layout) noexcept;
-
-        xstrided_view_base(xstrided_view_base&& rhs);
-
-        xstrided_view_base(const xstrided_view_base& rhs);
-
-        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;
-        layout_type layout() const noexcept;
-
-        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 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 OS>
-        disable_integral_t<OS, reference> operator[](const OS& index);
-        template <class I>
-        reference operator[](std::initializer_list<I> index);
-        reference operator[](size_type i);
-
-        template <class OS>
-        disable_integral_t<OS, const_reference> operator[](const OS& index) const;
-        template <class I>
-        const_reference operator[](std::initializer_list<I> index) const;
-        const_reference operator[](size_type i) const;
-
-        template <class It>
-        reference element(It first, It last);
-
-        template <class It>
-        const_reference element(It first, It last) const;
-
-        storage_type& storage() noexcept;
-        const storage_type& storage() const noexcept;
-
-        template <class E = std::decay_t<CT>>
-        std::enable_if_t<has_data_interface<std::decay_t<E>>::value, value_type*>
-        data() noexcept;
-        template <class E = std::decay_t<CT>>
-        std::enable_if_t<has_data_interface<std::decay_t<E>>::value, const value_type*>
-        data() const noexcept;
-        size_type data_offset() const noexcept;
-
-        xexpression_type& expression() noexcept;
-        const xexpression_type& expression() const noexcept;
-
-        template <class O>
-        bool broadcast_shape(O& shape, bool reuse_cache = false) const;
-
-        template <class O>
-        bool has_linear_assign(const O& strides) const noexcept;
-
-    protected:
-
-        using offset_type = typename strides_type::value_type;
-
-        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;
-
-    private:
-
-        CT m_e;
-        inner_storage_type m_storage;
-        inner_shape_type m_shape;
-        inner_strides_type m_strides;
-        inner_backstrides_type m_backstrides;
-        size_type m_offset;
-        layout_type m_layout;
-    };
-
-    /***************************
-     * flat_expression_adaptor *
-     ***************************/
-
-    namespace detail
-    {
-        template <class CT>
-        class flat_expression_adaptor
-        {
-        public:
-
-            using xexpression_type = std::decay_t<CT>;
-            using shape_type = typename xexpression_type::shape_type;
-            using index_type = xindex_type_t<shape_type>;
-            using size_type = typename xexpression_type::size_type;
-            using value_type = typename xexpression_type::value_type;
-            using reference = typename xexpression_type::reference;
-            using const_reference = typename xexpression_type::const_reference;
-
-            using iterator = typename xexpression_type::iterator;
-            using const_iterator = typename xexpression_type::const_iterator;
-
-            explicit flat_expression_adaptor(CT* e);
-
-            template <class FST>
-            flat_expression_adaptor(CT* e, FST&& strides, layout_type layout);
-
-            void update_pointer(CT* ptr) const
-            {
-                m_e = ptr;
-            }
-
-            size_type size() const;
-            reference operator[](size_type idx);
-            const_reference operator[](size_type idx) const;
-
-            iterator begin();
-            iterator end();
-            const_iterator begin() const;
-            const_iterator end() const;
-            const_iterator cbegin() const;
-            const_iterator cend() const;
-
-        private:
-
-            mutable CT* m_e;
-            shape_type m_strides;
-            mutable index_type m_index;
-            size_type m_size;
-            layout_type m_layout;
-        };
-
-        template <class CT, class T = void>
-        struct flat_storage_type;
-
-        template <class CT>
-        struct flat_storage_type<CT, typename std::enable_if_t<has_data_interface<std::decay_t<CT>>::value>>
-        {
-            // Note: we could also use the storage_type typedef.
-            // using type = std::conditional_t<
-            //    std::is_const<std::remove_reference_t<CT>>::value,
-            //    const typename std::decay_t<CT>::storage_type&,
-            //    typename std::decay_t<CT>::storage_type&>;
-            using type = decltype(std::declval<CT>().storage());
-        };
-
-        template <class CT>
-        struct flat_storage_type<CT, typename std::enable_if_t<!has_data_interface<std::decay_t<CT>>::value>>
-        {
-            using type = flat_expression_adaptor<std::remove_reference_t<CT>>;
-        };
-
-        template <class CT>
-        using flat_storage_type_t = typename flat_storage_type<CT>::type;
-
-        // with data_interface
-        template <class E, std::enable_if_t<has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline decltype(auto) get_flat_storage(E& e)
-        {
-            return e.storage();
-        }
-
-        template <class E, std::enable_if_t<has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline auto get_offset(E&& e)
-        {
-            return e.data_offset();
-        }
-
-        template <class E, std::enable_if_t<has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline decltype(auto) get_strides(E&& e)
-        {
-            return e.strides();
-        }
-
-        // without data_interface
-        template <class E, std::enable_if_t<!has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline auto get_flat_storage(E& e) -> flat_expression_adaptor<std::remove_reference_t<E>>
-        {
-            // moved to addressof because ampersand on xview returns a closure pointer
-            return flat_expression_adaptor<std::remove_reference_t<E>>(std::addressof(e));
-        }
-
-        template <class E, class S>
-        inline auto get_flat_storage(E& e, S&& s, layout_type l) -> flat_expression_adaptor<std::remove_reference_t<E>>
-        {
-            return flat_expression_adaptor<std::remove_reference_t<E>>(std::addressof(e), std::forward<S>(s), l);
-        }
-
-        template <class E, std::enable_if_t<!has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline auto get_offset(E&& /*e*/)
-        {
-            return typename std::decay_t<E>::size_type(0);
-        }
-
-        template <class E, std::enable_if_t<!has_data_interface<std::decay_t<E>>::value>* = nullptr>
-        inline auto get_strides(E&& e)
-        {
-            dynamic_shape<std::ptrdiff_t> strides;
-            strides.resize(e.shape().size());
-            compute_strides(e.shape(), XTENSOR_DEFAULT_LAYOUT, strides);
-            return strides;
-        }
-    }
-
-    /*************************************
-     * xstrided_view_base implementation *
-     *************************************/
-
-    /**
-     * @name Constructor
-     */
-    //@{
-    /**
-     * Constructs an xstrided_view_base
-     *
-     * @param e the underlying xexpression for this view
-     * @param shape the shape of the view
-     * @param strides the strides of the view
-     * @param offset the offset of the first element in the underlying container
-     * @param layout the layout of the view
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class CTA>
-    inline xstrided_view_base<CT, S, L, FST>::xstrided_view_base(CTA&& e, S&& shape, strides_type&& strides, size_type offset, layout_type layout) noexcept
-        : m_e(std::forward<CTA>(e)),
-          m_storage(detail::get_flat_storage<CT>(m_e)),
-          m_shape(std::move(shape)),
-          m_strides(std::move(strides)),
-          m_offset(offset),
-          m_layout(layout)
-    {
-        m_backstrides = xtl::make_sequence<backstrides_type>(m_shape.size(), 0);
-        adapt_strides(m_shape, m_strides, m_backstrides);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class CTA, class FLS>
-    inline xstrided_view_base<CT, S, L, FST>::xstrided_view_base(CTA&& e, S&& shape, strides_type&& strides,
-                                                                 size_type offset, layout_type layout,
-                                                                 FLS&& flatten_strides, layout_type flatten_layout) noexcept
-        : m_e(std::forward<CTA>(e)),
-          m_storage(detail::get_flat_storage<CT>(m_e, std::forward<FLS>(flatten_strides), flatten_layout)),
-          m_shape(std::move(shape)),
-          m_strides(std::move(strides)),
-          m_offset(offset),
-          m_layout(layout)
-    {
-        m_backstrides = xtl::make_sequence<backstrides_type>(m_shape.size(), 0);
-        adapt_strides(m_shape, m_strides, m_backstrides);
-    }
-
-    namespace detail
-    {
-        template <class T, class S>
-        auto& copy_move_storage(T& expr, S& /*storage*/)
-        {
-            return expr.storage();
-        }
-
-        template <class T, class E>
-        auto copy_move_storage(T& expr, const detail::flat_expression_adaptor<E>& storage)
-        {
-            detail::flat_expression_adaptor<E> new_storage = storage; // copy storage
-            new_storage.update_pointer(std::addressof(expr));
-            return new_storage;
-        }
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline xstrided_view_base<CT, S, L, FST>::xstrided_view_base(xstrided_view_base&& rhs)
-        : m_e(std::forward<CT>(rhs.m_e)),
-          m_storage(detail::copy_move_storage(m_e, rhs.m_storage)),
-          m_shape(std::move(rhs.m_shape)),
-          m_strides(std::move(rhs.m_strides)),
-          m_backstrides(std::move(rhs.m_backstrides)),
-          m_offset(std::move(rhs.m_offset)),
-          m_layout(std::move(rhs.m_layout))
-    {
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline xstrided_view_base<CT, S, L, FST>::xstrided_view_base(const xstrided_view_base& rhs)
-        : m_e(rhs.m_e),
-          m_storage(detail::copy_move_storage(m_e, rhs.m_storage)),
-          m_shape(rhs.m_shape),
-          m_strides(rhs.m_strides),
-          m_backstrides(rhs.m_backstrides),
-          m_offset(rhs.m_offset),
-          m_layout(rhs.m_layout)
-    {
-    }
-    //@}
-
-    /**
-     * @name Size and shape
-     */
-    //@{
-    /**
-     * Returns the size of the xtrided_view_base.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::size() const noexcept -> size_type
-    {
-        return compute_size(shape());
-    }
-
-    /**
-     * Returns the number of dimensions of the xtrided_view_base.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::dimension() const noexcept -> size_type
-    {
-        return m_shape.size();
-    }
-
-    /**
-     * Returns the shape of the xtrided_view_base.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::shape() const noexcept -> const inner_shape_type&
-    {
-        return m_shape;
-    }
-
-    /**
-     * Returns the strides of the xtrided_view_base.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::strides() const noexcept -> const inner_strides_type&
-    {
-        return m_strides;
-    }
-
-    /**
-     * Returns the backstrides of the xtrided_view_base.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::backstrides() const noexcept -> const inner_backstrides_type&
-    {
-        return m_backstrides;
-    }
-
-    /**
-     * Returns the layout of the xtrided_view_base.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::layout() const noexcept -> layout_type
-    {
-        return m_layout;
-    }
-    //@}
-
-    /**
-     * @name Data
-     */
-    //@{
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator()() -> reference
-    {
-        return m_storage[static_cast<size_type>(m_offset)];
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator()() const -> const_reference
-    {
-        return m_storage[static_cast<size_type>(m_offset)];
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the view.
-     * @param args a 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.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator()(Args... args) -> reference
-    {
-        XTENSOR_TRY(check_index(shape(), args...));
-        XTENSOR_CHECK_DIMENSION(shape(), args...);
-        offset_type index = compute_index(args...);
-        return m_storage[static_cast<size_type>(index)];
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the view.
-     * @param args a 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.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator()(Args... args) const -> const_reference
-    {
-        XTENSOR_TRY(check_index(shape(), args...));
-        XTENSOR_CHECK_DIMENSION(shape(), args...);
-        offset_type index = compute_index(args...);
-        return m_storage[static_cast<size_type>(index)];
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the view,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the view. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the view.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::at(Args... args) -> reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the view,
-     * after dimension and bounds checking.
-     * @param args a list of indices specifying the position in the view. Indices
-     * must be unsigned integers, the number of indices should be equal to the number of dimensions
-     * of the view.
-     * @exception std::out_of_range if the number of argument is greater than the number of dimensions
-     * or if indices are out of bounds.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::at(Args... args) const -> const_reference
-    {
-        check_access(shape(), static_cast<size_type>(args)...);
-        return this->operator()(args...);
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the view.
-     * @param args a 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 prefered whenever
-     * it is possible.
-     * @warning This method is NOT compatible with broadcasting, meaning the following
-     * code has undefined behavior:
-     * \code{.cpp}
-     * xt::xarray<double> a = {{0, 1}, {2, 3}};
-     * xt::xarray<double> b = {0, 1};
-     * auto fd = a + b;
-     * double res = fd.uncheked(0, 1);
-     * \endcode
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::unchecked(Args... args) -> reference
-    {
-        offset_type index = compute_unchecked_index(args...);
-        return m_storage[static_cast<size_type>(index)];
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the view.
-     * @param args a 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 prefered whenever
-     * it is possible.
-     * @warning This method is NOT compatible with broadcasting, meaning the following
-     * code has undefined behavior:
-     * \code{.cpp}
-     * xt::xarray<double> a = {{0, 1}, {2, 3}};
-     * xt::xarray<double> b = {0, 1};
-     * auto fd = a + b;
-     * double res = fd.uncheked(0, 1);
-     * \endcode
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::unchecked(Args... args) const -> const_reference
-    {
-        offset_type index = compute_unchecked_index(args...);
-        return m_storage[static_cast<size_type>(index)];
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the view.
-     * @param index a sequence of indices specifying the position in the view. Indices
-     * must be unsigned integers, the number of indices in the list should be equal or greater
-     * than the number of dimensions of the view.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class OS>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator[](const OS& index)
-        -> disable_integral_t<OS, reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class I>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator[](std::initializer_list<I> index)
-        -> reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator[](size_type i) -> reference
-    {
-        return operator()(i);
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the view.
-     * @param index a sequence of indices specifying the position in the view. Indices
-     * must be unsigned integers, the number of indices in the list should be equal or greater
-     * than the number of dimensions of the view.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class OS>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator[](const OS& index) const
-        -> disable_integral_t<OS, const_reference>
-    {
-        return element(index.cbegin(), index.cend());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class I>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator[](std::initializer_list<I> index) const
-        -> const_reference
-    {
-        return element(index.begin(), index.end());
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::operator[](size_type i) const -> const_reference
-    {
-        return operator()(i);
-    }
-
-    /**
-     * Returns a reference to the element at the specified position in the view.
-     * @param first iterator starting the sequence of indices
-     * @param last iterator 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..
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class It>
-    inline auto xstrided_view_base<CT, S, L, FST>::element(It first, It last) -> reference
-    {
-        XTENSOR_TRY(check_element_index(shape(), first, last));
-        return m_storage[static_cast<size_type>(compute_element_index(first, last))];
-    }
-
-    /**
-     * Returns a constant reference to the element at the specified position in the view.
-     * @param first iterator starting the sequence of indices
-     * @param last iterator 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..
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class It>
-    inline auto xstrided_view_base<CT, S, L, FST>::element(It first, It last) const -> const_reference
-    {
-        XTENSOR_TRY(check_element_index(shape(), first, last));
-        return m_storage[static_cast<size_type>(compute_element_index(first, last))];
-    }
-
-    /**
-     * Returns a reference to the buffer containing the elements of the view.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::storage() noexcept -> storage_type&
-    {
-        return m_storage;
-    }
-
-    /**
-     * Returns a constant reference to the buffer containing the elements of the view.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::storage() const noexcept -> const storage_type&
-    {
-        return m_storage;
-    }
-
-    /**
-     * Returns a pointer to the underlying array serving as element storage.
-     * The first element of the view is at data() + data_offset().
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class E>
-    inline auto xstrided_view_base<CT, S, L, FST>::data() noexcept ->
-        std::enable_if_t<has_data_interface<std::decay_t<E>>::value, value_type*>
-    {
-        return m_e.data();
-    }
-
-    /**
-     * Returns a constant pointer to the underlying array serving as element storage.
-     * The first element of the view is at data() + data_offset().
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class E>
-    inline auto xstrided_view_base<CT, S, L, FST>::data() const noexcept ->
-        std::enable_if_t<has_data_interface<std::decay_t<E>>::value, const value_type*>
-    {
-        return m_e.data();
-    }
-
-    /**
-     * Returns the offset to the first element in the view.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::data_offset() const noexcept -> size_type
-    {
-        return m_offset;
-    }
-
-    /**
-     * Returns a reference to the underlying expression of the view.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::expression() noexcept -> xexpression_type&
-    {
-        return m_e;
-    }
-
-    /**
-     * Returns a constant reference to the underlying expression of the view.
-     */
-    template <class CT, class S, layout_type L, class FST>
-    inline auto xstrided_view_base<CT, S, L, FST>::expression() const noexcept -> const xexpression_type&
-    {
-        return m_e;
-    }
-    //@}
-
-    /**
-     * @name Broadcasting
-     */
-    //@{
-    /**
-     * Broadcast the shape of the view to the specified parameter.
-     * @param shape the result shape
-     * @param reuse_cache parameter for internal optimization
-     * @return a boolean indicating whether the broadcasting is trivial
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class O>
-    inline bool xstrided_view_base<CT, S, L, FST>::broadcast_shape(O& shape, bool) const
-    {
-        return xt::broadcast_shape(m_shape, shape);
-    }
-
-    /**
-     * Checks whether the xstrided_view_base can be linearly assigned to an expression
-     * with the specified strides.
-     * @return a boolean indicating whether a linear assign is possible
-     */
-    template <class CT, class S, layout_type L, class FST>
-    template <class O>
-    inline bool xstrided_view_base<CT, S, L, FST>::has_linear_assign(const O& str) const noexcept
-    {
-        return has_data_interface<std::decay_t<CT>>::value && str.size() == strides().size() &&
-            std::equal(str.cbegin(), str.cend(), strides().begin());
-    }
-    //@}
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::compute_index(Args... args) const -> offset_type
-    {
-        return static_cast<offset_type>(m_offset) + xt::data_offset<offset_type>(strides(), static_cast<offset_type>(args)...);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class... Args>
-    inline auto xstrided_view_base<CT, S, L, FST>::compute_unchecked_index(Args... args) const -> offset_type
-    {
-        return static_cast<offset_type>(m_offset) + xt::unchecked_data_offset<offset_type>(strides(), static_cast<offset_type>(args)...);
-    }
-
-    template <class CT, class S, layout_type L, class FST>
-    template <class It>
-    inline auto xstrided_view_base<CT, S, L, FST>::compute_element_index(It first, It last) const -> offset_type
-    {
-        return static_cast<offset_type>(m_offset) + xt::element_offset<offset_type>(strides(), first, last);
-    }
-
-    /******************************************
-     * flat_expression_adaptor implementation *
-     ******************************************/
-
-    namespace detail
-    {
-        template <class CT>
-        inline flat_expression_adaptor<CT>::flat_expression_adaptor(CT* e)
-            : m_e(e)
-        {
-            resize_container(m_index, m_e->dimension());
-            resize_container(m_strides, m_e->dimension());
-            m_size = compute_size(m_e->shape());
-            // Fallback to XTENSOR_DEFAULT_LAYOUT when the underlying layout is not
-            // row-major or column major.
-            m_layout = default_assignable_layout(m_e->layout());
-            compute_strides(m_e->shape(), m_layout, m_strides);
-        }
-
-        template <class CT>
-        template <class FST>
-        inline flat_expression_adaptor<CT>::flat_expression_adaptor(CT* e, FST&& strides, layout_type layout)
-            : m_e(e), m_strides(xtl::forward_sequence<shape_type>(strides)), m_layout(layout)
-        {
-            resize_container(m_index, m_e->dimension());
-            m_size = m_e->size();
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::size() const -> size_type
-        {
-            return m_size;
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::operator[](size_type idx) -> reference
-        {
-            m_index = detail::unravel_noexcept(idx, m_strides, m_layout);
-            return m_e->element(m_index.cbegin(), m_index.cend());
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::operator[](size_type idx) const -> const_reference
-        {
-            m_index = detail::unravel_noexcept(idx, m_strides, m_layout);
-            return m_e->element(m_index.cbegin(), m_index.cend());
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::begin() -> iterator
-        {
-            return m_e->begin();
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::end() -> iterator
-        {
-            return m_e->end();
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::begin() const -> const_iterator
-        {
-            return m_e->cbegin();
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::end() const -> const_iterator
-        {
-            return m_e->cend();
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::cbegin() const -> const_iterator
-        {
-            return m_e->cbegin();
-        }
-
-        template <class CT>
-        inline auto flat_expression_adaptor<CT>::cend() const ->const_iterator
-        {
-            return m_e->cend();
-        }
-    }
-
-    /**********************************
-     * Builder helpers implementation *
-     **********************************/
-
-    namespace detail
-    {
-        template <class S>
-        struct slice_getter_impl
-        {
-            const S& m_shape;
-            mutable std::size_t idx;
-            using array_type = std::array<std::ptrdiff_t, 3>;
-
-            explicit slice_getter_impl(const S& shape)
-                : m_shape(shape), idx(0)
-            {
-            }
-
-            template <class T>
-            array_type operator()(const T& /*t*/) const
-            {
-                return array_type{{0, 0, 0}};
-            }
-
-            template <class A, class B, class C>
-            array_type operator()(const xrange_adaptor<A, B, C>& range) const
-            {
-                auto sl = range.get(static_cast<std::size_t>(m_shape[idx]));
-                return array_type({sl(0), sl.size(), sl.step_size()});
-            }
-
-            template <class T>
-            array_type operator()(const xrange<T>& range) const
-            {
-                return array_type({ range(T(0)), range.size(), T(1) });
-            }
-
-            template <class T>
-            array_type operator()(const xstepped_range<T>& range) const
-            {
-                return array_type({ range(T(0)), range.size(), range.step_size(T(0)) });
-            }
-        };
-
-        template <class adj_strides_policy>
-        struct strided_view_args : adj_strides_policy
-        {
-            using base_type = adj_strides_policy;
-
-            template <class S, class ST, class V>
-            void fill_args(const S& shape, ST&& old_strides, std::size_t base_offset, layout_type layout, const V& slices)
-            {
-                // Compute dimension
-                std::size_t dimension = shape.size(), n_newaxis = 0, n_add_all = 0;
-                std::ptrdiff_t dimension_check = static_cast<std::ptrdiff_t>(shape.size());
-
-                bool has_ellipsis = false;
-                for (const auto& el : slices)
-                {
-                    if (xtl::get_if<xt::xnewaxis_tag>(&el) != nullptr)
-                    {
-                        ++dimension;
-                        ++n_newaxis;
-                    }
-                    else if (xtl::get_if<std::ptrdiff_t>(&el) != nullptr)
-                    {
-                        --dimension;
-                        --dimension_check;
-                    }
-                    else if (xtl::get_if<xt::xellipsis_tag>(&el) != nullptr)
-                    {
-                        if (has_ellipsis == true)
-                        {
-                            throw std::runtime_error("Ellipsis can only appear once.");
-                        }
-                        has_ellipsis = true;
-                    }
-                    else
-                    {
-                        --dimension_check;
-                    }
-                }
-
-                if (dimension_check < 0)
-                {
-                    throw std::runtime_error("Too many slices for view.");
-                }
-
-                if (has_ellipsis)
-                {
-                    // replace ellipsis with N * xt::all
-                    // remove -1 because of the ellipsis slize itself
-                    n_add_all = shape.size() - (slices.size() - 1 - n_newaxis);
-                }
-
-                // Compute strided view
-                new_offset = base_offset;
-                new_shape.resize(dimension);
-                new_strides.resize(dimension);
-                base_type::resize(dimension);
-
-                auto old_shape = shape;
-                using old_strides_vt = std::decay_t<decltype(old_strides[0])>;
-
-                std::ptrdiff_t axis_skip = 0;
-                std::size_t idx = 0, i = 0, i_ax = 0;
-
-                auto slice_getter = detail::slice_getter_impl<S>(shape);
-
-                for (; i < slices.size(); ++i)
-                {
-                    i_ax = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(i) - axis_skip);
-                    auto ptr = xtl::get_if<std::ptrdiff_t>(&slices[i]);
-                    if (ptr != nullptr)
-                    {
-                        auto slice0 = static_cast<old_strides_vt>(*ptr);
-                        new_offset += static_cast<std::size_t>(slice0 * old_strides[i_ax]);
-                    }
-                    else if (xtl::get_if<xt::xnewaxis_tag>(&slices[i]) != nullptr)
-                    {
-                        new_shape[idx] = 1;
-                        base_type::set_fake_slice(idx);
-                        ++axis_skip, ++idx;
-                    }
-                    else if (xtl::get_if<xt::xellipsis_tag>(&slices[i]) != nullptr)
-                    {
-                        for (std::size_t j = 0; j < n_add_all; ++j)
-                        {
-                            new_shape[idx] = old_shape[i_ax];
-                            new_strides[idx] = old_strides[i_ax];
-                            base_type::set_fake_slice(idx);
-                            ++idx, ++i_ax;
-                        }
-                        axis_skip = axis_skip - static_cast<std::ptrdiff_t>(n_add_all) + 1;
-                    }
-                    else if (xtl::get_if<xt::xall_tag>(&slices[i]) != nullptr)
-                    {
-                        new_shape[idx] = old_shape[i_ax];
-                        new_strides[idx] = old_strides[i_ax];
-                        base_type::set_fake_slice(idx);
-                        ++idx;
-                    }
-                    else if (base_type::fill_args(slices, i, idx,
-                                                  old_shape[i_ax],
-                                                  old_strides[i_ax],
-                                                  new_shape, new_strides))
-                    {
-                        ++idx;
-                    }
-                    else
-                    {
-                        slice_getter.idx = i_ax;
-                        auto info = xtl::visit(slice_getter, slices[i]);
-                        new_offset += static_cast<std::size_t>(info[0] * old_strides[i_ax]);
-                        new_shape[idx] = static_cast<std::size_t>(info[1]);
-                        new_strides[idx] = info[2] * old_strides[i_ax];
-                        base_type::set_fake_slice(idx);
-                        ++idx;
-                    }
-                }
-
-                i_ax = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(i) - axis_skip);
-                for (; i_ax < old_shape.size(); ++i_ax, ++idx)
-                {
-                    new_shape[idx] = old_shape[i_ax];
-                    new_strides[idx] = old_strides[i_ax];
-                    base_type::set_fake_slice(idx);
-                }
-
-                new_layout = do_strides_match(new_shape, new_strides, layout) ? layout : layout_type::dynamic;
-            }
-
-            using shape_type = dynamic_shape<std::size_t>;
-            shape_type new_shape;
-            using strides_type = dynamic_shape<std::ptrdiff_t>;
-            strides_type new_strides;
-            std::size_t new_offset;
-            layout_type new_layout;
-        };
-    }
-}
-
-#endif
diff --git a/include/xtensor/xstrides.hpp b/include/xtensor/xstrides.hpp
deleted file mode 100644
index 5ff82bca5..000000000
--- a/include/xtensor/xstrides.hpp
+++ /dev/null
@@ -1,535 +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 XTENSOR_STRIDES_HPP
-#define XTENSOR_STRIDES_HPP
-
-#include <cstddef>
-#include <functional>
-#include <numeric>
-
-#include "xexception.hpp"
-#include "xtensor_forward.hpp"
-
-namespace xt
-{
-
-    template <class shape_type>
-    std::size_t compute_size(const shape_type& shape) noexcept;
-
-    /***************
-     * data offset *
-     ***************/
-
-    template <class offset_type, class S>
-    offset_type data_offset(const S& strides) noexcept;
-
-    template <class offset_type, class S, class Arg, class... Args>
-    offset_type data_offset(const S& strides, Arg arg, Args... args) noexcept;
-
-    template <class offset_type, layout_type L = layout_type::dynamic, class S, class... Args>
-    offset_type unchecked_data_offset(const S& strides, Args... args) noexcept;
-
-    template <class offset_type, class S, class It>
-    offset_type element_offset(const S& strides, It first, It last) noexcept;
-
-    /*******************
-     * strides builder *
-     *******************/
-
-    template <layout_type L = layout_type::dynamic, class shape_type, class strides_type>
-    std::size_t compute_strides(const shape_type& shape, layout_type l, strides_type& strides);
-
-    template <layout_type L = layout_type::dynamic, class shape_type, class strides_type, class backstrides_type>
-    std::size_t compute_strides(const shape_type& shape, layout_type l,
-                                strides_type& strides, backstrides_type& backstrides);
-
-    template <class shape_type, class strides_type>
-    void adapt_strides(const shape_type& shape, strides_type& strides) noexcept;
-
-    template <class shape_type, class strides_type, class backstrides_type>
-    void adapt_strides(const shape_type& shape, strides_type& strides,
-                       backstrides_type& backstrides) noexcept;
-
-    /*****************
-     * unravel_index *
-     *****************/
-
-    template <class S>
-    S unravel_from_strides(typename S::value_type index, const S& strides, layout_type l);
-
-    template <class S>
-    get_strides_t<S> unravel_index(typename S::value_type index, const S& shape, layout_type l);
-
-    /***********************
-     * broadcast functions *
-     ***********************/
-
-    template <class S1, class S2>
-    bool broadcast_shape(const S1& input, S2& output);
-
-    template <class S1, class S2>
-    bool broadcastable(const S1& s1, S2& s2);
-
-    /*************************
-     * check strides overlap *
-     *************************/
-
-    template <layout_type L>
-    struct check_strides_overlap;
-
-    /********************************************
-     * utility functions for strided containers *
-     ********************************************/
-
-    template <class C, class It>
-    It strided_data_end(const C& c, It end, layout_type l)
-    {
-        using difference_type = typename std::iterator_traits<It>::difference_type;
-        if (c.dimension() == 0)
-        {
-            return end;
-        }
-        else
-        {
-            auto leading_stride = (l == layout_type::row_major ? c.strides().back() : c.strides().front());
-            return end + difference_type(leading_stride - 1);
-        }
-    }
-
-    /******************
-     * Implementation *
-     ******************/
-
-    namespace detail
-    {
-        template <class shape_type>
-        inline std::size_t compute_size_impl(const shape_type& shape, std::true_type /* is signed */) {
-            using size_type = std::decay_t<typename shape_type::value_type>;
-            return static_cast<std::size_t>(std::abs(std::accumulate(shape.cbegin(), shape.cend(), size_type(1), std::multiplies<size_type>())));
-        }
-
-        template <class shape_type>
-        inline std::size_t compute_size_impl(const shape_type& shape, std::false_type /* is not signed */) {
-            using size_type = std::decay_t<typename shape_type::value_type>;
-            return static_cast<std::size_t>(std::accumulate(shape.cbegin(), shape.cend(), size_type(1), std::multiplies<size_type>()));
-        }
-    }
-
-    template <class shape_type>
-    inline std::size_t compute_size(const shape_type& shape) noexcept
-    {
-        return detail::compute_size_impl(shape, std::is_signed<std::decay_t<typename std::decay_t<shape_type>::value_type>>());
-    }
-
-    namespace detail
-    {
-        template <std::size_t dim, class S>
-        inline auto raw_data_offset(const S&) noexcept
-        {
-            using strides_value_type = std::decay_t<decltype(std::declval<S>()[0])>;
-            return strides_value_type(0);
-        }
-
-        template <std::size_t dim, class S, class Arg, class... Args>
-        inline auto raw_data_offset(const S& strides, Arg arg, Args... args) noexcept
-        {
-            return arg * strides[dim] + raw_data_offset<dim + 1>(strides, args...);
-        }
-
-        template <layout_type L, std::ptrdiff_t static_dim>
-        struct layout_data_offset
-        {
-            template <std::size_t dim, class S, class Arg, class... Args>
-            static inline auto run(const S& strides, Arg arg, Args... args) noexcept
-            {
-                return raw_data_offset<dim>(strides, arg, args...);
-            }
-        };
-
-        template <std::ptrdiff_t static_dim>
-        struct layout_data_offset<layout_type::row_major, static_dim>
-        {
-            using self_type = layout_data_offset<layout_type::row_major, static_dim>;
-
-            template <std::size_t dim, class S, class Arg>
-            static inline auto run(const S& strides, Arg arg) noexcept
-            {
-                if (std::ptrdiff_t(dim) + 1 == static_dim)
-                {
-                    return arg;
-                }
-                else
-                {
-                    return arg * strides[dim];
-                }
-            }
-
-            template <std::size_t dim, class S, class Arg, class... Args>
-            static inline auto run(const S& strides, Arg arg, Args... args) noexcept
-            {
-                return arg * strides[dim] + self_type::template run<dim + 1>(strides, args...);
-            }
-        };
-
-        template <std::ptrdiff_t static_dim>
-        struct layout_data_offset<layout_type::column_major, static_dim>
-        {
-            using self_type = layout_data_offset<layout_type::column_major, static_dim>;
-
-            template <std::size_t dim, class S, class Arg>
-            static inline auto run(const S& strides, Arg arg) noexcept
-            {
-                if (dim == 0)
-                {
-                    return arg;
-                }
-                else
-                {
-                    return arg * strides[dim];
-                }
-            }
-
-            template <std::size_t dim, class S, class Arg, class... Args>
-            static inline auto run(const S& strides, Arg arg, Args... args) noexcept
-            {
-                if (dim == 0)
-                {
-                    return arg + self_type::template run<dim + 1>(strides, args...);
-                }
-                else
-                {
-                    return arg * strides[dim] + self_type::template run<dim + 1>(strides, args...);
-                }
-            }
-        };
-    }
-
-    template <class offset_type, class S>
-    inline offset_type data_offset(const S&) noexcept
-    {
-        return offset_type(0);
-    }
-
-    template <class offset_type, class S, class Arg, class... Args>
-    inline offset_type data_offset(const S& strides, Arg arg, Args... args) noexcept
-    {
-        constexpr std::size_t nargs = sizeof...(Args) + 1;
-        if (nargs == strides.size())
-        {
-            // Correct number of arguments: iterate
-            return static_cast<offset_type>(detail::raw_data_offset<0>(strides, arg, args...));
-        }
-        else if (nargs > strides.size())
-        {
-            // Too many arguments: drop the first
-            return data_offset<offset_type, S>(strides, args...);
-        }
-        else
-        {
-            // Too few arguments: right to left scalar product
-            auto view = strides.cend() - nargs;
-            return static_cast<offset_type>(detail::raw_data_offset<0>(view, arg, args...));
-        }
-    }
-
-    template <class offset_type, layout_type L, class S, class... Args>
-    inline offset_type unchecked_data_offset(const S& strides, Args... args) noexcept
-    {
-        return static_cast<offset_type>(detail::layout_data_offset<L, static_dimension<S>::value>::template run<0>(strides.cbegin(), args...));
-    }
-
-    template <class offset_type, class S, class It>
-    inline offset_type element_offset(const S& strides, It first, It last) noexcept
-    {
-        using difference_type = typename std::iterator_traits<It>::difference_type;
-        auto size = static_cast<difference_type>((std::min)(static_cast<typename S::size_type>(std::distance(first, last)), strides.size()));
-        return std::inner_product(last - size, last, strides.cend() - size, offset_type(0));
-    }
-
-    namespace detail
-    {
-        template <class shape_type, class strides_type, class bs_ptr>
-        inline void adapt_strides(const shape_type& shape, strides_type& strides,
-                                  bs_ptr backstrides, typename strides_type::size_type i) noexcept
-        {
-            if (shape[i] == 1)
-            {
-                strides[i] = 0;
-            }
-            (*backstrides)[i] = strides[i] * std::ptrdiff_t(shape[i] - 1);
-        }
-
-        template <class shape_type, class strides_type>
-        inline void adapt_strides(const shape_type& shape, strides_type& strides,
-                                  std::nullptr_t, typename strides_type::size_type i) noexcept
-        {
-            if (shape[i] == 1)
-            {
-                strides[i] = 0;
-            }
-        }
-
-        template <layout_type L, class shape_type, class strides_type, class bs_ptr>
-        inline std::size_t compute_strides(const shape_type& shape, layout_type l,
-                                           strides_type& strides, bs_ptr bs)
-        {
-            using strides_value_type = std::decay_t<decltype(strides[0])>;
-            strides_value_type data_size = 1;
-            if (L == layout_type::row_major || l == layout_type::row_major)
-            {
-                for (std::size_t i = shape.size(); i != 0; --i)
-                {
-                    strides[i - 1] = data_size;
-                    data_size = strides[i - 1] * static_cast<strides_value_type>(shape[i - 1]);
-                    adapt_strides(shape, strides, bs, i - 1);
-                }
-            }
-            else
-            {
-                for (std::size_t i = 0; i < shape.size(); ++i)
-                {
-                    strides[i] = data_size;
-                    data_size = strides[i] * static_cast<strides_value_type>(shape[i]);
-                    adapt_strides(shape, strides, bs, i);
-                }
-            }
-            return static_cast<std::size_t>(data_size);
-        }
-    }
-
-    template <layout_type L, class shape_type, class strides_type>
-    inline std::size_t compute_strides(const shape_type& shape, layout_type l, strides_type& strides)
-    {
-        return detail::compute_strides<L>(shape, l, strides, nullptr);
-    }
-
-    template <layout_type L, class shape_type, class strides_type, class backstrides_type>
-    inline std::size_t compute_strides(const shape_type& shape, layout_type l,
-                                       strides_type& strides,
-                                       backstrides_type& backstrides)
-    {
-        return detail::compute_strides<L>(shape, l, strides, &backstrides);
-    }
-
-    template <class shape_type, class strides_type>
-    inline bool do_strides_match(const shape_type& shape, const strides_type& strides, layout_type l)
-    {
-        using value_type = typename strides_type::value_type;
-        value_type data_size = 1;
-        if (l == layout_type::row_major)
-        {
-            for (std::size_t i = strides.size(); i != 0; --i)
-            {
-                if ((shape[i - 1] == 1 && strides[i - 1] != 0) || (shape[i - 1] != 1 && strides[i - 1] != data_size))
-                {
-                    return false;
-                }
-                data_size *= static_cast<value_type>(shape[i - 1]);
-            }
-            return true;
-        }
-        else if (l == layout_type::column_major)
-        {
-            for (std::size_t i = 0; i < strides.size(); ++i)
-            {
-                if ((shape[i] != 1 && strides[i] != data_size) || (shape[i] == 1 && strides[i] != 0))
-                {
-                    return false;
-                }
-                data_size *= static_cast<value_type>(shape[i]);
-            }
-            return true;
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    template <class shape_type, class strides_type>
-    inline void adapt_strides(const shape_type& shape, strides_type& strides) noexcept
-    {
-        for (typename shape_type::size_type i = 0; i < shape.size(); ++i)
-        {
-            detail::adapt_strides(shape, strides, nullptr, i);
-        }
-    }
-
-    template <class shape_type, class strides_type, class backstrides_type>
-    inline void adapt_strides(const shape_type& shape, strides_type& strides,
-                              backstrides_type& backstrides) noexcept
-    {
-        for (typename shape_type::size_type i = 0; i < shape.size(); ++i)
-        {
-            detail::adapt_strides(shape, strides, &backstrides, i);
-        }
-    }
-
-    namespace detail
-    {
-        template <class S>
-        inline S unravel_noexcept(typename S::value_type idx, const S& strides, layout_type l) noexcept
-        {
-            using value_type = typename S::value_type;
-            using size_type = typename S::size_type;
-            S result = xtl::make_sequence<S>(strides.size(), 0);
-            if (l == layout_type::row_major)
-            {
-                for (size_type i = 0; i < strides.size(); ++i)
-                {
-                    value_type str = strides[i];
-                    value_type quot = str != 0 ? idx / str : 0;
-                    idx = str != 0 ? idx % str : idx;
-                    result[i] = quot;
-                }
-            }
-            else
-            {
-                for (size_type i = strides.size(); i != 0; --i)
-                {
-                    value_type str = strides[i - 1];
-                    value_type quot = str != 0 ? idx / str : 0;
-                    idx = str != 0 ? idx % str : idx;
-                    result[i - 1] = quot;
-                }
-            }
-            return result;
-        }
-    }
-
-    template <class S>
-    inline S unravel_from_strides(typename S::value_type index, const S& strides, layout_type l)
-    {
-        if (l != layout_type::row_major && l != layout_type::column_major)
-        {
-            throw std::runtime_error("unravel_index: dynamic layout not supported");
-        }
-        return detail::unravel_noexcept(index, strides, l);
-    }
-
-    template <class S>
-    inline get_strides_t<S> unravel_index(typename S::value_type index, const S& shape, layout_type l)
-    {
-        get_strides_t<S> strides = xtl::make_sequence<get_strides_t<S>>(shape.size(), 0);
-        using strides_value_type = std::decay_t<decltype(strides[0])>;
-        compute_strides(shape, l, strides);
-        return unravel_from_strides(static_cast<strides_value_type>(index), strides, l);
-    }
-
-    template <class S1, class S2>
-    inline bool broadcast_shape(const S1& input, S2& output)
-    {
-        bool trivial_broadcast = (input.size() == output.size());
-        // Indices are faster than reverse iterators
-        using value_type = typename S2::value_type;
-        auto output_index = output.size();
-        auto input_index = input.size();
-
-        if (output_index < input_index)
-        {
-            throw_broadcast_error(output, input);
-        }
-        for (; input_index != 0; --input_index, --output_index)
-        {
-            // First case: output = (0, 0, ...., 0)
-            // output is a new shape that has not been through
-            // the broadcast process yet; broadcast is trivial
-            if (output[output_index - 1] == 0)
-            {
-                output[output_index - 1] = static_cast<value_type>(input[input_index - 1]);
-            }
-            // Second case: output has been initialized to 1. Broacast is trivial
-            // only if input is 1 to.
-            else if (output[output_index - 1] == 1)
-            {
-                output[output_index - 1] = static_cast<value_type>(input[input_index - 1]);
-                trivial_broadcast = trivial_broadcast && (input[input_index - 1] == 1);
-            }
-            // Third case: output has been initialized to something different from 1.
-            // if input is 1, then the broadcast is not trivial
-            else if (input[input_index - 1] == 1)
-            {
-                trivial_broadcast = false;
-            }
-            // Last case: input and output must have the same value, else
-            // shape are not compatible and an exception is thrown
-            else if (static_cast<value_type>(input[input_index - 1]) != output[output_index - 1])
-            {
-                throw_broadcast_error(output, input);
-            }
-        }
-        return trivial_broadcast;
-    }
-
-    template <class S1, class S2>
-    inline bool broadcastable(const S1& src_shape, const S2& dst_shape)
-    {
-        auto src_iter = src_shape.crbegin();
-        auto dst_iter = dst_shape.crbegin();
-        bool res = dst_shape.size() >= src_shape.size();
-        for (; src_iter != src_shape.crend() && res; ++src_iter, ++dst_iter)
-        {
-            res = (static_cast<std::size_t>(*src_iter) == static_cast<std::size_t>(*dst_iter)) || (*src_iter == 1);
-        }
-        return res;
-    }
-
-    template <>
-    struct check_strides_overlap<layout_type::row_major>
-    {
-        template <class S1, class S2>
-        static std::size_t get(const S1& s1, const S2& s2)
-        {
-            using value_type = typename S1::value_type;
-            // Indices are faster than reverse iterators
-            auto s1_index = s1.size();
-            auto s2_index = s2.size();
-
-            for (; s2_index != 0; --s1_index, --s2_index)
-            {
-                if (static_cast<value_type>(s1[s1_index - 1]) != static_cast<value_type>(s2[s2_index - 1]))
-                {
-                    break;
-                }
-            }
-            return s1_index;
-        }
-    };
-
-    template <>
-    struct check_strides_overlap<layout_type::column_major>
-    {
-        template <class S1, class S2>
-        static std::size_t get(const S1& s1, const S2& s2)
-        {
-            // Indices are faster than reverse iterators
-            using size_type = typename S1::size_type;
-            using value_type = typename S1::value_type;
-            size_type index = 0;
-
-            // This check is necessary as column major "broadcasting" is still
-            // peformed in a row major fashion
-            if (s1.size() != s2.size())
-                return 0;
-
-            auto size = s2.size();
-
-            for (; index < size; ++index)
-            {
-                if (static_cast<value_type>(s1[index]) != static_cast<value_type>(s2[index]))
-                {
-                    break;
-                }
-            }
-            return index;
-        }
-    };
-}
-
-#endif
diff --git a/include/xtensor/xtensor.hpp b/include/xtensor/xtensor.hpp
deleted file mode 100644
index 69ed86a7b..000000000
--- a/include/xtensor/xtensor.hpp
+++ /dev/null
@@ -1,523 +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 XTENSOR_TENSOR_HPP
-#define XTENSOR_TENSOR_HPP
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <utility>
-#include <vector>
-
-#include "xbuffer_adaptor.hpp"
-#include "xcontainer.hpp"
-#include "xsemantic.hpp"
-
-namespace xt
-{
-
-    /***********************
-     * xtensor declaration *
-     ***********************/
-
-    namespace extension
-    {
-        template <class EC, std::size_t N, layout_type L, class Tag>
-        struct xtensor_container_base;
-
-        template <class EC, std::size_t N, layout_type L>
-        struct xtensor_container_base<EC, N, L, xtensor_expression_tag>
-        {
-            using type = xtensor_empty_base;
-        };
-
-        template <class EC, std::size_t N, layout_type L, class Tag>
-        using xtensor_container_base_t = typename xtensor_container_base<EC, N, L, Tag>::type;
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    struct xcontainer_inner_types<xtensor_container<EC, N, L, Tag>>
-    {
-        using storage_type = EC;
-        using shape_type = std::array<typename storage_type::size_type, N>;
-        using strides_type = get_strides_t<shape_type>;
-        using backstrides_type = get_strides_t<shape_type>;
-        using inner_shape_type = shape_type;
-        using inner_strides_type = strides_type;
-        using inner_backstrides_type = backstrides_type;
-        using temporary_type = xtensor_container<EC, N, L, Tag>;
-        static constexpr layout_type layout = L;
-    };
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    struct xiterable_inner_types<xtensor_container<EC, N, L, Tag>>
-        : xcontainer_iterable_types<xtensor_container<EC, N, L, Tag>>
-    {
-    };
-
-    /**
-     * @class xtensor_container
-     * @brief Dense multidimensional container with tensor semantic and fixed
-     * dimension.
-     *
-     * The xtensor_container class implements a dense multidimensional container
-     * with tensor semantic and fixed dimension
-     *
-     * @tparam EC The type of the container holding the elements.
-     * @tparam N The dimension of the container.
-     * @tparam L The layout_type of the tensor.
-     * @tparam Tag The expression tag.
-     * @sa xtensor
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    class xtensor_container : public xstrided_container<xtensor_container<EC, N, L, Tag>>,
-                              public xcontainer_semantic<xtensor_container<EC, N, L, Tag>>,
-                              public extension::xtensor_container_base_t<EC, N, L, Tag>
-    {
-    public:
-
-        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;
-
-        xtensor_container();
-        xtensor_container(nested_initializer_list_t<value_type, N> t);
-        explicit xtensor_container(const shape_type& shape, layout_type l = L);
-        explicit xtensor_container(const shape_type& shape, const_reference value, layout_type l = L);
-        explicit xtensor_container(const shape_type& shape, const strides_type& strides);
-        explicit xtensor_container(const shape_type& shape, const strides_type& strides, const_reference value);
-        explicit xtensor_container(storage_type&& storage, inner_shape_type&& shape, inner_strides_type&& strides);
-
-        template <class S = shape_type>
-        static xtensor_container from_shape(S&& s);
-
-        ~xtensor_container() = default;
-
-        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>
-        explicit xtensor_container(xarray_container<EC, L, SC, Tag>&&);
-        template <class SC>
-        xtensor_container& operator=(xarray_container<EC, L, SC, Tag>&&);
-
-        template <class E>
-        xtensor_container(const xexpression<E>& e);
-
-        template <class E>
-        xtensor_container& operator=(const xexpression<E>& e);
-
-    private:
-
-        storage_type m_storage;
-
-        storage_type& storage_impl() noexcept;
-        const storage_type& storage_impl() const noexcept;
-
-        friend class xcontainer<xtensor_container<EC, N, L, Tag>>;
-    };
-
-    /*****************************************
-     * xtensor_container_adaptor declaration *
-     *****************************************/
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    struct xcontainer_inner_types<xtensor_adaptor<EC, N, L, Tag>>
-    {
-        using storage_type = std::remove_reference_t<EC>;
-        using shape_type = std::array<typename storage_type::size_type, N>;
-        using strides_type = get_strides_t<shape_type>;
-        using backstrides_type = get_strides_t<shape_type>;
-        using inner_shape_type = shape_type;
-        using inner_strides_type = strides_type;
-        using inner_backstrides_type = backstrides_type;
-        using temporary_type = xtensor_container<temporary_container_t<storage_type>, N, L, Tag>;
-        static constexpr layout_type layout = L;
-    };
-
-    template <class EC, std::size_t N, layout_type L>
-    struct xiterable_inner_types<xtensor_adaptor<EC, N, L>>
-        : xcontainer_iterable_types<xtensor_adaptor<EC, N, L>>
-    {
-    };
-
-    /**
-     * @class xtensor_adaptor
-     * @brief Dense multidimensional container adaptor with tensor semantic
-     * and fixed dimension.
-     *
-     * The xtensor_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.
-     *
-     * @tparam EC The closure for the container type to adapt.
-     * @tparam N The dimension of the adaptor.
-     * @tparam L The layout_type of the adaptor.
-     * @tparam Tag The expression tag.
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    class xtensor_adaptor : public xstrided_container<xtensor_adaptor<EC, N, L, Tag>>,
-                            public xcontainer_semantic<xtensor_adaptor<EC, N, L, Tag>>
-    {
-    public:
-
-        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 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;
-
-        xtensor_adaptor(storage_type&& storage);
-        xtensor_adaptor(const storage_type& storage);
-
-        template <class D>
-        xtensor_adaptor(D&& storage, const shape_type& shape, layout_type l = L);
-
-        template <class D>
-        xtensor_adaptor(D&& storage, const shape_type& shape, const strides_type& strides);
-
-        ~xtensor_adaptor() = default;
-
-        xtensor_adaptor(const xtensor_adaptor&) = default;
-        xtensor_adaptor& operator=(const xtensor_adaptor&);
-
-        xtensor_adaptor(xtensor_adaptor&&) = default;
-        xtensor_adaptor& operator=(xtensor_adaptor&&);
-        xtensor_adaptor& operator=(temporary_type&&);
-
-        template <class E>
-        xtensor_adaptor& operator=(const xexpression<E>& e);
-
-    private:
-
-        container_closure_type m_storage;
-
-        storage_type& storage_impl() noexcept;
-        const storage_type& storage_impl() const noexcept;
-
-        friend class xcontainer<xtensor_adaptor<EC, N, L, Tag>>;
-    };
-
-    /************************************
-     * xtensor_container implementation *
-     ************************************/
-
-    /**
-     * @name Constructors
-     */
-    //@{
-    /**
-     * Allocates an uninitialized xtensor_container that holds 0 element.
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container()
-        : base_type(), m_storage(N == 0 ? 1 : 0, value_type())
-    {
-    }
-
-    /**
-     * Allocates an xtensor_container with nested initializer lists.
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(nested_initializer_list_t<value_type, N> t)
-        : base_type()
-    {
-        base_type::resize(xt::shape<shape_type>(t), true);
-        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
-    }
-
-    /**
-     * Allocates an uninitialized xtensor_container with the specified shape and
-     * layout_type.
-     * @param shape the shape of the xtensor_container
-     * @param l the layout_type of the xtensor_container
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const shape_type& shape, layout_type l)
-        : base_type()
-    {
-        base_type::resize(shape, l);
-    }
-
-    /**
-     * Allocates an xtensor_container with the specified shape and layout_type. Elements
-     * are initialized to the specified value.
-     * @param shape the shape of the xtensor_container
-     * @param value the value of the elements
-     * @param l the layout_type of the xtensor_container
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const shape_type& shape, const_reference value, layout_type l)
-        : base_type()
-    {
-        base_type::resize(shape, l);
-        std::fill(m_storage.begin(), m_storage.end(), value);
-    }
-
-    /**
-     * Allocates an uninitialized xtensor_container with the specified shape and strides.
-     * @param shape the shape of the xtensor_container
-     * @param strides the strides of the xtensor_container
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const shape_type& shape, const strides_type& strides)
-        : base_type()
-    {
-        base_type::resize(shape, strides);
-    }
-
-    /**
-     * Allocates an uninitialized xtensor_container with the specified shape and strides.
-     * Elements are initialized to the specified value.
-     * @param shape the shape of the xtensor_container
-     * @param strides the strides of the xtensor_container
-     * @param value the value of the elements
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const shape_type& shape, const strides_type& strides, const_reference value)
-        : base_type()
-    {
-        base_type::resize(shape, strides);
-        std::fill(m_storage.begin(), m_storage.end(), value);
-    }
-
-    /**
-     * Allocates an xtensor_container by moving specified data, shape and strides
-     *
-     * @param storage the data for the xtensor_container
-     * @param shape the shape of the xtensor_container
-     * @param strides the strides of the xtensor_container
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(storage_type&& storage, inner_shape_type&& shape, inner_strides_type&& strides)
-        : base_type(std::move(shape), std::move(strides)), m_storage(std::move(storage))
-    {
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class SC>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(xarray_container<EC, L, SC, Tag>&& rhs)
-        : base_type(xtl::forward_sequence<inner_shape_type>(rhs.shape()),
-                    xtl::forward_sequence<inner_strides_type>(rhs.strides()),
-                    xtl::forward_sequence<inner_backstrides_type>(rhs.backstrides()),
-                    std::move(rhs.layout())),
-          m_storage(std::move(rhs.storage()))
-    {
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class SC>
-    inline xtensor_container<EC, N, L, Tag>& xtensor_container<EC, N, L, Tag>::operator=(xarray_container<EC, L, SC, Tag>&& rhs)
-    {
-        XTENSOR_ASSERT_MSG(N == rhs.dimension(), "Cannot change dimension of xtensor.");
-        std::copy(rhs.shape().begin(), rhs.shape().end(), this->shape_impl().begin());
-        std::copy(rhs.strides().cbegin(), rhs.strides().cend(), this->strides_impl().begin());
-        std::copy(rhs.backstrides().cbegin(), rhs.backstrides().cend(), this->backstrides_impl().begin());
-        this->mutable_layout() = std::move(rhs.layout());
-        m_storage = std::move(std::move(rhs.storage()));
-        return *this;
-    }
-
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class S>
-    inline xtensor_container<EC, N, L, Tag> xtensor_container<EC, N, L, Tag>::from_shape(S&& s)
-    {
-        XTENSOR_ASSERT_MSG(s.size() == N, "Cannot change dimension of xtensor.");
-        shape_type shape = xtl::forward_sequence<shape_type>(s);
-        return self_type(shape);
-    }
-    //@}
-
-    /**
-     * @name Extended copy semantic
-     */
-    //@{
-    /**
-     * The extended copy constructor.
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class E>
-    inline xtensor_container<EC, N, L, Tag>::xtensor_container(const xexpression<E>& e)
-        : base_type()
-    {
-        XTENSOR_ASSERT_MSG(N == e.derived_cast().dimension(), "Cannot change dimension of xtensor.");
-        // Avoids unintialized data because of (m_shape == shape) condition
-        // in resize (called by assign), which is always true when dimension() == 0.
-        if (e.derived_cast().dimension() == 0)
-        {
-            detail::resize_data_container(m_storage, std::size_t(1));
-        }
-        semantic_base::assign(e);
-    }
-
-    /**
-     * The extended assignment operator.
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class E>
-    inline auto xtensor_container<EC, N, L, Tag>::operator=(const xexpression<E>& e) -> self_type&
-    {
-        return semantic_base::operator=(e);
-    }
-    //@}
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline auto xtensor_container<EC, N, L, Tag>::storage_impl() noexcept -> storage_type&
-    {
-        return m_storage;
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline auto xtensor_container<EC, N, L, Tag>::storage_impl() const noexcept -> const storage_type&
-    {
-        return m_storage;
-    }
-
-    /*******************
-     * xtensor_adaptor *
-     *******************/
-
-    /**
-     * @name Constructors
-     */
-    //@{
-    /**
-     * Constructs an xtensor_adaptor of the given stl-like container.
-     * @param storage the container to adapt
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(storage_type&& storage)
-        : base_type(), m_storage(std::move(storage))
-    {
-    }
-
-    /**
-     * Constructs an xtensor_adaptor of the given stl-like container.
-     * @param storage the container to adapt
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(const storage_type& storage)
-        : base_type(), m_storage(storage)
-    {
-    }
-
-    /**
-     * Constructs an xtensor_adaptor of the given stl-like container,
-     * with the specified shape and layout_type.
-     * @param storage the container to adapt
-     * @param shape the shape of the xtensor_adaptor
-     * @param l the layout_type of the xtensor_adaptor
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class D>
-    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(D&& storage, const shape_type& shape, layout_type l)
-        : base_type(), m_storage(std::forward<D>(storage))
-    {
-        base_type::resize(shape, l);
-    }
-
-    /**
-     * Constructs an xtensor_adaptor of the given stl-like container,
-     * with the specified shape and strides.
-     * @param storage the container to adapt
-     * @param shape the shape of the xtensor_adaptor
-     * @param strides the strides of the xtensor_adaptor
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class D>
-    inline xtensor_adaptor<EC, N, L, Tag>::xtensor_adaptor(D&& storage, const shape_type& shape, const strides_type& strides)
-        : base_type(), m_storage(std::forward<D>(storage))
-    {
-        base_type::resize(shape, strides);
-    }
-    //@}
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(const xtensor_adaptor& rhs) -> self_type&
-    {
-        base_type::operator=(rhs);
-        m_storage = rhs.m_storage;
-        return *this;
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(xtensor_adaptor&& rhs) -> self_type&
-    {
-        base_type::operator=(std::move(rhs));
-        m_storage = rhs.m_storage;
-        return *this;
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(temporary_type&& rhs) -> self_type&
-    {
-        base_type::shape_impl() = std::move(const_cast<shape_type&>(rhs.shape()));
-        base_type::strides_impl() = std::move(const_cast<strides_type&>(rhs.strides()));
-        base_type::backstrides_impl() = std::move(const_cast<backstrides_type&>(rhs.backstrides()));
-        m_storage = std::move(rhs.storage());
-        return *this;
-    }
-
-    /**
-     * @name Extended copy semantic
-     */
-    //@{
-    /**
-     * The extended assignment operator.
-     */
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    template <class E>
-    inline auto xtensor_adaptor<EC, N, L, Tag>::operator=(const xexpression<E>& e) -> self_type&
-    {
-        return semantic_base::operator=(e);
-    }
-    //@}
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline auto xtensor_adaptor<EC, N, L, Tag>::storage_impl() noexcept -> storage_type&
-    {
-        return m_storage;
-    }
-
-    template <class EC, std::size_t N, layout_type L, class Tag>
-    inline auto xtensor_adaptor<EC, N, L, Tag>::storage_impl() const noexcept -> const storage_type&
-    {
-        return m_storage;
-    }
-}
-
-#endif
diff --git a/include/xtensor/xtensor_config.hpp b/include/xtensor/xtensor_config.hpp
deleted file mode 100644
index 0ae209eb4..000000000
--- a/include/xtensor/xtensor_config.hpp
+++ /dev/null
@@ -1,78 +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 XTENSOR_CONFIG_HPP
-#define XTENSOR_CONFIG_HPP
-
-#define XTENSOR_VERSION_MAJOR 0
-#define XTENSOR_VERSION_MINOR 18
-#define XTENSOR_VERSION_PATCH 2
-
-// DETECT 3.6 <= clang < 3.8 for compiler bug workaround.
-#ifdef __clang__
-    #if __clang_major__ == 3 && __clang_minor__ < 8
-        #define X_OLD_CLANG
-        #include <initializer_list>
-        #include <vector>
-    #endif
-#endif
-
-// Workaround for some missing constexpr functionality in MSVC 2015 and MSVC 2017 x86
-#if defined(_MSC_VER)
-    #define XTENSOR_CONSTEXPR_ENHANCED const
-    // The following must not be defined to const, otherwise
-    // it prevents generation of copy operators of classes
-    // containing XTENSOR_CONSTEXPR_ENHANCED_STATIC members
-    #define XTENSOR_CONSTEXPR_ENHANCED_STATIC
-    #define XTENSOR_CONSTEXPR_RETURN inline
-#else
-    #define XTENSOR_CONSTEXPR_ENHANCED constexpr
-    #define XTENSOR_CONSTEXPR_RETURN constexpr
-    #define XTENSOR_CONSTEXPR_ENHANCED_STATIC constexpr static
-    #define XTENSOR_HAS_CONSTEXPR_ENHANCED
-#endif
-
-#ifndef XTENSOR_DEFAULT_DATA_CONTAINER
-#define XTENSOR_DEFAULT_DATA_CONTAINER(T, A) uvector<T, A>
-#endif
-
-#ifndef XTENSOR_DEFAULT_SHAPE_CONTAINER
-#define XTENSOR_DEFAULT_SHAPE_CONTAINER(T, EA, SA) \
-    xt::svector<typename XTENSOR_DEFAULT_DATA_CONTAINER(T, EA)::size_type, 4, SA>
-#endif
-
-#ifndef XTENSOR_DEFAULT_ALLOCATOR
-#ifdef XTENSOR_ALLOC_TRACKING
-    #ifndef XTENSOR_ALLOC_TRACKING_POLICY
-        #define XTENSOR_ALLOC_TRACKING_POLICY xt::alloc_tracking::policy::print
-    #endif
-    #ifdef XTENSOR_USE_XSIMD
-        #include <xsimd/xsimd.hpp>
-        #define XTENSOR_DEFAULT_ALLOCATOR(T) \
-            xt::tracking_allocator<T, xsimd::aligned_allocator<T, XSIMD_DEFAULT_ALIGNMENT>, XTENSOR_ALLOC_TRACKING_POLICY>
-    #else
-        #define XTENSOR_DEFAULT_ALLOCATOR(T) \
-            xt::tracking_allocator<T, std::allocator<T>, XTENSOR_ALLOC_TRACKING_POLICY>
-    #endif
-#else
-    #ifdef XTENSOR_USE_XSIMD
-    #include <xsimd/xsimd.hpp>
-    #define XTENSOR_DEFAULT_ALLOCATOR(T) \
-        xsimd::aligned_allocator<T, XSIMD_DEFAULT_ALIGNMENT>
-    #else
-    #define XTENSOR_DEFAULT_ALLOCATOR(T) \
-        std::allocator<T>
-    #endif
-#endif
-#endif
-
-#ifndef XTENSOR_DEFAULT_LAYOUT
-#define XTENSOR_DEFAULT_LAYOUT ::xt::layout_type::row_major
-#endif
-
-#endif
diff --git a/include/xtensor/xtensor_simd.hpp b/include/xtensor/xtensor_simd.hpp
deleted file mode 100644
index 087e66e74..000000000
--- a/include/xtensor/xtensor_simd.hpp
+++ /dev/null
@@ -1,188 +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 XTENSOR_SIMD_HPP
-#define XTENSOR_SIMD_HPP
-
-#include <vector>
-
-#include "xstorage.hpp"
-#include "xutils.hpp"
-
-#ifdef XTENSOR_USE_XSIMD
-
-#include <xsimd/xsimd.hpp>
-
-#else  // XTENSOR_USE_XSIMD
-
-namespace xsimd
-{
-    template <class T, std::size_t A>
-    class aligned_allocator;
-
-    struct aligned_mode
-    {
-    };
-
-    struct unaligned_mode
-    {
-    };
-
-    template <class A>
-    struct allocator_alignment
-    {
-        using type = unaligned_mode;
-    };
-
-    template <class A>
-    using allocator_alignment_t = typename allocator_alignment<A>::type;
-
-    template <class C>
-    struct container_alignment
-    {
-        using type = unaligned_mode;
-    };
-
-    template <class C>
-    using container_alignment_t = typename container_alignment<C>::type;
-
-    template <class T>
-    struct simd_traits
-    {
-        using type = T;
-        using bool_type = bool;
-        using batch_bool = bool;
-        static constexpr std::size_t size = 1;
-    };
-
-    template <class T>
-    struct revert_simd_traits
-    {
-        using type = T;
-        static constexpr std::size_t size = simd_traits<type>::size;
-    };
-
-    template <class T>
-    using simd_type = typename simd_traits<T>::type;
-
-    template <class T>
-    using simd_bool_type = typename simd_traits<T>::bool_type;
-
-    template <class T>
-    using revert_simd_type = typename revert_simd_traits<T>::type;
-
-    template <class T, class V>
-    inline simd_type<T> set_simd(const T& value)
-    {
-        return value;
-    }
-
-    template <class T, class V>
-    inline simd_type<T> load_simd(const T* src, aligned_mode)
-    {
-        return *src;
-    }
-
-    template <class T, class V>
-    inline simd_type<T> load_simd(const T* src, unaligned_mode)
-    {
-        return *src;
-    }
-
-    template <class T>
-    inline void store_simd(T* dst, const simd_type<T>& src, aligned_mode)
-    {
-        *dst = src;
-    }
-
-    template <class T>
-    inline void store_simd(T* dst, const simd_type<T>& src, unaligned_mode)
-    {
-        *dst = src;
-    }
-
-    template <class T>
-    inline T select(bool cond, const T& t1, const T& t2)
-    {
-        return cond ? t1 : t2;
-    }
-
-    template <class T>
-    inline std::size_t get_alignment_offset(const T* /*p*/, std::size_t size, std::size_t /*block_size*/)
-    {
-        return size;
-    }
-
-    template <class T1, class T2>
-    using simd_return_type = simd_type<T2>;
-
-    template <class V>
-    struct is_batch_bool : std::false_type
-    {
-    };
-
-    template <class V>
-    struct is_batch_complex : std::false_type
-    {
-    };
-}
-
-#endif  // XTENSOR_USE_XSIMD
-
-namespace xt
-{
-    using xsimd::aligned_mode;
-    using xsimd::unaligned_mode;
-
-    struct inner_aligned_mode
-    {
-    };
-
-    namespace detail
-    {
-        template <class A1, class A2>
-        struct driven_align_mode_impl
-        {
-            using type = std::conditional_t<std::is_same<A1, A2>::value, A1, ::xsimd::unaligned_mode>;
-        };
-
-        template <class A>
-        struct driven_align_mode_impl<inner_aligned_mode, A>
-        {
-            using type = A;
-        };
-    }
-
-    template <class A1, class A2>
-    struct driven_align_mode
-    {
-        using type = typename detail::driven_align_mode_impl<A1, A2>::type;
-    };
-
-    template <class A1, class A2>
-    using driven_align_mode_t = typename detail::driven_align_mode_impl<A1, A2>::type;
-
-    template <class E, class = void>
-    struct test_simd_interface_impl : std::false_type
-    {
-    };
-
-    template <class E>
-    struct test_simd_interface_impl<E, void_t<decltype(std::declval<E>().template load_simd<aligned_mode>(typename E::size_type(0)))>>
-        : std::true_type
-    {
-    };
-
-    template <class E>
-    struct has_simd_interface
-        : test_simd_interface_impl<E>
-    {
-    };
-}
-
-#endif
diff --git a/include/xtensor/xutils.hpp b/include/xtensor/xutils.hpp
deleted file mode 100644
index be8b64daa..000000000
--- a/include/xtensor/xutils.hpp
+++ /dev/null
@@ -1,1199 +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 XTENSOR_UTILS_HPP
-#define XTENSOR_UTILS_HPP
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <complex>
-#include <cstddef>
-#include <initializer_list>
-#include <iostream>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include <xtl/xfunctional.hpp>
-#include <xtl/xsequence.hpp>
-#include <xtl/xmeta_utils.hpp>
-#include <xtl/xtype_traits.hpp>
-
-#include "xtensor_config.hpp"
-
-namespace xt
-{
-    /****************
-     * declarations *
-     ****************/
-
-    template <class T>
-    struct remove_class;
-
-    template <class F, class... T>
-    void for_each(F&& f, std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()));
-
-    template <class F, class R, class... T>
-    R accumulate(F&& f, R init, const std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()));
-
-    template <std::size_t I, class... Args>
-    constexpr decltype(auto) argument(Args&&... args) noexcept;
-
-    template <class R, class F, class... S>
-    R apply(std::size_t index, F&& func, const std::tuple<S...>& s) noexcept(noexcept(std::declval<F>()));
-
-    template <class T, class S>
-    void nested_copy(T&& iter, const S& s);
-
-    template <class T, class S>
-    void nested_copy(T&& iter, std::initializer_list<S> s);
-
-    template <class U>
-    struct initializer_dimension;
-
-    template <class R, class T>
-    constexpr R shape(T t);
-
-    template <class T, class S>
-    constexpr bool check_shape(T t, S first, S last);
-
-    template <class C>
-    bool resize_container(C& c, typename C::size_type size);
-
-    template <class T, std::size_t N>
-    bool resize_container(std::array<T, N>& a, typename std::array<T, N>::size_type size);
-
-    template <std::size_t... I>
-    class fixed_shape;
-
-    template <std::size_t... I>
-    bool resize_container(fixed_shape<I...>& a, std::size_t size);
-
-    template <class X, class C>
-    struct rebind_container;
-
-    template <class X, class C>
-    using rebind_container_t = typename rebind_container<X, C>::type;
-
-    std::size_t normalize_axis(std::size_t dim, std::ptrdiff_t axis);
-
-    template <class S1, class S2>
-    inline bool same_shape(const S1& s1, const S2& s2) noexcept;
-
-    // gcc 4.9 is affected by C++14 defect CGW 1558
-    // see http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
-    template <class... T>
-    struct make_void
-    {
-        using type = void;
-    };
-
-    template <class... T>
-    using void_t = typename make_void<T...>::type;
-
-    // This is used for non existant types (e.g. storage for some expressions
-    // like generators)
-    struct invalid_type
-    {
-    };
-
-    template <class... T>
-    struct make_invalid_type
-    {
-        using type = invalid_type;
-    };
-
-    template <class T, class R>
-    using disable_integral_t = std::enable_if_t<!std::is_integral<T>::value, R>;
-
-    /*******************************
-     * remove_class implementation *
-     *******************************/
-
-    template <class T>
-    struct remove_class
-    {
-    };
-
-    template <class C, class R, class... Args>
-    struct remove_class<R (C::*)(Args...)>
-    {
-        typedef R type(Args...);
-    };
-
-    template <class C, class R, class... Args>
-    struct remove_class<R (C::*)(Args...) const>
-    {
-        typedef R type(Args...);
-    };
-
-    template <class T>
-    using remove_class_t = typename remove_class<T>::type;
-
-    /***************************
-     * for_each implementation *
-     ***************************/
-
-    namespace detail
-    {
-        template <std::size_t I, class F, class... T>
-        inline typename std::enable_if<I == sizeof...(T), void>::type
-        for_each_impl(F&& /*f*/, std::tuple<T...>& /*t*/) noexcept(noexcept(std::declval<F>()))
-        {
-        }
-
-        template <std::size_t I, class F, class... T>
-        inline typename std::enable_if<I < sizeof...(T), void>::type
-        for_each_impl(F&& f, std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()))
-        {
-            f(std::get<I>(t));
-            for_each_impl<I + 1, F, T...>(std::forward<F>(f), t);
-        }
-    }
-
-    template <class F, class... T>
-    inline void for_each(F&& f, std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()))
-    {
-        detail::for_each_impl<0, F, T...>(std::forward<F>(f), t);
-    }
-
-    namespace detail
-    {
-        template <std::size_t I, class F, class... T>
-        inline typename std::enable_if<I == sizeof...(T), void>::type
-        for_each_impl(F&& /*f*/, const std::tuple<T...>& /*t*/) noexcept(noexcept(std::declval<F>()))
-        {
-        }
-
-        template <std::size_t I, class F, class... T>
-        inline typename std::enable_if<I < sizeof...(T), void>::type
-        for_each_impl(F&& f, const std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()))
-        {
-            f(std::get<I>(t));
-            for_each_impl<I + 1, F, T...>(std::forward<F>(f), t);
-        }
-    }
-
-    template <class F, class... T>
-    inline void for_each(F&& f, const std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()))
-    {
-        detail::for_each_impl<0, F, T...>(std::forward<F>(f), t);
-    }
-
-    /*****************************
-     * accumulate implementation *
-     *****************************/
-
-    namespace detail
-    {
-        template <std::size_t I, class F, class R, class... T>
-        inline std::enable_if_t<I == sizeof...(T), R>
-        accumulate_impl(F&& /*f*/, R init, const std::tuple<T...>& /*t*/) noexcept(noexcept(std::declval<F>()))
-        {
-            return init;
-        }
-
-        template <std::size_t I, class F, class R, class... T>
-        inline std::enable_if_t<I < sizeof...(T), R>
-        accumulate_impl(F&& f, R init, const std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()))
-        {
-            R res = f(init, std::get<I>(t));
-            return accumulate_impl<I + 1, F, R, T...>(std::forward<F>(f), res, t);
-        }
-    }
-
-    template <class F, class R, class... T>
-    inline R accumulate(F&& f, R init, const std::tuple<T...>& t) noexcept(noexcept(std::declval<F>()))
-    {
-        return detail::accumulate_impl<0, F, R, T...>(std::forward<F>(f), init, t);
-    }
-
-    /***************************
-     * argument implementation *
-     ***************************/
-
-    namespace detail
-    {
-        template <std::size_t I>
-        struct getter
-        {
-            template <class Arg, class... Args>
-            static constexpr decltype(auto) get(Arg&& /*arg*/, Args&&... args) noexcept
-            {
-                return getter<I - 1>::get(std::forward<Args>(args)...);
-            }
-        };
-
-        template <>
-        struct getter<0>
-        {
-            template <class Arg, class... Args>
-            static constexpr Arg&& get(Arg&& arg, Args&&... /*args*/) noexcept
-            {
-                return std::forward<Arg>(arg);
-            }
-        };
-    }
-
-    template <std::size_t I, class... Args>
-    constexpr decltype(auto) argument(Args&&... args) noexcept
-    {
-        static_assert(I < sizeof...(Args), "I should be lesser than sizeof...(Args)");
-        return detail::getter<I>::get(std::forward<Args>(args)...);
-    }
-
-    /************************
-     * apply implementation *
-     ************************/
-
-    namespace detail
-    {
-        template <class R, class F, std::size_t I, class... S>
-        R apply_one(F&& func, const std::tuple<S...>& s) noexcept(noexcept(std::declval<F>()))
-        {
-            return static_cast<R>(func(std::get<I>(s)));
-        }
-
-        template <class R, class F, std::size_t... I, class... S>
-        R apply(std::size_t index, F&& func, std::index_sequence<I...> /*seq*/, const std::tuple<S...>& s) noexcept(noexcept(std::declval<F>()))
-        {
-            using FT = std::add_pointer_t<R(F&&, const std::tuple<S...>&)>;
-            static const std::array<FT, sizeof...(I)> ar = {{&apply_one<R, F, I, S...>...}};
-            return ar[index](std::forward<F>(func), s);
-        }
-    }
-
-    template <class R, class F, class... S>
-    inline R apply(std::size_t index, F&& func, const std::tuple<S...>& s) noexcept(noexcept(std::declval<F>()))
-    {
-        return detail::apply<R>(index, std::forward<F>(func), std::make_index_sequence<sizeof...(S)>(), s);
-    }
-
-    /***************************
-     * nested_initializer_list *
-     ***************************/
-
-    template <class T, std::size_t I>
-    struct nested_initializer_list
-    {
-        using type = std::initializer_list<typename nested_initializer_list<T, I - 1>::type>;
-    };
-
-    template <class T>
-    struct nested_initializer_list<T, 0>
-    {
-        using type = T;
-    };
-
-    template <class T, std::size_t I>
-    using nested_initializer_list_t = typename nested_initializer_list<T, I>::type;
-
-    /******************************
-     * nested_copy implementation *
-     ******************************/
-
-    template <class T, class S>
-    inline void nested_copy(T&& iter, const S& s)
-    {
-        *iter++ = s;
-    }
-
-    template <class T, class S>
-    inline void nested_copy(T&& iter, std::initializer_list<S> s)
-    {
-        for (auto it = s.begin(); it != s.end(); ++it)
-        {
-            nested_copy(std::forward<T>(iter), *it);
-        }
-    }
-
-    /****************************************
-     * initializer_dimension implementation *
-     ****************************************/
-
-    namespace detail
-    {
-        template <class U>
-        struct initializer_depth_impl
-        {
-            static constexpr std::size_t value = 0;
-        };
-
-        template <class T>
-        struct initializer_depth_impl<std::initializer_list<T>>
-        {
-            static constexpr std::size_t value = 1 + initializer_depth_impl<T>::value;
-        };
-    }
-
-    template <class U>
-    struct initializer_dimension
-    {
-        static constexpr std::size_t value = detail::initializer_depth_impl<U>::value;
-    };
-
-    /************************************
-     * initializer_shape implementation *
-     ************************************/
-
-    namespace detail
-    {
-        template <std::size_t I>
-        struct initializer_shape_impl
-        {
-            template <class T>
-            static constexpr std::size_t value(T t)
-            {
-                return t.size() == 0 ? 0 : initializer_shape_impl<I - 1>::value(*t.begin());
-            }
-        };
-
-        template <>
-        struct initializer_shape_impl<0>
-        {
-            template <class T>
-            static constexpr std::size_t value(T t)
-            {
-                return t.size();
-            }
-        };
-
-        template <class R, class U, std::size_t... I>
-        constexpr R initializer_shape(U t, std::index_sequence<I...>)
-        {
-            using size_type = typename R::value_type;
-            return {size_type(initializer_shape_impl<I>::value(t))...};
-        }
-    }
-
-    template <class R, class T>
-    constexpr R shape(T t)
-    {
-        return detail::initializer_shape<R, decltype(t)>(t, std::make_index_sequence<initializer_dimension<decltype(t)>::value>());
-    }
-
-    /******************************
-     * check_shape implementation *
-     ******************************/
-
-    namespace detail
-    {
-        template <class T, class S>
-        struct predshape
-        {
-            constexpr predshape(S first, S last)
-                : m_first(first), m_last(last)
-            {
-            }
-
-            constexpr bool operator()(const T&) const
-            {
-                return m_first == m_last;
-            }
-
-            S m_first;
-            S m_last;
-        };
-
-        template <class T, class S>
-        struct predshape<std::initializer_list<T>, S>
-        {
-            constexpr predshape(S first, S last)
-                : m_first(first), m_last(last)
-            {
-            }
-
-            constexpr bool operator()(std::initializer_list<T> t) const
-            {
-                return *m_first == t.size() && std::all_of(t.begin(), t.end(), predshape<T, S>(m_first + 1, m_last));
-            }
-
-            S m_first;
-            S m_last;
-        };
-    }
-
-    template <class T, class S>
-    constexpr bool check_shape(T t, S first, S last)
-    {
-        return detail::predshape<decltype(t), S>(first, last)(t);
-    }
-
-    /***********************************
-     * resize_container implementation *
-     ***********************************/
-
-    template <class C>
-    inline bool resize_container(C& c, typename C::size_type size)
-    {
-        c.resize(size);
-        return true;
-    }
-
-    template <class T, std::size_t N>
-    inline bool resize_container(std::array<T, N>& /*a*/, typename std::array<T, N>::size_type size)
-    {
-        return size == N;
-    }
-
-    template <std::size_t... I>
-    inline bool resize_container(xt::fixed_shape<I...>&, std::size_t size)
-    {
-        return sizeof...(I) == size;
-    }
-
-    /*********************************
-     * normalize_axis implementation *
-     *********************************/
-
-
-    // scalar normalize axis
-    inline std::size_t normalize_axis(std::size_t dim, std::ptrdiff_t axis)
-    {
-        return axis < 0 ? static_cast<std::size_t>(static_cast<std::ptrdiff_t>(dim) + axis) : static_cast<std::size_t>(axis);
-    }
-
-    template <class E, class C>
-    inline std::enable_if_t<!std::is_integral<std::decay_t<C>>::value &&
-                     std::is_signed<typename std::decay_t<C>::value_type>::value,
-                     rebind_container_t<std::size_t, std::decay_t<C>>>
-    normalize_axis(E& expr, C&& axes)
-    {
-        rebind_container_t<std::size_t, std::decay_t<C>> res;
-        resize_container(res, axes.size());
-
-        for (std::size_t i = 0; i < axes.size(); ++i)
-        {
-            res[i] = normalize_axis(expr.dimension(), axes[i]);
-        }
-
-        XTENSOR_ASSERT(std::all_of(res.begin(), res.end(), [&expr](auto ax_el) { return ax_el < expr.dimension(); }));
-
-        return res;
-    }
-
-    template <class C, class E>
-    inline std::enable_if_t<!std::is_integral<std::decay_t<C>>::value && std::is_unsigned<typename std::decay_t<C>::value_type>::value, C&&>
-    normalize_axis(E& expr, C&& axes)
-    {
-        static_cast<void>(expr);
-        XTENSOR_ASSERT(std::all_of(axes.begin(), axes.end(), [&expr](auto ax_el) { return ax_el < expr.dimension(); }));
-        return std::forward<C>(axes);
-    }
-
-    template <class R, class E, class C>
-    inline auto forward_normalize(E& expr, C&& axes)
-        -> std::enable_if_t<std::is_signed<std::decay_t<decltype(*std::begin(axes))>>::value, R>
-    {
-        R res;
-        xt::resize_container(res, xtl::sequence_size(axes));
-        auto dim = expr.dimension();
-        std::transform(std::begin(axes), std::end(axes), std::begin(res), [&dim](auto ax_el) {
-            return normalize_axis(dim, ax_el);
-        });
-
-        XTENSOR_ASSERT(std::all_of(res.begin(), res.end(), [&expr](auto ax_el) { return ax_el < expr.dimension(); }));
-
-        return res;
-    }
-
-    template <class R, class E, class C>
-    inline auto forward_normalize(E& expr, C&& axes)
-        -> std::enable_if_t<!std::is_signed<std::decay_t<decltype(*std::begin(axes))>>::value && !std::is_same<R, std::decay_t<C>>::value, R>
-    {
-        static_cast<void>(expr);
-
-        R res;
-        xt::resize_container(res, xtl::sequence_size(axes));
-        std::copy(std::begin(axes), std::end(axes), std::begin(res));
-        XTENSOR_ASSERT(std::all_of(res.begin(), res.end(), [&expr](auto ax_el) { return ax_el < expr.dimension(); }));
-        return res;
-    }
-
-    template <class R, class E, class C>
-    inline auto forward_normalize(E& expr, C&& axes)
-        -> std::enable_if_t<!std::is_signed<std::decay_t<decltype(*std::begin(axes))>>::value && std::is_same<R, std::decay_t<C>>::value, R&&>
-    {
-        static_cast<void>(expr);
-        XTENSOR_ASSERT(std::all_of(std::begin(axes), std::end(axes), [&expr](auto ax_el) { return ax_el < expr.dimension(); }));
-        return std::move(axes);
-    }
-
-    /*****************************
-     * same_shape implementation *
-     *****************************/
-
-    template <class S1, class S2>
-    inline bool same_shape(const S1& s1, const S2& s2) noexcept
-    {
-        return s1.size() == s2.size() && std::equal(s1.begin(), s1.end(), s2.begin());
-    }
-
-
-    /******************
-     * get_value_type *
-     ******************/
-
-    template <class T, class = void_t<>>
-    struct get_value_type
-    {
-        using type = T;
-    };
-
-    template <class T>
-    struct get_value_type<T, void_t<typename T::value_type>>
-    {
-        using type = typename T::value_type;
-    };
-
-    template <class T>
-    using get_value_type_t = typename get_value_type<T>::type;
-
-    /***************************
-     * apply_cv implementation *
-     ***************************/
-
-    namespace detail
-    {
-        template <class T, class U, bool = std::is_const<std::remove_reference_t<T>>::value,
-                  bool = std::is_volatile<std::remove_reference_t<T>>::value>
-        struct apply_cv_impl
-        {
-            using type = U;
-        };
-
-        template <class T, class U>
-        struct apply_cv_impl<T, U, true, false>
-        {
-            using type = const U;
-        };
-
-        template <class T, class U>
-        struct apply_cv_impl<T, U, false, true>
-        {
-            using type = volatile U;
-        };
-
-        template <class T, class U>
-        struct apply_cv_impl<T, U, true, true>
-        {
-            using type = const volatile U;
-        };
-
-        template <class T, class U>
-        struct apply_cv_impl<T&, U, false, false>
-        {
-            using type = U&;
-        };
-
-        template <class T, class U>
-        struct apply_cv_impl<T&, U, true, false>
-        {
-            using type = const U&;
-        };
-
-        template <class T, class U>
-        struct apply_cv_impl<T&, U, false, true>
-        {
-            using type = volatile U&;
-        };
-
-        template <class T, class U>
-        struct apply_cv_impl<T&, U, true, true>
-        {
-            using type = const volatile U&;
-        };
-    }
-
-    template <class T, class U>
-    struct apply_cv
-    {
-        using type = typename detail::apply_cv_impl<T, U>::type;
-    };
-
-    template <class T, class U>
-    using apply_cv_t = typename apply_cv<T, U>::type;
-
-
-    /**************************
-    * to_array implementation *
-    ***************************/
-
-    namespace detail
-    {
-        template <class T, std::size_t N, std::size_t... I>
-        constexpr std::array<std::remove_cv_t<T>, N> to_array_impl(T (&a)[N], std::index_sequence<I...>)
-        {
-            return {{a[I]...}};
-        }
-    }
-
-    template <class T, std::size_t N>
-    constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N])
-    {
-        return detail::to_array_impl(a, std::make_index_sequence<N>{});
-    }
-
-    /********************************
-     * sequence_size implementation *
-     ********************************/
-
-    // equivalent to std::size(c) in c++17
-    template <class C>
-    constexpr auto sequence_size(const C& c) -> decltype(c.size())
-    {
-        return c.size();
-    }
-
-    // equivalent to std::size(a) in c++17
-    template <class T, std::size_t N>
-    constexpr std::size_t sequence_size(const T (&)[N])
-    {
-        return N;
-    }
-
-    /*************************************
-     * has_data_interface implementation *
-     *************************************/
-
-    template <class E, class = void>
-    struct has_data_interface : std::false_type
-    {
-    };
-
-    template <class E>
-    struct has_data_interface<E, void_t<decltype(std::declval<E>().data())>>
-        : std::true_type
-    {
-    };
-
-    template <class E, class = void>
-    struct has_strides : std::false_type
-    {
-    };
-
-    template <class E>
-    struct has_strides<E, void_t<decltype(std::declval<E>().strides())>>
-        : std::true_type
-    {
-    };
-
-    /******************
-     * enable_if_type *
-     ******************/
-
-    template <class T>
-    struct enable_if_type
-    {
-        using type = void;
-    };
-
-    /********************************************
-     * xtrivial_default_construct implemenation *
-     ********************************************/
-
-#if !defined(__GNUG__) || defined(_LIBCPP_VERSION) || defined(_GLIBCXX_USE_CXX11_ABI)
-
-    template <class T>
-    using xtrivially_default_constructible = std::is_trivially_default_constructible<T>;
-
-#else
-
-    template <class T>
-    using xtrivially_default_constructible = std::has_trivial_default_constructor<T>;
-
-#endif
-
-    /*************************
-     * conditional type cast *
-     *************************/
-
-    template <bool condition, class T>
-    struct conditional_cast_functor;
-
-    template <class T>
-    struct conditional_cast_functor<false, T> : public xtl::identity
-    {
-    };
-
-    template <class T>
-    struct conditional_cast_functor<true, T>
-    {
-        template <class U>
-        inline auto operator()(U&& u) const
-        {
-            return static_cast<T>(std::forward<U>(u));
-        }
-    };
-
-    /**
-     * @brief Perform a type cast when a condition is true.
-     * If <tt>condition</tt> is true, return <tt>static_cast<T>(u)</tt>,
-     * otherwise return <tt>u</tt> unchanged. This is useful when an unconditional
-     * static_cast would force undesired type conversions in some situations where
-     * an error or warning would be desired. The condition determines when the
-     * explicit cast is ok.
-     */
-    template <bool condition, class T, class U>
-    inline auto conditional_cast(U&& u)
-    {
-        return conditional_cast_functor<condition, T>()(std::forward<U>(u));
-    }
-
-    /************************************
-     * arithmetic type promotion traits *
-     ************************************/
-
-    /**
-     * @brief Traits class for the result type of mixed arithmetic expressions.
-     * For example, <tt>promote_type<unsigned char, unsigned char>::type</tt> tells
-     * the user that <tt>unsigned char + unsigned char => int</tt>.
-     */
-    template <class... T>
-    struct promote_type;
-
-    template <>
-    struct promote_type<>
-    {
-        using type = void;
-    };
-
-    template <class T>
-    struct promote_type<T>
-    {
-        using type = typename promote_type<T, T>::type;
-    };
-
-    template <class T0, class T1>
-    struct promote_type<T0, T1>
-    {
-        using type = decltype(std::declval<std::decay_t<T0>>() + std::declval<std::decay_t<T1>>());
-    };
-
-    template <class T0, class... REST>
-    struct promote_type<T0, REST...>
-    {
-        using type = decltype(std::declval<std::decay_t<T0>>() + std::declval<typename promote_type<REST...>::type>());
-    };
-
-    template <>
-    struct promote_type<bool>
-    {
-        using type = bool;
-    };
-
-    template <class T>
-    struct promote_type<bool, T>
-    {
-        using type = T;
-    };
-
-    template <class... REST>
-    struct promote_type<bool, REST...>
-    {
-        using type = typename promote_type<bool, typename promote_type<REST...>::type>::type;
-    };
-
-    /**
-     * @brief Abbreviation of 'typename promote_type<T>::type'.
-     */
-    template <class... T>
-    using promote_type_t = typename promote_type<T...>::type;
-    /**
-     * @brief Traits class to find the biggest type of the same kind.
-     *
-     * For example, <tt>big_promote_type<unsigned char>::type</tt> is <tt>unsigned long long</tt>.
-     * The default implementation only supports built-in types and <tt>std::complex</tt>. All
-     * other types remain unchanged unless <tt>big_promote_type</tt> gets specialized for them.
-     */
-    template <class T>
-    struct big_promote_type
-    {
-    private:
-
-        using V = std::decay_t<T>;
-        static constexpr bool is_arithmetic = std::is_arithmetic<V>::value;
-        static constexpr bool is_signed = std::is_signed<V>::value;
-        static constexpr bool is_integral = std::is_integral<V>::value;
-        static constexpr bool is_long_double = std::is_same<V, long double>::value;
-
-    public:
-
-        using type = std::conditional_t<is_arithmetic,
-                        std::conditional_t<is_integral,
-                            std::conditional_t<is_signed, long long, unsigned long long>,
-                            std::conditional_t<is_long_double, long double, double>
-                        >,
-                        V
-                     >;
-    };
-
-    template <class T>
-    struct big_promote_type<std::complex<T>>
-    {
-        using type = std::complex<typename big_promote_type<T>::type>;
-    };
-
-    /**
-     * @brief Abbreviation of 'typename big_promote_type<T>::type'.
-     */
-    template <class T>
-    using big_promote_type_t = typename big_promote_type<T>::type;
-
-    namespace traits_detail
-    {
-        using std::sqrt;
-
-        template <class T>
-        using real_promote_type_t = decltype(sqrt(std::declval<std::decay_t<T>>()));
-    }
-
-    /**
-     * @brief Result type of algebraic expressions.
-     *
-     * For example, <tt>real_promote_type<int>::type</tt> tells the
-     * user that <tt>sqrt(int) => double</tt>.
-     */
-    template <class T>
-    struct real_promote_type
-    {
-        using type = traits_detail::real_promote_type_t<T>;
-    };
-
-    /**
-     * @brief Abbreviation of 'typename real_promote_type<T>::type'.
-     */
-    template <class T>
-    using real_promote_type_t = typename real_promote_type<T>::type;
-
-    /**
-     * @brief Traits class to replace 'bool' with 'uint8_t' and keep everything else.
-     *
-     * This is useful for scientific computing, where a boolean mask array is
-     * usually implemented as an array of bytes.
-     */
-    template <class T>
-    struct bool_promote_type
-    {
-        using type = typename std::conditional<std::is_same<T, bool>::value, uint8_t, T>::type;
-    };
-
-    /**
-     * @brief Abbreviation for typename bool_promote_type<T>::type
-     */
-    template <class T>
-    using bool_promote_type_t = typename bool_promote_type<T>::type;
-
-    /********************************************
-     * type inference for norm and squared norm *
-     ********************************************/
-
-    template <class T>
-    struct norm_type;
-
-    template <class T>
-    struct squared_norm_type;
-
-    namespace traits_detail
-    {
-
-        template <class T, bool scalar = std::is_arithmetic<T>::value>
-        struct norm_of_scalar_impl;
-
-        template <class T>
-        struct norm_of_scalar_impl<T, false>
-        {
-            static const bool value = false;
-            using norm_type = void*;
-            using squared_norm_type = void*;
-        };
-
-        template <class T>
-        struct norm_of_scalar_impl<T, true>
-        {
-            static const bool value = true;
-            using norm_type = promote_type_t<T>;
-            using squared_norm_type = promote_type_t<T>;
-        };
-
-        template <class T, bool integral = std::is_integral<T>::value,
-                  bool floating = std::is_floating_point<T>::value>
-        struct norm_of_array_elements_impl;
-
-        template <>
-        struct norm_of_array_elements_impl<void*, false, false>
-        {
-            using norm_type = void*;
-            using squared_norm_type = void*;
-        };
-
-        template <class T>
-        struct norm_of_array_elements_impl<T, false, false>
-        {
-            using norm_type = typename norm_type<T>::type;
-            using squared_norm_type = typename squared_norm_type<T>::type;
-        };
-
-        template <class T>
-        struct norm_of_array_elements_impl<T, true, false>
-        {
-            static_assert(!std::is_same<T, char>::value,
-                          "'char' is not a numeric type, use 'signed char' or 'unsigned char'.");
-
-            using norm_type = double;
-            using squared_norm_type = uint64_t;
-        };
-
-        template <class T>
-        struct norm_of_array_elements_impl<T, false, true>
-        {
-            using norm_type = double;
-            using squared_norm_type = double;
-        };
-
-        template <>
-        struct norm_of_array_elements_impl<long double, false, true>
-        {
-            using norm_type = long double;
-            using squared_norm_type = long double;
-        };
-
-        template <class ARRAY>
-        struct norm_of_vector_impl
-        {
-            static void* test(...);
-
-            template <class U>
-            static typename U::value_type test(U*, typename U::value_type* = 0);
-
-            using T = decltype(test(std::declval<ARRAY*>()));
-
-            static const bool value = !std::is_same<T, void*>::value;
-
-            using norm_type = typename norm_of_array_elements_impl<T>::norm_type;
-            using squared_norm_type = typename norm_of_array_elements_impl<T>::squared_norm_type;
-        };
-
-        template <class U>
-        struct norm_type_base
-        {
-            using T = std::decay_t<U>;
-
-            static_assert(!std::is_same<T, char>::value,
-                          "'char' is not a numeric type, use 'signed char' or 'unsigned char'.");
-
-            using norm_of_scalar = norm_of_scalar_impl<T>;
-            using norm_of_vector = norm_of_vector_impl<T>;
-
-            static const bool value = norm_of_scalar::value || norm_of_vector::value;
-
-            static_assert(value, "norm_type<T> are undefined for type U.");
-        };
-    }  // namespace traits_detail
-
-    /**
-     * @brief Traits class for the result type of the <tt>norm_l2()</tt> function.
-     *
-     * Member 'type' defines the result of <tt>norm_l2(t)</tt>, where <tt>t</tt>
-     * is of type @tparam T. It implements the following rules designed to
-     * minimize the potential for overflow:
-     *   - @tparam T is an arithmetic type: 'type' is the result type of <tt>abs(t)</tt>.
-     *   - @tparam T is a container of 'long double' elements: 'type' is <tt>long double</tt>.
-     *   - @tparam T is a container of another arithmetic type: 'type' is <tt>double</tt>.
-     *   - @tparam T is a container of some other type: 'type' is the element's norm type,
-     *
-     * Containers are recognized by having an embedded typedef 'value_type'.
-     * To change the behavior for a case not covered here, specialize the
-     * <tt>traits_detail::norm_type_base</tt> template.
-     */
-    template <class T>
-    struct norm_type
-        : public traits_detail::norm_type_base<T>
-    {
-        using base_type = traits_detail::norm_type_base<T>;
-
-        using type =
-            typename std::conditional<base_type::norm_of_vector::value,
-                                      typename base_type::norm_of_vector::norm_type,
-                                      typename base_type::norm_of_scalar::norm_type>::type;
-    };
-
-    /**
-     * Abbreviation of 'typename norm_type<T>::type'.
-     */
-    template <class T>
-    using norm_type_t = typename norm_type<T>::type;
-
-    /**
-     * @brief Traits class for the result type of the <tt>norm_sq()</tt> function.
-     *
-     * Member 'type' defines the result of <tt>norm_sq(t)</tt>, where <tt>t</tt>
-     * is of type @tparam T. It implements the following rules designed to
-     * minimize the potential for overflow:
-     *   - @tparam T is an arithmetic type: 'type' is the result type of <tt>t*t</tt>.
-     *   - @tparam T is a container of 'long double' elements: 'type' is <tt>long double</tt>.
-     *   - @tparam T is a container of another floating-point type: 'type' is <tt>double</tt>.
-     *   - @tparam T is a container of integer elements: 'type' is <tt>uint64_t</tt>.
-     *   - @tparam T is a container of some other type: 'type' is the element's squared norm type,
-     *
-     *  Containers are recognized by having an embedded typedef 'value_type'.
-     *  To change the behavior for a case not covered here, specialize the
-     *  <tt>traits_detail::norm_type_base</tt> template.
-     */
-    template <class T>
-    struct squared_norm_type
-        : public traits_detail::norm_type_base<T>
-    {
-        using base_type = traits_detail::norm_type_base<T>;
-
-        using type =
-            typename std::conditional<base_type::norm_of_vector::value,
-                                      typename base_type::norm_of_vector::squared_norm_type,
-                                      typename base_type::norm_of_scalar::squared_norm_type>::type;
-    };
-
-    /**
-     * Abbreviation of 'typename squared_norm_type<T>::type'.
-     */
-    template <class T>
-    using squared_norm_type_t = typename squared_norm_type<T>::type;
-
-    namespace alloc_tracking
-    {
-        inline bool& enabled()
-        {
-            static bool enabled;
-            return enabled;
-        }
-
-        inline void enable()
-        {
-            enabled() = true;
-        }
-
-        inline void disable()
-        {
-            enabled() = false;
-        }
-
-        enum policy
-        {
-            print,
-            assert
-        };
-    }
-
-    template <class T, class A, alloc_tracking::policy P>
-    struct tracking_allocator
-        : private A
-    {
-        using base_type = A;
-        using value_type = typename A::value_type;
-        using reference = typename A::reference;
-        using const_reference = typename A::const_reference;
-        using pointer = typename A::pointer;
-        using const_pointer = typename A::const_pointer;
-        using size_type = typename A::size_type;
-        using difference_type = typename A::difference_type;
-
-        tracking_allocator() = default;
-
-        T* allocate(std::size_t n)
-        {
-            if (alloc_tracking::enabled())
-            {
-                if (P == alloc_tracking::print)
-                {
-                    std::cout << "xtensor allocating: " << n << "" << std::endl;
-                }
-                else if (P == alloc_tracking::assert)
-                {
-                    throw std::runtime_error("xtensor allocation of " + std::to_string(n) + " elements detected");
-                }
-            }
-            return base_type::allocate(n);
-        }
-
-        using base_type::deallocate;
-        using base_type::construct;
-        using base_type::destroy;
-
-        template <class U>
-        struct rebind
-        {
-            using other = tracking_allocator<U, typename A::template rebind<U>::other, P>;
-        };
-    };
-
-    template <class T, class AT, alloc_tracking::policy PT, class U, class AU, alloc_tracking::policy PU>
-    inline bool operator==(const tracking_allocator<T, AT, PT>&, const tracking_allocator<U, AU, PU>&)
-    {
-      return std::is_same<AT, AU>::value;
-    }
-
-    template <class T, class AT, alloc_tracking::policy PT, class U, class AU, alloc_tracking::policy PU>
-    inline bool operator!=(const tracking_allocator<T, AT, PT>& a, const tracking_allocator<U, AU, PU>& b)
-    {
-      return !(a == b);
-    }
-
-    template <class E1, class E2, class = void>
-    struct has_assign_to : std::false_type
-    {
-    };
-
-    template <class E1, class E2>
-    struct has_assign_to<E1, E2, void_t<decltype(std::declval<const E2&>().assign_to(std::declval<E1&>()))>>
-        : std::true_type
-    {
-    };
-
-    template <class X, template <class, class> class C, class T, class A>
-    struct rebind_container<X, C<T, A>>
-    {
-        using allocator = typename A::template rebind<X>::other;
-        using type = C<X, allocator>;
-    };
-
-#if defined(__GNUC__) && __GNUC__ > 6 && !defined(__clang__) && __cplusplus >= 201703L
-    template <class X, class T, std::size_t N>
-    struct rebind_container<X, std::array<T, N>>
-    {
-        using type = std::array<X, N>;
-    };
-#else
-    template <class X, template <class, std::size_t> class C, class T, std::size_t N>
-    struct rebind_container<X, C<T, N>>
-    {
-        using type = C<X, N>;
-    };
-#endif
-
-
-    template <class S>
-    struct get_strides_type
-    {
-        using type = typename rebind_container<std::ptrdiff_t, S>::type;
-    };
-
-    template <std::size_t... I>
-    struct get_strides_type<fixed_shape<I...>>
-    {
-        // TODO we could compute the strides statically here.
-        //      But we'll need full constexpr support to have a
-        //      homogenous ``compute_strides`` method
-        using type = std::array<std::ptrdiff_t, sizeof...(I)>;
-    };
-
-    template <class C>
-    using get_strides_t = typename get_strides_type<C>::type;
-}
-
-#endif
diff --git a/notebooks/xtensor.ipynb b/notebooks/xtensor.ipynb
index 4778af91b..08da57dcb 100644
--- a/notebooks/xtensor.ipynb
+++ b/notebooks/xtensor.ipynb
@@ -1,566 +1,424 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# ![xtensor](images/xtensor.png)\n",
-    "\n",
-    "<center>Multi-dimensional arrays with broadcasting and lazy computing.</center>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Introduction\n",
-    "\n",
-    "`xtensor` is a C++ library meant for numerical analysis with multi-dimensional array expressions.\n",
-    "\n",
-    "`xtensor` provides\n",
-    "\n",
-    " - an extensible expression system enabling **lazy broadcasting**.\n",
-    " - an API following the idioms of the **C++ standard library**.\n",
-    " - tools to manipulate array expressions and build upon `xtensor`.\n",
-    "\n",
-    "The implementation of the containers of `xtensor` is 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).\n",
-    "\n",
-    "`xtensor` requires a modern C++ compiler supporting C++14. The following C+ compilers are supported:\n",
-    "\n",
-    " - On Windows platforms, Visual C++ 2015 Update 2, or more recent\n",
-    " - On Unix platforms, gcc 4.9 or a recent version of Clang"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
-   "source": [
-    "## Usage\n",
-    "\n",
-    "<div style=\"background: #efffed;\n",
-    "            border: 1px solid grey;\n",
-    "            margin: 8px 0 8px 0;\n",
-    "            text-align: center;\n",
-    "            padding: 8px; \">\n",
-    "    <i class=\"fa-play fa\" \n",
-    "       style=\"font-size: 40px;\n",
-    "              line-height: 40px;\n",
-    "              margin: 8px;\n",
-    "              color: #444;\">\n",
-    "    </i>\n",
-    "    <div>\n",
-    "    To run the selected code cell, hit <pre style=\"background: #efffed\">Shift + Enter</pre>\n",
-    "    </div>\n",
-    "</div>\n",
-    "\n",
-    "\n",
-    "### Initialize a 2-D array and compute the sum of one of its rows and a 1-D array"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include <iostream>\n",
-    "\n",
-    "#include \"xtensor/xarray.hpp\"\n",
-    "#include \"xtensor/xio.hpp\"\n",
-    "#include \"xtensor/xview.hpp\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='0'><pre>  7.</pre></td></tr><tr><td style='font-family:monospace;' title='1'><pre> 11.</pre></td></tr><tr><td style='font-family:monospace;' title='2'><pre> 14.</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::xarray<double> arr1\n",
-    "  {{1.0, 2.0, 3.0},\n",
-    "   {2.0, 5.0, 7.0},\n",
-    "   {2.0, 5.0, 7.0}};\n",
-    "\n",
-    "xt::xarray<double> arr2\n",
-    "  {5.0, 6.0, 7.0};\n",
-    "\n",
-    "xt::view(arr1, 1) + arr2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre> 1.</pre></td><td style='font-family:monospace;' title='(0, 1)'><pre> 2.</pre></td><td style='font-family:monospace;' title='(0, 2)'><pre> 3.</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre> 2.</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre> 5.</pre></td><td style='font-family:monospace;' title='(1, 2)'><pre> 7.</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0)'><pre> 2.</pre></td><td style='font-family:monospace;' title='(2, 1)'><pre> 5.</pre></td><td style='font-family:monospace;' title='(2, 2)'><pre> 7.</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "arr1"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Initialize a 1-D array and reshape it inplace"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include <iostream>\n",
-    "#include \"xtensor/xarray.hpp\"\n",
-    "#include \"xtensor/xio.hpp\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre>1</pre></td><td style='font-family:monospace;' title='(0, 1)'><pre>2</pre></td><td style='font-family:monospace;' title='(0, 2)'><pre>3</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre>4</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre>5</pre></td><td style='font-family:monospace;' title='(1, 2)'><pre>6</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0)'><pre>7</pre></td><td style='font-family:monospace;' title='(2, 1)'><pre>8</pre></td><td style='font-family:monospace;' title='(2, 2)'><pre>9</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::xarray<int> arr\n",
-    "  {1, 2, 3, 4, 5, 6, 7, 8, 9};\n",
-    "\n",
-    "arr.reshape({3, 3});\n",
-    "\n",
-    "arr"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Broadcasting the ``xt::pow`` universal functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include <iostream>\n",
-    "#include \"xtensor/xarray.hpp\"\n",
-    "#include \"xtensor/xmath.hpp\"\n",
-    "#include \"xtensor/xio.hpp\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre>    1.</pre></td><td style='font-family:monospace;' title='(0, 1)'><pre>   16.</pre></td><td style='font-family:monospace;' title='(0, 2)'><pre>   81.</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre>    1.</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre>   32.</pre></td><td style='font-family:monospace;' title='(1, 2)'><pre>  243.</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0)'><pre>    1.</pre></td><td style='font-family:monospace;' title='(2, 1)'><pre>   64.</pre></td><td style='font-family:monospace;' title='(2, 2)'><pre>  729.</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0)'><pre>    1.</pre></td><td style='font-family:monospace;' title='(3, 1)'><pre>  128.</pre></td><td style='font-family:monospace;' title='(3, 2)'><pre> 2187.</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::xarray<double> arr3\n",
-    "  {1.0, 2.0, 3.0};\n",
-    "\n",
-    "xt::xarray<unsigned int> arr4\n",
-    "  {4, 5, 6, 7};\n",
-    "\n",
-    "arr4.reshape({4, 1});\n",
-    "\n",
-    "xt::pow(arr3, arr4)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Random arrays with the random module"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include <iostream>\n",
-    "#include \"xtensor/xrandom.hpp\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre> 0.13453 </pre></td><td style='font-family:monospace;' title='(0, 1)'><pre>-0.146382</pre></td><td style='font-family:monospace;' title='(0, 2)'><pre> 0.46065 </pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre>-1.871384</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre> 0.163712</pre></td><td style='font-family:monospace;' title='(1, 2)'><pre>-0.214253</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0)'><pre> 0.298595</pre></td><td style='font-family:monospace;' title='(2, 1)'><pre>-0.827944</pre></td><td style='font-family:monospace;' title='(2, 2)'><pre> 0.010215</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0)'><pre> 1.055466</pre></td><td style='font-family:monospace;' title='(3, 1)'><pre>-0.546841</pre></td><td style='font-family:monospace;' title='(3, 2)'><pre> 1.174568</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::xarray<double> arr5 = xt::random::randn<double>({4, 3});\n",
-    "arr5"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td><table style='border-style:solid;border-width:1px;'><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 1, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 0, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 2, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><center>...</center></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 5, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 0, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 0, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 1, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 0, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 5, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 1, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 1, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(0, 2, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(0, 2, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(0, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(1, 0, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(1, 1, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(1, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><center>...</center></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(1, 0, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 0, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 0, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(1, 1, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 5, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 1, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(1, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 0, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 5, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 2, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(1, 2, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(1, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 0, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 0, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 1, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><center>...</center></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 0, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 1, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr></table></td></tr><tr><td><center>...</center></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 0, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 1, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 2, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><center>...</center></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 0, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 0, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 1, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 1, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 1, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(2, 2, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(2, 2, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(2, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(3, 0, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 0, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(3, 1, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(3, 2, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 7, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><center>...</center></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(3, 0, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 2, 9)'><pre> true</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 5, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 5, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 6, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 0, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(3, 1, 0, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 0, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 0, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 5, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 1, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(3, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(3, 2, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(3, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(4, 0, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 2, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(4, 1, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(4, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><center>...</center></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(4, 0, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 0, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 0, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 0, 7, 9)'><pre> true</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(4, 1, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 1, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 1, 0)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 1, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 1, 1, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 2, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 6, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 6, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 1, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 1, 7, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 1, 7, 9)'><pre>false</pre></td></tr></table></td></tr><tr><td><table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(4, 2, 0, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 0, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 0, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 1, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 1, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 1, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 2, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 2, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 2, 9)'><pre>false</pre></td></tr><tr><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 5, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 1)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 2)'><pre>false</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 5, 7)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 5, 9)'><pre>false</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 6, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 6, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 8)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 2, 6, 9)'><pre> true</pre></td></tr><tr><td style='font-family:monospace;' title='(4, 2, 7, 0)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 1)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 2)'><pre> true</pre></td><td><center>...</center></td><td style='font-family:monospace;' title='(4, 2, 7, 7)'><pre> true</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 8)'><pre>false</pre></td><td style='font-family:monospace;' title='(4, 2, 7, 9)'><pre> true</pre></td></tr></table></td></tr></table></td></tr></table>"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::random::randn<double>({5, 3, 8, 10}) > 0.2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Using `linspace`, `arange`, `ones`, `zeros`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include \"xtensor/xbuilder.hpp\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre>  0.      </pre></td><td style='font-family:monospace;' title='(0, 1)'><pre>  0.909091</pre></td><td style='font-family:monospace;' title='(0, 2)'><pre>  1.818182</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre>  2.727273</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre>  3.636364</pre></td><td style='font-family:monospace;' title='(1, 2)'><pre>  4.545455</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0)'><pre>  5.454545</pre></td><td style='font-family:monospace;' title='(2, 1)'><pre>  6.363636</pre></td><td style='font-family:monospace;' title='(2, 2)'><pre>  7.272727</pre></td></tr><tr><td style='font-family:monospace;' title='(3, 0)'><pre>  8.181818</pre></td><td style='font-family:monospace;' title='(3, 1)'><pre>  9.090909</pre></td><td style='font-family:monospace;' title='(3, 2)'><pre> 10.      </pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::xarray<double> ar = xt::linspace<double>(0.0, 10.0, 12);\n",
-    "ar.reshape({4, 3});\n",
-    "ar"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre> 1.</pre></td><td style='font-family:monospace;' title='(0, 1)'><pre> 1.</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre> 1.</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre> 1.</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::xarray<double> fones = xt::ones<float>({2, 2});\n",
-    "fones"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='0'><pre>         0</pre></td></tr><tr><td style='font-family:monospace;' title='1'><pre>         1</pre></td></tr><tr><td style='font-family:monospace;' title='2'><pre>         2</pre></td></tr><tr><td><center>...</center></td></tr><tr><td style='font-family:monospace;' title='1569325052'><pre>1569325052</pre></td></tr><tr><td style='font-family:monospace;' title='1569325053'><pre>1569325053</pre></td></tr><tr><td style='font-family:monospace;' title='1569325054'><pre>1569325054</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::arange<int>(1569325055)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Using `xt::broadcast`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include <vector>\n",
-    "#include \"xtensor/xbroadcast.hpp\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre> 0.      </pre></td><td style='font-family:monospace;' title='(0, 1)'><pre> 0.      </pre></td><td style='font-family:monospace;' title='(0, 2)'><pre> 0.      </pre></td><td style='font-family:monospace;' title='(0, 3)'><pre> 0.      </pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre> 3.333333</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre> 3.333333</pre></td><td style='font-family:monospace;' title='(1, 2)'><pre> 3.333333</pre></td><td style='font-family:monospace;' title='(1, 3)'><pre> 3.333333</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0)'><pre> 6.666667</pre></td><td style='font-family:monospace;' title='(2, 1)'><pre> 6.666667</pre></td><td style='font-family:monospace;' title='(2, 2)'><pre> 6.666667</pre></td><td style='font-family:monospace;' title='(2, 3)'><pre> 6.666667</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "xt::broadcast(xt::linspace<double>(0.0, 10.0, 4),\n",
-    "              std::vector<std::size_t>({3, 4}))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Using standard algorithms with xexpressions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include <algorithm>"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-2.01197"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<table style='border-style:solid;border-width:1px;'><tr><td style='font-family:monospace;' title='(0, 0)'><pre>-2.339393</pre></td><td style='font-family:monospace;' title='(0, 1)'><pre> 0.747579</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre>-0.307341</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre>-0.112812</pre></td></tr></table>"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# ![xtensor](images/xtensor.png)\n",
+        "\n",
+        "<center>Multi-dimensional arrays with broadcasting and lazy computing.</center>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Introduction\n",
+        "\n",
+        "`xtensor` is a C++ library meant for numerical analysis with multi-dimensional array expressions.\n",
+        "\n",
+        "`xtensor` provides\n",
+        "\n",
+        " - an extensible expression system enabling **lazy broadcasting**.\n",
+        " - an API following the idioms of the **C++ standard library**.\n",
+        " - tools to manipulate array expressions and build upon `xtensor`.\n",
+        "\n",
+        "The implementation of the containers of `xtensor` is 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).\n",
+        "\n",
+        "`xtensor` requires a modern C++ compiler supporting C++14. The following C+ compilers are supported:\n",
+        "\n",
+        " - On Windows platforms, Visual C++ 2015 Update 2, or more recent\n",
+        " - On Unix platforms, gcc 4.9 or a recent version of Clang"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Usage\n",
+        "\n",
+        "<div style=\"background: #efffed;\n",
+        "            border: 1px solid grey;\n",
+        "            margin: 8px 0 8px 0;\n",
+        "            text-align: center;\n",
+        "            padding: 8px; \">\n",
+        "    <i class=\"fa-play fa\" \n",
+        "       style=\"font-size: 40px;\n",
+        "              line-height: 40px;\n",
+        "              margin: 8px;\n",
+        "              color: #444;\">\n",
+        "    </i>\n",
+        "    <div>\n",
+        "    To run the selected code cell, hit <pre style=\"background: #efffed\">Shift + Enter</pre>\n",
+        "    </div>\n",
+        "</div>\n",
+        "\n",
+        "\n",
+        "### Initialize a 2-D array and compute the sum of one of its rows and a 1-D array"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include <iostream>\n",
+        "\n",
+        "#include \"xtensor/xarray.hpp\"\n",
+        "#include \"xtensor/xio.hpp\"\n",
+        "#include \"xtensor/xview.hpp\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<double> arr1\n",
+        "  {{1.0, 2.0, 3.0},\n",
+        "   {2.0, 5.0, 7.0},\n",
+        "   {2.0, 5.0, 7.0}};\n",
+        "\n",
+        "xt::xarray<double> arr2\n",
+        "  {5.0, 6.0, 7.0};\n",
+        "\n",
+        "xt::view(arr1, 1) + arr2"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "arr1"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Initialize a 1-D array and reshape it inplace"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include <iostream>\n",
+        "#include \"xtensor/xarray.hpp\"\n",
+        "#include \"xtensor/xio.hpp\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<int> arr\n",
+        "  {1, 2, 3, 4, 5, 6, 7, 8, 9};\n",
+        "\n",
+        "arr.reshape({3, 3});\n",
+        "\n",
+        "arr"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Broadcasting the ``xt::pow`` universal functions"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include <iostream>\n",
+        "#include \"xtensor/xarray.hpp\"\n",
+        "#include \"xtensor/xmath.hpp\"\n",
+        "#include \"xtensor/xio.hpp\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<double> arr3\n",
+        "  {1.0, 2.0, 3.0};\n",
+        "\n",
+        "xt::xarray<unsigned int> arr4\n",
+        "  {4, 5, 6, 7};\n",
+        "\n",
+        "arr4.reshape({4, 1});\n",
+        "\n",
+        "xt::pow(arr3, arr4)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Random arrays with the random module"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include <iostream>\n",
+        "#include \"xtensor/xrandom.hpp\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<double> arr5 = xt::random::randn<double>({4, 3});\n",
+        "arr5"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "scrolled": true
+      },
+      "outputs": [],
+      "source": [
+        "xt::random::randn<double>({5, 3, 8, 10}) > 0.2"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Using `linspace`, `arange`, `ones`, `zeros`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include \"xtensor/xbuilder.hpp\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<double> ar = xt::linspace<double>(0.0, 10.0, 12);\n",
+        "ar.reshape({4, 3});\n",
+        "ar"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<double> fones = xt::ones<float>({2, 2});\n",
+        "fones"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::arange<int>(1569325055)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Using `xt::broadcast`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include <vector>\n",
+        "#include \"xtensor/xbroadcast.hpp\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::broadcast(xt::linspace<double>(0.0, 10.0, 4),\n",
+        "              std::vector<std::size_t>({3, 4}))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Using standard algorithms with xexpressions"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include <algorithm>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<double> frand = xt::random::randn<double>({2, 2});\n",
+        "\n",
+        "// begin() and end() provide and iterator pair iterating over the xexpression in a row-major fashion\n",
+        "std::cout << std::accumulate(frand.begin(), frand.end(), 0.0);\n",
+        "\n",
+        "frand"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Iterating over a prescribed broadcasted shape"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "// begin(shape) and end(shape) provide and iterator pair iterating\n",
+        "// over the xexpression broadcasted to the prescrived shape in a row-major fashion\n",
+        "std::vector<std::size_t> shape = {3, 2, 2};\n",
+        "std::cout << std::accumulate(frand.begin(shape), frand.end(shape), 0.0);"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# ![xtensor-blas](images/xtensor-blas.png)\n",
+        "\n",
+        "<center>Blas bindings for xtensor.</center>\n",
+        "\n",
+        "`xtensor-blas` is an extension to the xtensor library, offering bindings to BLAS and LAPACK libraries \n",
+        "through cxxblas and cxxlapack from the [FLENS](https://github.com/michael-lehn/FLENS) project.\n",
+        "\n",
+        "`xtensor-blas` currently provides non-broadcasting `dot`, `norm` (1- and 2-norm for vectors), `inverse`, `solve`,\n",
+        "`eig`, `cross`, `det`, `slogdet`, `matrix_rank`, `inv`, `cholesky`, `qr`, `svd` in the `xt::linalg` namespace (check the corresponding `xlinalg.hpp` header for the function signatures). The functions, and signatures, are trying to be 1-to-1 equivalent to NumPy.\n",
+        "Low-level functions to interface with BLAS or LAPACK with xtensor containers are also offered \n",
+        "in the `blas` and `lapack` namespace.\n",
+        "\n",
+        "`xtensor` and `xtensor-blas` require a modern C++ compiler supporting C++14. The following C++ compilers are supported:\n",
+        "\n",
+        " - On Windows platforms, Visual C++ 2015 Update 2, or more recent\n",
+        " - On Unix platforms, gcc 4.9 or a recent version of Clang"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "#include \"xtensor-blas/xlinalg.hpp\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xtensor<double, 2> m = {{1.5, 0.5}, {0.7, 1.0}};"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "std::cout << \"Matrix rank: \" << std::endl << xt::linalg::matrix_rank(m);"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "std::cout << \"Matrix inverse: \" << std::endl << xt::linalg::inv(m);"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "std::cout << \"Eigen values: \" << std::endl << xt::linalg::eigvals(m);"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "xt::xarray<double> arg1 = xt::arange<double>(9);\n",
+        "xt::xarray<double> arg2 = xt::arange<double>(18);\n",
+        "arg1.reshape({3, 3});\n",
+        "arg2.reshape({2, 3, 3});\n",
+        "std::cout << xt::linalg::dot(arg1, arg2) << std::endl;"
+      ]
     }
-   ],
-   "source": [
-    "xt::xarray<double> frand = xt::random::randn<double>({2, 2});\n",
-    "\n",
-    "// begin() and end() provide and iterator pair iterating over the xexpression in a row-major fashion\n",
-    "std::cout << std::accumulate(frand.begin(), frand.end(), 0.0);\n",
-    "\n",
-    "frand"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Iterating over a prescribed broadcasted shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-6.0359"
-     ]
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "C++14",
+      "language": "C++14",
+      "name": "xcpp14"
+    },
+    "language_info": {
+      "version": "-std=c++14",
+      "codemirror_mode": "text/x-c++src",
+      "file_extension": ".cpp",
+      "mimetype": "text/x-c++src",
+      "name": "c++"
     }
-   ],
-   "source": [
-    "// begin(shape) and end(shape) provide and iterator pair iterating\n",
-    "// over the xexpression broadcasted to the prescrived shape in a row-major fashion\n",
-    "std::vector<std::size_t> shape = {3, 2, 2};\n",
-    "std::cout << std::accumulate(frand.begin(shape), frand.end(shape), 0.0);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
-   "source": [
-    "# ![xtensor-blas](images/xtensor-blas.png)\n",
-    "\n",
-    "<center>Blas bindings for xtensor.</center>\n",
-    "\n",
-    "`xtensor-blas` is an extension to the xtensor library, offering bindings to BLAS and LAPACK libraries \n",
-    "through cxxblas and cxxlapack from the [FLENS](https://github.com/michael-lehn/FLENS) project.\n",
-    "\n",
-    "`xtensor-blas` currently provides non-broadcasting `dot`, `norm` (1- and 2-norm for vectors), `inverse`, `solve`,\n",
-    "`eig`, `cross`, `det`, `slogdet`, `matrix_rank`, `inv`, `cholesky`, `qr`, `svd` in the `xt::linalg` namespace (check the corresponding `xlinalg.hpp` header for the function signatures). The functions, and signatures, are trying to be 1-to-1 equivalent to NumPy.\n",
-    "Low-level functions to interface with BLAS or LAPACK with xtensor containers are also offered \n",
-    "in the `blas` and `lapack` namespace.\n",
-    "\n",
-    "`xtensor` and `xtensor-blas` require a modern C++ compiler supporting C++14. The following C++ compilers are supported:\n",
-    "\n",
-    " - On Windows platforms, Visual C++ 2015 Update 2, or more recent\n",
-    " - On Unix platforms, gcc 4.9 or a recent version of Clang"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#include \"xtensor-blas/xlinalg.hpp\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "xt::xtensor<double, 2> m = {{1.5, 0.5}, {0.7, 1.0}};"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "std::cout << \"Matrix rank: \" << std::endl << xt::linalg::matrix_rank(m);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "std::cout << \"Matrix inverse: \" << std::endl << xt::linalg::inv(m);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "std::cout << \"Eigen values: \" << std::endl << xt::linalg::eigvals(m);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "xt::xarray<double> arg1 = xt::arange<double>(9);\n",
-    "xt::xarray<double> arg2 = xt::arange<double>(18);\n",
-    "arg1.reshape({3, 3});\n",
-    "arg2.reshape({2, 3, 3});\n",
-    "std::cout << xt::linalg::dot(arg1, arg2) << std::endl;"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "C++14",
-   "language": "C++14",
-   "name": "xeus-cling-cpp14"
   },
-  "language_info": {
-   "codemirror_mode": "text/x-c++src",
-   "file_extension": ".cpp",
-   "mimetype": "text/x-c++src",
-   "name": "c++",
-   "version": "-std=c++14"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
+  "nbformat": 4,
+  "nbformat_minor": 4
 }
diff --git a/readthedocs.yml b/readthedocs.yml
index 02f0e7baa..9b5447ca5 100644
--- a/readthedocs.yml
+++ b/readthedocs.yml
@@ -1,2 +1,13 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: mambaforge-22.9
+
+sphinx:
+  # Path to Sphinx configuration file
+  configuration: docs/source/conf.py
+
 conda:
-    file: docs/environment.yml
+  environment: docs/rtd_environment.yml
diff --git a/share/xeus-cpp/tagfiles/xtensor.tag b/share/xeus-cpp/tagfiles/xtensor.tag
new file mode 100644
index 000000000..6e7377611
--- /dev/null
+++ b/share/xeus-cpp/tagfiles/xtensor.tag
@@ -0,0 +1,1336 @@
+<?xml version='1.0' encoding='utf-8'?>
+<tagfile>
+    <url>https://xtensor.readthedocs.io/en/latest/</url>
+    <compound kind="class">
+        <name>xt::any</name>
+        <filename>api/xcontainer.html#_CPPv2N2xt3anyE</filename>
+    </compound>
+    <compound kind="class">
+        <name>xt::column_major</name>
+        <filename>api/xcontainer.html#_CPPv2N2xt12column_majorE</filename>
+    </compound>
+    <compound kind="class">
+        <name>xt::dynamic</name>
+        <filename>api/xcontainer.html#_CPPv2N2xt7dynamicE</filename>
+    </compound>
+    <compound kind="class">
+        <name>xt::row_major</name>
+        <filename>api/xcontainer.html#_CPPv2N2xt9row_majorE</filename>
+    </compound>
+    <compound kind="class">
+        <name>xt::xadaptor_semantic</name>
+        <filename>api/xadaptor_semantic.html#_CPPv2N2xt17xadaptor_semanticE</filename>
+        <member kind="function">
+            <name>assign_temporary</name>
+            <anchorfile>api/xadaptor_semantic.html#_CPPv2N2xt17xadaptor_semantic16assign_temporaryERR14temporary_type</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xarray_adaptor</name>
+        <filename>api/xarray_adaptor.html#_CPPv2N2xt14xarray_adaptorE</filename>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xarray_adaptor.html#_CPPv2N2xt14xarray_adaptoraSERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xarray_adaptor</name>
+            <anchorfile>api/xarray_adaptor.html#_CPPv2N2xt14xarray_adaptor14xarray_adaptorE22container_closure_typeRK10shape_typeRK12strides_type</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xarray_container</name>
+        <filename>api/xarray.html#_CPPv2N2xt16xarray_containerE</filename>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xarray.html#_CPPv2N2xt16xarray_containeraSERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xarray_container</name>
+            <anchorfile>api/xarray.html#_CPPv2N2xt16xarray_container16xarray_containerEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xbroadcast</name>
+        <filename>api/xbroadcast.html#_CPPv2N2xt10xbroadcastE</filename>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcast15broadcast_shapeER1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcast9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>element</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcast7elementE2It2It</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcast20is_trivial_broadcastERK1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>layout</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcast6layoutEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcastclEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator[]</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcastixERK6xindex</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcast5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2NK2xt10xbroadcast4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xbroadcast</name>
+            <anchorfile>api/xbroadcast.html#_CPPv2N2xt10xbroadcast10xbroadcastERR3CTARR1S</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xconst_iterable</name>
+        <filename>api/xiterable.html#_CPPv2N2xt15xconst_iterableE</filename>
+        <member kind="function">
+            <name>cxbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable7cxbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cxend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable5cxendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cxrbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable8cxrbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cxrend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable6cxrendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable6xbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable4xendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xrbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable7xrbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xrend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt15xconst_iterable5xrendEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xcontainer</name>
+        <filename>api/xcontainer.html#_CPPv2N2xt10xcontainerE</filename>
+        <member kind="function">
+            <name>backstrides</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer11backstridesEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>begin</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer5beginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer15broadcast_shapeER1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cbegin</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer6cbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cend</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer4cendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crbegin</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer7crbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crend</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer5crendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>data</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer4dataEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>element</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer7elementE2It2It</anchorfile>
+        </member>
+        <member kind="function">
+            <name>end</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer3endEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer20is_trivial_broadcastERK1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainerclEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator[]</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainerixERK6xindex</anchorfile>
+        </member>
+        <member kind="function">
+            <name>raw_data</name>
+            <anchorfile>api/xcontainer.html#_CPPv2N2xt10xcontainer8raw_dataEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>raw_data_offset</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer15raw_data_offsetEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rbegin</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer6rbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rend</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer4rendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>strides</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt10xcontainer7stridesEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xcontainer_semantic</name>
+        <filename>api/xcontainer_semantic.html#_CPPv2N2xt19xcontainer_semanticE</filename>
+        <member kind="function">
+            <name>assign_temporary</name>
+            <anchorfile>api/xcontainer_semantic.html#_CPPv2N2xt19xcontainer_semantic16assign_temporaryERR14temporary_type</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xexpression</name>
+        <filename>api/xexpression.html#_CPPv2N2xt11xexpressionE</filename>
+        <member kind="function">
+            <name>derived_cast</name>
+            <anchorfile>api/xexpression.html#_CPPv2NK2xt11xexpression12derived_castEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xexpression_const_iterable</name>
+        <filename>api/xiterable.html#_CPPv2N2xt26xexpression_const_iterableE</filename>
+        <member kind="function">
+            <name>begin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable5beginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable6cbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable4cendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable7crbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable5crendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>end</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable3endEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable6rbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt26xexpression_const_iterable4rendEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xexpression_iterable</name>
+        <filename>api/xiterable.html#_CPPv2N2xt20xexpression_iterableE</filename>
+        <member kind="function">
+            <name>begin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable5beginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable6cbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable4cendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable7crbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable5crendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>end</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable3endEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable6rbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rend</name>
+            <anchorfile>api/xiterable.html#_CPPv2NK2xt20xexpression_iterable4rendEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xfiltration</name>
+        <filename>api/xindexview.html#_CPPv2N2xt11xfiltrationE</filename>
+        <member kind="function">
+            <name>operator*=</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt11xfiltrationmLERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator+=</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt11xfiltrationpLERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator-=</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt11xfiltrationmIERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator/=</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt11xfiltrationdVERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt11xfiltrationaSERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xfiltration</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt11xfiltration11xfiltrationE3ECT3CCT</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xfunction</name>
+        <filename>api/xfunction.html#_CPPv2N2xt9xfunctionE</filename>
+        <member kind="function">
+            <name>begin</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction5beginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction15broadcast_shapeER1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cbegin</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction6cbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cend</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction4cendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crbegin</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction7crbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crend</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction5crendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>element</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction7elementE2It2It</anchorfile>
+        </member>
+        <member kind="function">
+            <name>end</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction3endEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction20is_trivial_broadcastERK1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>layout</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction6layoutEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunctionclEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rbegin</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction6rbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rend</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction4rendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xfunction.html#_CPPv2NK2xt9xfunction4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xfunction</name>
+            <anchorfile>api/xfunction.html#_CPPv2N2xt9xfunction9xfunctionERR4FuncDp2CT</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xfunctorview</name>
+        <filename>api/xfunctorview.html#_CPPv2N2xt12xfunctorviewE</filename>
+        <member kind="function">
+            <name>begin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview5beginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview15broadcast_shapeER1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cbegin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview6cbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cend</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview4cendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crbegin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview7crbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>crend</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview5crendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cxbegin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview7cxbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cxend</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview5cxendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cxrbegin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview8cxrbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>cxrend</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview6cxrendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>element</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview7elementE2IT2IT</anchorfile>
+        </member>
+        <member kind="function">
+            <name>end</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview3endEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview20is_trivial_broadcastERK1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>layout</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview6layoutEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorviewclEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2N2xt12xfunctorviewaSERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator[]</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorviewixERK6xindex</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rbegin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview6rbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>rend</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview4rendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xbegin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview6xbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xend</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview4xendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xfunctorview</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2N2xt12xfunctorview12xfunctorviewERR4FuncRR1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xrbegin</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview7xrbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xrend</name>
+            <anchorfile>api/xfunctorview.html#_CPPv2NK2xt12xfunctorview5xrendEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xgenerator</name>
+        <filename>api/xgenerator.html#_CPPv2N2xt10xgeneratorE</filename>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xgenerator.html#_CPPv2NK2xt10xgenerator15broadcast_shapeER1O</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xgenerator.html#_CPPv2NK2xt10xgenerator9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>element</name>
+            <anchorfile>api/xgenerator.html#_CPPv2NK2xt10xgenerator7elementE2It2It</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xgenerator.html#_CPPv2NK2xt10xgenerator20is_trivial_broadcastERK1O</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xgenerator.html#_CPPv2NK2xt10xgeneratorclEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xgenerator.html#_CPPv2NK2xt10xgenerator5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xgenerator.html#_CPPv2NK2xt10xgenerator4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xgenerator</name>
+            <anchorfile>api/xgenerator.html#_CPPv2N2xt10xgenerator10xgeneratorERR4FuncRK1S</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xindexview</name>
+        <filename>api/xindexview.html#_CPPv2N2xt10xindexviewE</filename>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xindexview.html#_CPPv2NK2xt10xindexview15broadcast_shapeER1O</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xindexview.html#_CPPv2NK2xt10xindexview9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>element</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt10xindexview7elementE2It2It</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xindexview.html#_CPPv2NK2xt10xindexview20is_trivial_broadcastERK1O</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xindexview.html#_CPPv2NK2xt10xindexviewclENSt6size_tEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt10xindexviewaSERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xindexview.html#_CPPv2NK2xt10xindexview5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xindexview.html#_CPPv2NK2xt10xindexview4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xindexview</name>
+            <anchorfile>api/xindexview.html#_CPPv2N2xt10xindexview10xindexviewE2CTRR2I2</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xiterable</name>
+        <filename>api/xiterable.html#_CPPv2N2xt9xiterableE</filename>
+        <member kind="function">
+            <name>xbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2N2xt9xiterable6xbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xend</name>
+            <anchorfile>api/xiterable.html#_CPPv2N2xt9xiterable4xendEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xrbegin</name>
+            <anchorfile>api/xiterable.html#_CPPv2N2xt9xiterable7xrbeginEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xrend</name>
+            <anchorfile>api/xiterable.html#_CPPv2N2xt9xiterable5xrendEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xreducer</name>
+        <filename>api/xreducer.html#_CPPv2N2xt8xreducerE</filename>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducer15broadcast_shapeER1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducer9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>element</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducer7elementE2It2It</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducer20is_trivial_broadcastERK1S</anchorfile>
+        </member>
+        <member kind="function">
+            <name>layout</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducer6layoutEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducerclEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator[]</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducerixERK6xindex</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducer5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xreducer.html#_CPPv2NK2xt8xreducer4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xreducer</name>
+            <anchorfile>api/xreducer.html#_CPPv2N2xt8xreducer8xreducerERR4FuncRR3CTARR2AX</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xsemantic_base</name>
+        <filename>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_baseE</filename>
+        <member kind="function">
+            <name>assign</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_base6assignERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>divides_assign</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_base14divides_assignERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>minus_assign</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_base12minus_assignERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>multiplies_assign</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_base17multiplies_assignERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator*=</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_basemLERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator+=</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_basepLERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator-=</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_basemIERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator/=</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_basedVERK1E</anchorfile>
+        </member>
+        <member kind="function">
+            <name>plus_assign</name>
+            <anchorfile>api/xsemantic_base.html#_CPPv2N2xt14xsemantic_base11plus_assignERK11xexpressionI1EE</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xstrided_container</name>
+        <filename>api/xcontainer.html#_CPPv2N2xt18xstrided_containerE</filename>
+        <member kind="function">
+            <name>layout</name>
+            <anchorfile>api/xcontainer.html#_CPPv2NK2xt18xstrided_container6layoutEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>reshape</name>
+            <anchorfile>api/xcontainer.html#_CPPv2N2xt18xstrided_container7reshapeERK1Sb</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xtensor_adaptor</name>
+        <filename>api/xtensor_adaptor.html#_CPPv2N2xt15xtensor_adaptorE</filename>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xtensor_adaptor.html#_CPPv2N2xt15xtensor_adaptoraSERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xtensor_adaptor</name>
+            <anchorfile>api/xtensor_adaptor.html#_CPPv2N2xt15xtensor_adaptor15xtensor_adaptorE22container_closure_typeRK10shape_typeRK12strides_type</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xtensor_container</name>
+        <filename>api/xtensor.html#_CPPv2N2xt17xtensor_containerE</filename>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xtensor.html#_CPPv2N2xt17xtensor_containeraSERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xtensor_container</name>
+            <anchorfile>api/xtensor.html#_CPPv2N2xt17xtensor_container17xtensor_containerEv</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xview</name>
+        <filename>api/xview.html#_CPPv2N2xt5xviewE</filename>
+        <member kind="function">
+            <name>broadcast_shape</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview15broadcast_shapeER2ST</anchorfile>
+        </member>
+        <member kind="function">
+            <name>data</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview4dataEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>dimension</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview9dimensionEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>is_trivial_broadcast</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview20is_trivial_broadcastERK2ST</anchorfile>
+        </member>
+        <member kind="function">
+            <name>layout</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview6layoutEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator()</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xviewclEDp4Args</anchorfile>
+        </member>
+        <member kind="function">
+            <name>operator=</name>
+            <anchorfile>api/xview.html#_CPPv2N2xt5xviewaSERK11xexpressionI1EE</anchorfile>
+        </member>
+        <member kind="function">
+            <name>raw_data</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview8raw_dataEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>raw_data_offset</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview15raw_data_offsetEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>shape</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview5shapeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>size</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview4sizeEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>slices</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview6slicesEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>strides</name>
+            <anchorfile>api/xview.html#_CPPv2NK2xt5xview7stridesEv</anchorfile>
+        </member>
+        <member kind="function">
+            <name>xview</name>
+            <anchorfile>api/xview.html#_CPPv2N2xt5xview5xviewERR3CTARR3FSLDpRR2SL</anchorfile>
+        </member>
+    </compound>
+    <compound kind="class">
+        <name>xt::xview_semantic</name>
+        <filename>api/xview_semantic.html#_CPPv2N2xt14xview_semanticE</filename>
+        <member kind="function">
+            <name>assign_temporary</name>
+            <anchorfile>api/xview_semantic.html#_CPPv2N2xt14xview_semantic16assign_temporaryERR14temporary_type</anchorfile>
+        </member>
+    </compound>
+    <member kind="function">
+        <name>xt::abs</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt3absERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::acos</name>
+        <anchorfile>api/trigonometric_functions.html#_CPPv2N2xt4acosERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::acosh</name>
+        <anchorfile>api/hyperbolic_functions.html#_CPPv2N2xt5acoshERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::all</name>
+        <anchorfile>api/xview.html#_CPPv2N2xt3allEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::allclose</name>
+        <anchorfile>api/classif_functions.html#_CPPv2N2xt8allcloseERR2E1RR2E2dd</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::any</name>
+        <anchorfile>api/operators.html#_CPPv2N2xt3anyERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::arange</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt6arangeE1T1T1T</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::asin</name>
+        <anchorfile>api/trigonometric_functions.html#_CPPv2N2xt4asinERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::asinh</name>
+        <anchorfile>api/hyperbolic_functions.html#_CPPv2N2xt5asinhERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::atan</name>
+        <anchorfile>api/trigonometric_functions.html#_CPPv2N2xt4atanERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::atan2</name>
+        <anchorfile>api/trigonometric_functions.html#_CPPv2N2xt5atan2ERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::atanh</name>
+        <anchorfile>api/hyperbolic_functions.html#_CPPv2N2xt5atanhERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::broadcast</name>
+        <anchorfile>api/xbroadcast.html#_CPPv2N2xt9broadcastERR1ERK1S</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::cbrt</name>
+        <anchorfile>api/power_functions.html#_CPPv2N2xt4cbrtERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::ceil</name>
+        <anchorfile>api/nearint_operations.html#_CPPv2N2xt4ceilERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::clip</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt4clipERR2E1RR2E2RR2E3</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::compute_layout</name>
+        <anchorfile>api/xcontainer.html#_CPPv2N2xt14compute_layoutEDp4Args</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::cos</name>
+        <anchorfile>api/trigonometric_functions.html#_CPPv2N2xt3cosERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::cosh</name>
+        <anchorfile>api/hyperbolic_functions.html#_CPPv2N2xt4coshERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::detail::isclose::isclose</name>
+        <anchorfile>api/classif_functions.html#_CPPv2N2xt6detail7isclose7iscloseEddb</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::diag</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt4diagERR1Ei</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::diagonal</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt8diagonalERR1EiNSt6size_tENSt6size_tE</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::equal</name>
+        <anchorfile>api/operators.html#_CPPv2N2xt5equalERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::erf</name>
+        <anchorfile>api/error_functions.html#_CPPv2N2xt3erfERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::erfc</name>
+        <anchorfile>api/error_functions.html#_CPPv2N2xt4erfcERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::eval</name>
+        <anchorfile>api/xeval.html#_CPPv2N2xt4evalERR1T</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::exp</name>
+        <anchorfile>api/exponential_functions.html#_CPPv2N2xt3expERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::exp2</name>
+        <anchorfile>api/exponential_functions.html#_CPPv2N2xt4exp2ERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::expm1</name>
+        <anchorfile>api/exponential_functions.html#_CPPv2N2xt5expm1ERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::eye</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt3eyeERKNSt6vectorINSt6size_tEEEi</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::fabs</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt4fabsERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::fdim</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt4fdimERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::filter</name>
+        <anchorfile>api/xindexview.html#_CPPv2N2xt6filterERR1ERR1O</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::filtration</name>
+        <anchorfile>api/xindexview.html#_CPPv2N2xt10filtrationERR1ERR1C</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::flip</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt4flipERR1ENSt6size_tE</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::floor</name>
+        <anchorfile>api/nearint_operations.html#_CPPv2N2xt5floorERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::fma</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt3fmaERR2E1RR2E2RR2E3</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::fmax</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt4fmaxERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::fmin</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt4fminERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::fmod</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt4fmodERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::hypot</name>
+        <anchorfile>api/power_functions.html#_CPPv2N2xt5hypotERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::index_view</name>
+        <anchorfile>api/xindexview.html#_CPPv2N2xt10index_viewERR1ERR1I</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::isclose</name>
+        <anchorfile>api/classif_functions.html#_CPPv2N2xt7iscloseERR2E1RR2E2ddb</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::isfinite</name>
+        <anchorfile>api/classif_functions.html#_CPPv2N2xt8isfiniteERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::isinf</name>
+        <anchorfile>api/classif_functions.html#_CPPv2N2xt5isinfERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::isnan</name>
+        <anchorfile>api/classif_functions.html#_CPPv2N2xt5isnanERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::lgamma</name>
+        <anchorfile>api/error_functions.html#_CPPv2N2xt6lgammaERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::linspace</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt8linspaceE1T1TNSt6size_tEb</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::log</name>
+        <anchorfile>api/exponential_functions.html#_CPPv2N2xt3logERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::log10</name>
+        <anchorfile>api/exponential_functions.html#_CPPv2N2xt5log10ERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::log1p</name>
+        <anchorfile>api/exponential_functions.html#_CPPv2N2xt5log1pERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::log2</name>
+        <anchorfile>api/exponential_functions.html#_CPPv2N2xt4log2ERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::logspace</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt8logspaceE1T1TNSt6size_tE1Tb</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::maximum</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt7maximumERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::mean</name>
+        <anchorfile>api/reducing_functions.html#_CPPv2N2xt4meanERR1ERR1X</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::minimum</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt7minimumERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::nearbyint</name>
+        <anchorfile>api/nearint_operations.html#_CPPv2N2xt9nearbyintERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::newaxis</name>
+        <anchorfile>api/xview.html#_CPPv2N2xt7newaxisEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::nonzero</name>
+        <anchorfile>api/operators.html#_CPPv2N2xt7nonzeroERK1T</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::not_equal</name>
+        <anchorfile>api/operators.html#_CPPv2N2xt9not_equalERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::ones</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt4onesERAL_K1I</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator!</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtntERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator!=</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtneERK9xiteratorI2It1S1LERK9xiteratorI2It1S1LE</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator&amp;&amp;</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtaaERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtmlERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator+</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtplERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator-</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtmiERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator/</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtdvERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator&lt;</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtltERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator&lt;=</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtleERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator==</name>
+        <anchorfile>api/operators.html#_CPPv2N2xteqERK9xiteratorI2It1S1LERK9xiteratorI2It1S1LE</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator&gt;</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtgtERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator&gt;=</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtgeERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::operator||</name>
+        <anchorfile>api/operators.html#_CPPv2N2xtooERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::pow</name>
+        <anchorfile>api/power_functions.html#_CPPv2N2xt3powERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::prod</name>
+        <anchorfile>api/reducing_functions.html#_CPPv2N2xt4prodERR1ERR1X</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::random::get_default_random_engine</name>
+        <anchorfile>api/xrandom.html#_CPPv2N2xt6random25get_default_random_engineEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::random::rand</name>
+        <anchorfile>api/xrandom.html#_CPPv2N2xt6random4randERK1S1T1TR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::random::randint</name>
+        <anchorfile>api/xrandom.html#_CPPv2N2xt6random7randintERK1S1T1TR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::random::randn</name>
+        <anchorfile>api/xrandom.html#_CPPv2N2xt6random5randnERK1S1T1TR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::random::seed</name>
+        <anchorfile>api/xrandom.html#_CPPv2N2xt6random4seedE9seed_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::range</name>
+        <anchorfile>api/xview.html#_CPPv2N2xt5rangeE1T1T1T</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::reduce</name>
+        <anchorfile>api/xreducer.html#_CPPv2N2xt6reduceERR1FRR1ERR1X</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::remainder</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt9remainderERR2E1RR2E2</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::rint</name>
+        <anchorfile>api/nearint_operations.html#_CPPv2N2xt4rintERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::round</name>
+        <anchorfile>api/nearint_operations.html#_CPPv2N2xt5roundERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::sign</name>
+        <anchorfile>api/basic_functions.html#_CPPv2N2xt4signERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::sin</name>
+        <anchorfile>api/trigonometric_functions.html#_CPPv2N2xt3sinERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::sinh</name>
+        <anchorfile>api/hyperbolic_functions.html#_CPPv2N2xt4sinhERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::sqrt</name>
+        <anchorfile>api/power_functions.html#_CPPv2N2xt4sqrtERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::sum</name>
+        <anchorfile>api/reducing_functions.html#_CPPv2N2xt3sumERR1ERR1X</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::tan</name>
+        <anchorfile>api/trigonometric_functions.html#_CPPv2N2xt3tanERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::tanh</name>
+        <anchorfile>api/hyperbolic_functions.html#_CPPv2N2xt4tanhERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::tgamma</name>
+        <anchorfile>api/error_functions.html#_CPPv2N2xt6tgammaERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::tril</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt4trilERR1Ei</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::triu</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt4triuERR1Ei</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::trunc</name>
+        <anchorfile>api/nearint_operations.html#_CPPv2N2xt5truncERR1E</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::view</name>
+        <anchorfile>api/xview.html#_CPPv2N2xt4viewERR1EDpRR1S</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::where</name>
+        <anchorfile>api/operators.html#_CPPv2N2xt5whereERR2E1RR2E2RR2E3</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xadapt</name>
+        <anchorfile>api/xtensor_adaptor.html#_CPPv2N2xt6xadaptER1PN1A9size_typeE1ORKNSt5arrayIN1A9size_typeE1NEERKNSt5arrayIN1A9size_typeE1NEERK1A</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xaxis_iterator::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt14xaxis_iterator5equalERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xaxis_iterator::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt14xaxis_iteratormlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xdummy_iterator::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt15xdummy_iterator5equalERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xdummy_iterator::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt15xdummy_iteratormlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunction_iterator::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt18xfunction_iterator5equalERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunction_iterator::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt18xfunction_iteratormlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunction_stepper::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt17xfunction_stepper5equalERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunction_stepper::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt17xfunction_steppermlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunctor_iterator::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt17xfunctor_iterator5equalERK17xfunctor_iterator</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunctor_iterator::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt17xfunctor_iteratormlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunctor_stepper::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt16xfunctor_stepper5equalERK16xfunctor_stepper</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xfunctor_stepper::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt16xfunctor_steppermlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xindexed_stepper::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt16xindexed_stepper5equalERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xindexed_stepper::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt16xindexed_steppermlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xiterator::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt9xiterator5equalERK9xiterator</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xiterator::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt9xiteratormlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xoptional::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt9xoptional5equalERK9xoptionalI3CTO3CBOE</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xoptional_iterator::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt18xoptional_iterator5equalERK18xoptional_iterator</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xoptional_iterator::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt18xoptional_iteratormlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xoptional_iterator::operator+</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt18xoptional_iteratorplE15difference_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xoptional_iterator::operator-</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt18xoptional_iteratormiERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xreducer_stepper::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt16xreducer_stepper5equalERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xreducer_stepper::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt16xreducer_steppermlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xscalar_stepper::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt15xscalar_stepper5equalERK9self_type</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xscalar_stepper::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt15xscalar_steppermlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xstepper::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt8xstepper5equalERK8xstepper</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xstepper::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt8xsteppermlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xview_stepper::equal</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt13xview_stepper5equalERK13xview_stepper</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xview_stepper::operator*</name>
+        <anchorfile>api/operators.html#_CPPv2NK2xt13xview_steppermlEv</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::zeros</name>
+        <anchorfile>api/xbuilder.html#_CPPv2N2xt5zerosERAL_K1I</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::layout_type</name>
+        <anchorfile>api/xcontainer.html#_CPPv2N2xt11layout_typeE</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xarray</name>
+        <anchorfile>api/xarray.html#_CPPv2N2xt6xarrayE</anchorfile>
+    </member>
+    <member kind="function">
+        <name>xt::xtensor</name>
+        <anchorfile>api/xtensor.html#_CPPv2N2xt7xtensorE</anchorfile>
+    </member>
+</tagfile>
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 5076c8fb6..041a839cd 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,204 +1,324 @@
 ############################################################################
-# Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht    #
+# 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.1)
+cmake_minimum_required(VERSION 3.15..3.29)
 
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-    project(xtensor-test)
+    project(xtensor-test CXX)
+
+    enable_testing()
 
     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)
+find_package(doctest            REQUIRED)
+find_package(Threads)
+
+if(NOT CMAKE_BUILD_TYPE)
+    message(STATUS "Setting tests build type to Release")
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+else()
+    message(STATUS "Tests build type is ${CMAKE_BUILD_TYPE}")
+endif()
 
 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" AND NOT WIN32))
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -Wunused-parameter -Wextra -Wreorder -Wconversion -Wsign-conversion")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Wunused-variable")
-    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -Wunused-parameter -Wextra -Wreorder -Wconversion")
-    CHECK_CXX_COMPILER_FLAG("-std=c++14" HAS_CPP14_FLAG)
+include(set_compiler_flag.cmake)
 
-    if (HAS_CPP14_FLAG)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
-    else()
-        message(FATAL_ERROR "Unsupported compiler -- xtensor requires C++14 support!")
-    endif()
+if(CPP23)
+  # User requested C++23, but compiler might not oblige.
+  set_compiler_flag(
+    _cxx_std_flag CXX
+    "-std=c++23"  # this should work with GNU, Intel, PGI
+    "/std:c++23"  # this should work with MSVC
+  )
+  if(_cxx_std_flag)
+    message(STATUS "Building with C++23")
+  endif()
+else()
+  set_compiler_flag(
+    _cxx_std_flag CXX REQUIRED
+    "-std=c++20"  # this should work with GNU, Intel, PGI
+    "/std:c++20"  # this should work with MSVC
+  )
+  message(STATUS "Building with C++20")
 endif()
 
-if(MSVC)
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-    add_definitions(-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc /MP /bigobj /wd4800")
-    set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
+if(NOT _cxx_std_flag)
+  message(FATAL_ERROR "xtensor needs a C++20-compliant compiler.")
 endif()
 
-if(DOWNLOAD_GTEST OR GTEST_SRC_DIR)
-    if(DOWNLOAD_GTEST)
-        # Download and unpack googletest at configure time
-        configure_file(downloadGTest.cmake.in googletest-download/CMakeLists.txt)
-    else()
-        # Copy local source of googletest at configure time
-        configure_file(copyGTest.cmake.in googletest-download/CMakeLists.txt)
+OPTION(XTENSOR_ENABLE_WERROR "Turn on -Werror" OFF)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DXSIMD_ENABLE_XTL_COMPLEX=1")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR (CMAKE_CXX_COMPILER_ID MATCHES "Intel" AND NOT WIN32))
+  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} ${_cxx_std_flag} -Wunused-parameter -Wextra -Wreorder -Wconversion -Wno-sign-conversion ")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Wunused-variable -ftemplate-backtrace-limit=0")
+  if (XTENSOR_DISABLE_EXCEPTIONS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+  endif()
+  if (XTENSOR_ENABLE_WERROR)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -DSKIP_ON_WERROR")
+  endif()
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_cxx_std_flag} /Zc:__cplusplus /MP /bigobj")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+  add_definitions(-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
+  if (XTENSOR_DISABLE_EXCEPTIONS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHs-c-")
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
+  endif()
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU")
+    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()
-    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
-                    RESULT_VARIABLE result
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-    if(result)
-        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_cxx_std_flag} -Wunused-parameter -Wextra -Wreorder -Wconversion -Wsign-conversion")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Wunused-variable")
+    if (XTENSOR_DISABLE_EXCEPTIONS)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
     endif()
-    execute_process(COMMAND ${CMAKE_COMMAND} --build .
-                    RESULT_VARIABLE result
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download )
-    if(result)
-        message(FATAL_ERROR "Build step for googletest failed: ${result}")
+    if (XTENSOR_ENABLE_WERROR)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -DSKIP_ON_WERROR")
     endif()
-
-    # Add googletest directly to our build. This defines
-    # the gtest and gtest_main targets.
-    add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
-                     ${CMAKE_CURRENT_BINARY_DIR}/googletest-build)
-
-    set(GTEST_INCLUDE_DIRS "${gtest_SOURCE_DIR}/include")
-    set(GTEST_BOTH_LIBRARIES  gtest_main gtest)
+  elseif (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_cxx_std_flag} /bigobj")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    add_definitions(-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
+    if (XTENSOR_DISABLE_EXCEPTIONS)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHs-c-")
+    else()
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
+    endif()
+  endif()
 else()
-    find_package(GTest REQUIRED)
+  message(FATAL_ERROR "Unsupported compiler: ${CMAKE_CXX_COMPILER_ID}")
 endif()
 
-find_package(Threads)
-
-include_directories(${GTEST_INCLUDE_DIRS} SYSTEM)
 
-set(COMMON_BASE
-    main.cpp
+# For unit test and coverity scan.
+# The Coverity scanner takes time and it could cause build timeout(10mins) in Travis CI.
+# Therefore, we need keep this small but complete for analysis.
+set(TEST_HEADERS
     test_common.hpp
+    test_common_macros.hpp
+    test_utils.hpp
     test_xsemantic.hpp
 )
+set(COMMON_BASE
+    test_xadaptor_semantic.cpp
+    test_xarray_adaptor.cpp
+    test_xarray.cpp
+    test_xblockwise_reducer.cpp
+    test_xbroadcast.cpp
+    test_xbuilder.cpp
+    test_xcontainer_semantic.cpp
+    test_xeval.cpp
+    test_xexception.cpp
+    test_xexpression.cpp
+    test_xexpression_traits.cpp
+    test_xfunction.cpp
+    test_xfunc_on_xexpression.cpp
+    test_xmultiindex_iterator.cpp
+    test_xiterator.cpp
+    test_xmath.cpp
+    test_xoperation.cpp
+    test_xoptional_assembly.cpp
+    test_xreducer.cpp
+    test_xscalar.cpp
+    test_xscalar_semantic.cpp
+    test_xshape.cpp
+    test_xstorage.cpp
+    test_xstrided_view.cpp
+    test_xstrides.cpp
+    test_xtensor.cpp
+    test_xtensor_adaptor.cpp
+    test_xtensor_semantic.cpp
+    test_xview.cpp
+    test_xview_semantic.cpp
+    test_xutils.cpp
+    test_xsimd8.cpp
+)
 
 set(XTENSOR_TESTS
+    main.cpp
     test_xaccumulator.cpp
     test_xadapt.cpp
-    test_xadaptor_semantic.cpp
-    test_xarray.cpp
-    test_xarray_adaptor.cpp
+    test_strided_assign.cpp
+    test_xassign.cpp
     test_xaxis_iterator.cpp
-    test_xbroadcast.cpp
+    test_xaxis_slice_iterator.cpp
     test_xbuffer_adaptor.cpp
-    test_xbuilder.cpp
-    test_xconcepts.cpp
-    test_xcontainer_semantic.cpp
+    test_xchunked_array.cpp
+    test_xchunked_view.cpp
     test_xcomplex.cpp
     test_xcsv.cpp
     test_xdatesupport.cpp
     test_xdynamic_view.cpp
-    test_xeval.cpp
-    test_xexception.cpp
-    test_xexpression.cpp
-    test_xfunction.cpp
+    test_xfunctor_adaptor.cpp
     test_xfixed.cpp
+    test_xfft.cpp
     test_xhistogram.cpp
+    test_xpad.cpp
     test_xindex_view.cpp
     test_xinfo.cpp
-    test_xiterator.cpp
     test_xio.cpp
     test_xlayout.cpp
     test_xmanipulation.cpp
-    test_xmasked_value.cpp
     test_xmasked_view.cpp
-    test_xmath.cpp
+    test_xmath_result_type.cpp
     test_xnan_functions.cpp
     test_xnoalias.cpp
     test_xnorm.cpp
     test_xnpy.cpp
-    test_xoperation.cpp
     test_xoptional.cpp
-    test_xoptional_assembly.cpp
     test_xoptional_assembly_adaptor.cpp
     test_xoptional_assembly_storage.cpp
+    test_xset_operation.cpp
     test_xrandom.cpp
-    test_xreducer.cpp
-    test_xscalar.cpp
-    test_xscalar_semantic.cpp
-    test_xshape.cpp
+    test_xrepeat.cpp
     test_xsort.cpp
-    test_xstorage.cpp
-    test_xstrided_view.cpp
-    test_xstrides.cpp
-    test_xtensor.cpp
-    test_xtensor_adaptor.cpp
-    test_xtensor_semantic.cpp
+    test_xsimd.cpp
     test_xvectorize.cpp
-    test_xview.cpp
-    test_xview_semantic.cpp
-    test_xutils.cpp
     test_extended_xmath_interp.cpp
     test_extended_broadcast_view.cpp
     test_extended_xmath_reducers.cpp
     test_extended_xhistogram.cpp
+    test_extended_xsort.cpp
+    test_sfinae.cpp
 )
 
 if(nlohmann_json_FOUND)
     list(APPEND XTENSOR_TESTS test_xjson.cpp)
+    list(APPEND XTENSOR_TESTS test_xmime.cpp)
     list(APPEND XTENSOR_TESTS test_xexpression_holder.cpp)
 endif()
 
-# remove xinfo tests for compilers < GCC 5
-if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5))
-    list(REMOVE_ITEM XTENSOR_TESTS test_xinfo.cpp)
-endif()
-
-set(XTENSOR_TARGET test_xtensor_lib)
-
 # Add files for npy tests
 set(XNPY_FILES
-    bool.npy
-    bool_fortran.npy
-    double.npy
-    double_fortran.npy
-    unsignedlong.npy
-    unsignedlong_fortran.npy
+    bool
+    bool_fortran
+    double
+    double_fortran
+    int
+    unsignedlong
+    unsignedlong_fortran
 )
+
 foreach(filename IN LISTS XNPY_FILES)
-    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/files/xnpy_files/${filename}
-        ${CMAKE_CURRENT_BINARY_DIR}/files/xnpy_files/${filename} COPYONLY)
+    foreach(suffix .be.npy .le.npy)
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/files/xnpy_files/${filename}${suffix}
+            ${CMAKE_CURRENT_BINARY_DIR}/files/xnpy_files/${filename}${suffix} COPYONLY)
+    endforeach()
 endforeach()
 
-set(XTENSOR_PREPROCESS_FILES
-    files/cppy_source/test_xstrided_view_extended.cppy
-)
+file(GLOB XTENSOR_PREPROCESS_FILES files/cppy_source/*.cppy)
+
+# Sanitizer support
+include(${CMAKE_SOURCE_DIR}/cmake/sanitizers.cmake)
 
+# This target should only be run when the test source files have been changed.
 add_custom_target(
     preprocess_cppy
     COMMAND python3 ${CMAKE_CURRENT_SOURCE_DIR}/files/preprocess.py
     DEPENDS ${XTENSOR_PREPROCESS_FILES}
 )
 
-foreach(filename IN LISTS XTENSOR_TESTS)
+foreach(filename IN LISTS COMMON_BASE XTENSOR_TESTS)
     string(REPLACE ".cpp" "" targetname ${filename})
-    add_executable(${targetname} ${COMMON_BASE} ${filename} ${XTENSOR_HEADERS})
-    target_link_libraries(${targetname} xtensor ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-    if(DOWNLOAD_GTEST OR GTEST_SRC_DIR)
-        add_dependencies(${targetname} gtest_main)
+    add_executable(${targetname} main.cpp ${filename} ${TEST_HEADERS} ${XTENSOR_HEADERS})
+    if(XTENSOR_USE_XSIMD)
+        target_compile_definitions(${targetname}
+                                   PRIVATE
+                                   XTENSOR_USE_XSIMD
+                                   XSIMD_ENABLE_XTL_COMPLEX)
+        target_link_libraries(${targetname} PRIVATE xsimd)
     endif()
+    if(XTENSOR_USE_TBB)
+        target_compile_definitions(${targetname} PRIVATE XTENSOR_USE_TBB)
+        target_include_directories(${targetname} PRIVATE ${TBB_INCLUDE_DIRS})
+        target_link_libraries(${targetname} PRIVATE ${TBB_LIBRARIES})
+    endif()
+    if(XTENSOR_USE_OPENMP)
+        target_compile_definitions(${targetname} PRIVATE XTENSOR_USE_OPENMP)
+    endif()
+    target_include_directories(${targetname} PRIVATE ${XTENSOR_INCLUDE_DIR})
+    target_link_libraries(${targetname} PRIVATE xtensor doctest::doctest ${CMAKE_THREAD_LIBS_INIT})
+    target_compile_options(${targetname} PRIVATE  $<$<BOOL:USE_SANITIZER>:${SANITIZER_COMPILE_OPTIONS}>)
+    target_link_options(${targetname} PRIVATE  $<$<BOOL:USE_SANITIZER>:${SANITIZER_LINK_OPTIONS}>)
     add_custom_target(
         x${targetname}
         COMMAND ${targetname}
         DEPENDS ${targetname} ${filename} ${XTENSOR_HEADERS})
+    add_test(NAME ${targetname} COMMAND ${targetname})
 endforeach()
 
-add_executable(${XTENSOR_TARGET} ${COMMON_BASE} ${XTENSOR_TESTS} ${XTENSOR_HEADERS})
-if(DOWNLOAD_GTEST OR GTEST_SRC_DIR)
-    add_dependencies(${XTENSOR_TARGET} gtest_main)
+add_executable(test_xtensor_lib  main.cpp ${COMMON_BASE} ${XTENSOR_TESTS} ${TEST_HEADERS} ${XTENSOR_HEADERS})
+if(XTENSOR_USE_XSIMD)
+    target_compile_definitions(test_xtensor_lib
+                               PRIVATE
+                               XTENSOR_USE_XSIMD
+                               XSIMD_ENABLE_XTL_COMPLEX)
+    target_link_libraries(test_xtensor_lib PRIVATE xsimd)
+endif()
+if(XTENSOR_USE_TBB)
+    target_compile_definitions(test_xtensor_lib PRIVATE XTENSOR_USE_TBB)
+    target_include_directories(test_xtensor_lib PRIVATE ${TBB_INCLUDE_DIRS})
+    target_link_libraries(test_xtensor_lib PRIVATE ${TBB_LIBRARIES})
+endif()
+if(XTENSOR_USE_OPENMP)
+    target_compile_definitions(test_xtensor_lib PRIVATE XTENSOR_USE_OPENMP)
+endif()
+
+target_compile_options(test_xtensor_lib PRIVATE  $<$<BOOL:USE_SANITIZER>:${SANITIZER_COMPILE_OPTIONS}>)
+target_link_options(test_xtensor_lib PRIVATE  $<$<BOOL:USE_SANITIZER>:${SANITIZER_LINK_OPTIONS}>)
+
+# doctest's String union + MSan libc interceptors (strlen/strcmp) cause
+# false-positive use-of-uninitialized-value reports during reporter
+# registration and exception formatting. These cannot be suppressed at the
+# attribute level because MSan's libc interceptors check memory regardless
+# of calling-function attributes. The combined convenience binary therefore
+# opts out of MSan instrumentation so the xtest target can complete.
+# Individual per-test executables (test_xarray, test_xview, etc.) remain
+# fully instrumented and are the correct targets for MSan CI validation.
+if(USE_SANITIZER MATCHES "memory")
+  target_compile_options(test_xtensor_lib PRIVATE -fno-sanitize=memory)
+  target_link_options(test_xtensor_lib PRIVATE -fno-sanitize=memory)
 endif()
-target_link_libraries(${XTENSOR_TARGET} xtensor ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
 
-add_custom_target(xtest COMMAND ${XTENSOR_TARGET} DEPENDS ${XTENSOR_TARGET})
+target_include_directories(test_xtensor_lib PRIVATE ${XTENSOR_INCLUDE_DIR})
+target_link_libraries(test_xtensor_lib PRIVATE xtensor  doctest::doctest ${CMAKE_THREAD_LIBS_INIT})
+
+add_custom_target(
+  xtest
+  COMMAND $<TARGET_FILE:test_xtensor_lib>
+  DEPENDS test_xtensor_lib
+)
+add_test(NAME xtest COMMAND test_xtensor_lib)
+
+# Some files will be compiled twice, however compiling common files in a static
+# library and linking test_xtensor_lib with it removes half of the tests at
+# runtime.
+add_library(test_xtensor_core_lib STATIC ${COMMON_BASE} ${TEST_HEADERS} ${XTENSOR_HEADERS})
+target_include_directories(test_xtensor_core_lib PRIVATE ${XTENSOR_INCLUDE_DIR})
+
+target_link_libraries(test_xtensor_core_lib PRIVATE xtensor doctest::doctest ${CMAKE_THREAD_LIBS_INIT})
+target_precompile_headers(test_xtensor_core_lib PRIVATE ${XTENSOR_HEADERS})
+add_custom_target(coverity COMMAND coverity_scan DEPENDS test_xtensor_core_lib)
diff --git a/test/copyGTest.cmake.in b/test/copyGTest.cmake.in
deleted file mode 100644
index 1e5d3edd3..000000000
--- a/test/copyGTest.cmake.in
+++ /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. #
-############################################################################
-
-cmake_minimum_required(VERSION 2.8.2)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(googletest
-    URL               "${GTEST_SRC_DIR}"
-    SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
-    BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
-    CONFIGURE_COMMAND ""
-    BUILD_COMMAND     ""
-    INSTALL_COMMAND   ""
-    TEST_COMMAND      ""
-)
-
diff --git a/test/downloadGTest.cmake.in b/test/downloadGTest.cmake.in
deleted file mode 100644
index a4a081796..000000000
--- a/test/downloadGTest.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 2.8.2)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-ExternalProject_Add(googletest
-    GIT_REPOSITORY    https://github.com/google/googletest.git
-    GIT_TAG           release-1.8.0
-    SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
-    BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
-    CONFIGURE_COMMAND ""
-    BUILD_COMMAND     ""
-    INSTALL_COMMAND   ""
-    TEST_COMMAND      ""
-)
-
diff --git a/test/files/cppy_source/test_extended_broadcast_view.cppy b/test/files/cppy_source/test_extended_broadcast_view.cppy
index 70866cc6b..fee8395f2 100644
--- a/test/files/cppy_source/test_extended_broadcast_view.cppy
+++ b/test/files/cppy_source/test_extended_broadcast_view.cppy
@@ -1,5 +1,6 @@
 /***************************************************************************
-* Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht    *
+* Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
+* Copyright (c) QuantStack                                                 *
 *                                                                          *
 * Distributed under the terms of the BSD 3-Clause License.                 *
 *                                                                          *
@@ -8,7 +9,6 @@
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
 #include "xtensor/xarray.hpp"
 #include "xtensor/xfixed.hpp"
 #include "xtensor/xnoalias.hpp"
@@ -16,6 +16,8 @@
 #include "xtensor/xtensor.hpp"
 #include "xtensor/xview.hpp"
 
+#include "test_common_macros.hpp"
+
 namespace xt
 {
     using namespace xt::placeholders;
diff --git a/test/files/cppy_source/test_extended_xhistogram.cppy b/test/files/cppy_source/test_extended_xhistogram.cppy
index 5b32915d4..713e8e9e6 100644
--- a/test/files/cppy_source/test_extended_xhistogram.cppy
+++ b/test/files/cppy_source/test_extended_xhistogram.cppy
@@ -1,5 +1,6 @@
 /***************************************************************************
-* Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht    *
+* Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
+* Copyright (c) QuantStack                                                 *
 *                                                                          *
 * Distributed under the terms of the BSD 3-Clause License.                 *
 *                                                                          *
@@ -8,11 +9,12 @@
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
 #include "xtensor/xarray.hpp"
 #include "xtensor/xtensor.hpp"
 #include "xtensor/xhistogram.hpp"
 
+#include "test_common_macros.hpp"
+
 namespace xt
 {
     using namespace xt::placeholders;
@@ -45,4 +47,26 @@ namespace xt
 
         EXPECT_EQ(prob, py_prob);
     }
+
+    /*py
+
+    a = (np.random.random(1000) * 51).astype(np.int)
+
+    count, bin_edges  = np.histogram(a, 30, (10, 40))
+
+    */
+    TEST(xtest_extended_histogram, histogram_with_range)
+    {
+        // py_a
+        // py_bin_edges
+        // py_count
+
+        auto bin_edges = xt::histogram_bin_edges(py_a, 10, 40, std::size_t(30));
+
+        auto count = xt::histogram(py_a, bin_edges);
+
+        EXPECT_EQ(xt::cast<double>(bin_edges), py_bin_edges);
+
+        EXPECT_EQ(count, xt::cast<double>(py_count));
+    }
 }
diff --git a/test/files/cppy_source/test_extended_xmath_interp.cppy b/test/files/cppy_source/test_extended_xmath_interp.cppy
index 6058e55d7..3fb808392 100644
--- a/test/files/cppy_source/test_extended_xmath_interp.cppy
+++ b/test/files/cppy_source/test_extended_xmath_interp.cppy
@@ -1,5 +1,6 @@
 /***************************************************************************
-* Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht    *
+* Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
+* Copyright (c) QuantStack                                                 *
 *                                                                          *
 * Distributed under the terms of the BSD 3-Clause License.                 *
 *                                                                          *
@@ -8,11 +9,12 @@
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
 #include "xtensor/xarray.hpp"
 #include "xtensor/xtensor.hpp"
 #include "xtensor/xmath.hpp"
 
+#include "test_common_macros.hpp"
+
 namespace xt
 {
     using namespace xt::placeholders;
diff --git a/test/files/cppy_source/test_extended_xmath_reducers.cppy b/test/files/cppy_source/test_extended_xmath_reducers.cppy
index 4160f1bee..2c8fafe1e 100644
--- a/test/files/cppy_source/test_extended_xmath_reducers.cppy
+++ b/test/files/cppy_source/test_extended_xmath_reducers.cppy
@@ -1,15 +1,27 @@
+/***************************************************************************
+* 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. *
+****************************************************************************/
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
 #include "xtensor/xarray.hpp"
 #include "xtensor/xtensor.hpp"
 #include "xtensor/xmath.hpp"
 
+#include "test_common_macros.hpp"
+
 namespace xt
 {
     using namespace xt::placeholders;
 
+// Temporary disabling for TBB and OPENMP due to a potential
+// race condition that must be identified
+
     /*py
     a  = np.random.random(4*5*6*7).reshape(4,5,6,7)
     w  = np.random.random(4*5*6*7).reshape(4,5,6,7)
@@ -22,7 +34,6 @@ namespace xt
         // py_av
 
         auto av = xt::average(py_a, py_w, {0,1});
-
         EXPECT_TRUE(xt::allclose(av, py_av));
     }
 
@@ -30,28 +41,42 @@ namespace xt
     a  = np.random.random(4*5*6*7).reshape(4,5,6,7)
     vr_all = np.var(a)
     st_all = np.std(a)
+    vr_all_ddof = np.var(a, ddof=1)
     vr = np.var(a, axis=(0,2))
     st = np.std(a, axis=(0,2))
+    vr_ddof = np.var(a, axis=(0,2), ddof=1)
     */
     TEST(xtest_extended_xmath, var_std)
     {
         // py_a
 
         // py_vr_all
+        // py_vr_all_ddof
         // py_st_all
         // py_vr
+        // py_vr_ddof
         // py_st
 
         auto st_all = xt::stddev(py_a);
         auto vr_all = xt::variance(py_a);
+        auto vr_all_ddof = xt::variance(py_a, {0, 1, 2, 3}, 1);
+        std::vector<size_t> axes_all = {0, 1, 2, 3};
+        auto vr_all_ddof_with_axes_arr = xt::variance(py_a, axes_all, 1);
 
         auto st = xt::stddev(py_a, {0, 2});
         auto vr = xt::variance(py_a, {0, 2});
+        auto vr_ddof = xt::variance(py_a, {0, 2}, 1);
+        std::vector<size_t> axes02 = {0, 2};
+        auto vr_ddof_with_axes_arr = xt::variance(py_a, axes02, 1);
 
         EXPECT_TRUE(xt::allclose(st_all, py_st_all));
         EXPECT_TRUE(xt::allclose(vr_all, py_vr_all));
+        EXPECT_TRUE(xt::allclose(vr_all_ddof, py_vr_all_ddof));
+        EXPECT_TRUE(xt::allclose(vr_all_ddof_with_axes_arr, py_vr_all_ddof));
         EXPECT_TRUE(xt::allclose(st, py_st));
         EXPECT_TRUE(xt::allclose(vr, py_vr));
+        EXPECT_TRUE(xt::allclose(vr_ddof, py_vr_ddof));
+        EXPECT_TRUE(xt::allclose(vr_ddof_with_axes_arr, py_vr_ddof));
     }
 
 }
diff --git a/test/files/cppy_source/test_extended_xsort.cppy b/test/files/cppy_source/test_extended_xsort.cppy
new file mode 100644
index 000000000..ab89affe9
--- /dev/null
+++ b/test/files/cppy_source/test_extended_xsort.cppy
@@ -0,0 +1,280 @@
+/***************************************************************************
+* 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. *
+****************************************************************************/
+
+#include <xtensor/xarray.hpp>
+#include <xtensor/xio.hpp>
+#include <xtensor/xview.hpp>
+#include <xtensor/xsort.hpp>
+#include <xtensor/xmath.hpp>
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    using namespace xt::placeholders;
+
+    template <class T>
+    bool check_partition_equal(const T& a1, const T& a2, std::size_t kth)
+    {
+        auto p = a1[kth];
+        EXPECT_EQ(p, a2[kth]);
+
+        for (std::size_t i = 0; i < kth; ++i)
+        {
+            EXPECT_TRUE(a1[i] < p);
+            EXPECT_TRUE(a2[i] < p);
+        }
+
+        for (std::size_t i = kth + 1; i < a1.size(); ++i)
+        {
+            EXPECT_TRUE(p < a1[i]);
+            EXPECT_TRUE(p < a2[i]);
+        }
+        return true;
+    }
+
+    template <class X, class Y, class Z>
+    bool check_argpartition_equal(const X& data, const Y& a1, const Z& a2, std::size_t kth)
+    {
+        auto p = static_cast<std::size_t>(a1[kth]);
+        EXPECT_EQ(p, std::size_t(a2[kth]));
+        auto el = data[static_cast<std::size_t>(a1[kth])];
+        for (std::size_t i = 0; i < kth; ++i)
+        {
+            EXPECT_TRUE(data[static_cast<std::size_t>(a1[i])] < el);
+            EXPECT_TRUE(data[static_cast<std::size_t>(a2[i])] < el);
+        }
+
+        for (std::size_t i = kth + std::size_t(1); i < a1.size(); ++i)
+        {
+            EXPECT_TRUE(el < data[static_cast<std::size_t>(a1[i])]);
+            EXPECT_TRUE(el < data[static_cast<std::size_t>(a2[i])]);
+        }
+        return true;
+    }
+
+    /*py
+    a = np.random.randint(0, 1000, size=(20,))
+    */
+    TEST(xtest_extended, partition)
+    {
+        // py_a
+
+        // py_p5 = np.partition(a, 5)
+        // py_p0 = np.partition(a, 0)
+        // py_p13 = np.partition(a, 13)
+        // py_p19 = np.partition(a, 19)
+
+        // py_a5 = np.argpartition(a, 5)
+        // py_a0 = np.argpartition(a, 0)
+        // py_a13 = np.argpartition(a, 13)
+        // py_a19 = np.argpartition(a, 19)
+
+        auto part_a0 = xt::partition(py_a, 0);
+
+        check_partition_equal(py_p0, part_a0, 0);
+        check_partition_equal(py_p5, xt::partition(py_a, 5), 5);
+        check_partition_equal(py_p13, xt::partition(py_a, 13), 13);
+        check_partition_equal(py_p19, xt::partition(py_a, 19), 19);
+
+        auto parta_a0 = xt::argpartition(py_a, 0);
+        check_argpartition_equal(py_a, py_a0, parta_a0, 0);
+        check_argpartition_equal(py_a, py_a5, xt::argpartition(py_a, 5), 5);
+        check_argpartition_equal(py_a, py_a13, xt::argpartition(py_a, 13), 13);
+        check_argpartition_equal(py_a, py_a19, xt::argpartition(py_a, 19), 19);
+
+        // py_median = np.median(a)
+        EXPECT_EQ(static_cast<decltype(py_a)::value_type>(py_median), xt::median(py_a));
+    }
+
+    /*py
+    a = np.random.randint(0, 20, size=(20,))
+    */
+    TEST(xtest_extended, multi_partition)
+    {
+        // py_a
+
+        // py_p0 = np.partition(a, (4, 5, 6))
+        // py_p1 = np.partition(a, (2, 7, 12))
+
+        auto part_p0 = xt::partition(py_a, {4, 5, 6});
+        auto part_p1 = xt::partition(py_a, {2, 7, 12});
+
+        EXPECT_EQ(part_p0(4), py_p0(4));
+        EXPECT_EQ(part_p0(5), py_p0(5));
+        EXPECT_EQ(part_p0(6), py_p0(6));
+
+        EXPECT_EQ(part_p1(2), py_p1(2));
+        EXPECT_EQ(part_p1(7), py_p1(7));
+        EXPECT_EQ(part_p1(12), py_p1(12));
+
+        // py_a0 = np.argpartition(a, (4, 5, 6))
+        // py_a1 = np.argpartition(a, (2, 7, 12))
+
+        auto part_a0 = xt::argpartition(py_a, {4, 5, 6});
+        auto part_a1 = xt::argpartition(py_a, {2, 7, 12});
+
+        EXPECT_EQ(py_a[part_a0(4)], py_a[static_cast<std::size_t>(py_a0(4))]);
+        EXPECT_EQ(py_a[part_a0(5)], py_a[static_cast<std::size_t>(py_a0(5))]);
+        EXPECT_EQ(py_a[part_a0(6)], py_a[static_cast<std::size_t>(py_a0(6))]);
+
+        EXPECT_EQ(py_a[part_a1(2)], py_a[static_cast<std::size_t>(py_a1(2))]);
+        EXPECT_EQ(py_a[part_a1(7)], py_a[static_cast<std::size_t>(py_a1(7))]);
+        EXPECT_EQ(py_a[part_a1(12)], py_a[static_cast<std::size_t>(py_a1(12))]);
+    }
+
+    /*py
+    a = np.random.rand(4, 5, 6)
+    */
+    TEST(xtest_extended, quantile_axis)
+    {
+        // py_a
+
+        // py_q0 = np.quantile(a, [0., .3, .1, 1.], axis=0)
+        // py_q1 = np.quantile(a, [0., .3, .1, 1.], axis=1)
+        // py_q2 = np.quantile(a, [0., .3, .1, 1.], axis=2)
+
+        EXPECT_TRUE(xt::allclose(py_q0, xt::quantile(py_a, {0., .3, .1, 1.}, 0)));
+        EXPECT_TRUE(xt::allclose(py_q1, xt::quantile(py_a, {0., .3, .1, 1.}, 1)));
+        EXPECT_TRUE(xt::allclose(py_q2, xt::quantile(py_a, {0., .3, .1, 1.}, 2)));
+    }
+
+    /*py
+    a = np.random.rand(4, 5, 6)
+    */
+    TEST(xtest_extended, quantile_methods)
+    {
+        // py_a
+
+        // py_q4 = np.quantile(a, [0., .3, .1, 1.], method="interpolated_inverted_cdf")
+        // py_q5 = np.quantile(a, [0., .3, .1, 1.], method="hazen")
+        // py_q6 = np.quantile(a, [0., .3, .1, 1.], method="weibull")
+        // py_q7 = np.quantile(a, [0., .3, .1, 1.], method="linear")
+        // py_q8 = np.quantile(a, [0., .3, .1, 1.], method="median_unbiased")
+        // py_q9 = np.quantile(a, [0., .3, .1, 1.], method="normal_unbiased")
+
+        EXPECT_TRUE(
+            xt::allclose(
+                py_q4,
+                xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::interpolated_inverted_cdf)
+            )
+        );
+        EXPECT_TRUE(
+            xt::allclose(py_q5, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::hazen))
+        );
+        EXPECT_TRUE(
+            xt::allclose(py_q6, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::weibull))
+        );
+        EXPECT_TRUE(
+            xt::allclose(py_q7, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::linear))
+        );
+        EXPECT_TRUE(
+            xt::allclose(
+                py_q8,
+                xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::median_unbiased)
+            )
+        );
+        EXPECT_TRUE(
+            xt::allclose(
+                py_q9,
+                xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::normal_unbiased)
+            )
+        );
+    }
+
+    /*py
+    a = np.random.rand(5, 5, 5)
+    */
+    TEST(xtest_extended, axis_median)
+    {
+        // py_a
+        // py_m = np.median(a)
+
+        // py_m0 = np.median(a, 0)
+        // py_m1 = np.median(a, 1)
+        // py_m2 = np.median(a, 2)
+
+        EXPECT_EQ(py_m, xt::median(py_a));
+        EXPECT_EQ(py_m0, xt::median(py_a, 0));
+        EXPECT_EQ(py_m1, xt::median(py_a, 1));
+        EXPECT_EQ(py_m2, xt::median(py_a, 2));
+    }
+
+    /*py
+    a = np.random.permutation(np.arange(5 * 5 * 5)).reshape(5, 5, 5)
+    */
+    TEST(xtest_extended, axis_partition)
+    {
+        // py_a
+
+        // py_p0 = np.partition(a, 2, 0)
+        // py_p1 = np.partition(a, 4, 1)
+        // py_p2 = np.partition(a, 3, 2)
+
+        auto p0 = xt::partition(py_a, 2, 0);
+        auto p1 = xt::partition(py_a, 4, 1);
+        auto p2 = xt::partition(py_a, 3, 2);
+
+        EXPECT_EQ(xt::view(py_p0, 2, all(), all()), xt::view(p0, 2, all(), all()));
+        EXPECT_EQ(xt::view(py_p1, all(), 4, all()), xt::view(p1, all(), 4, all()));
+        EXPECT_EQ(xt::view(py_p2, all(), all(), 3), xt::view(p2, all(), all(), 3));
+
+        // py_a0 = np.argpartition(a, 2, 0)
+        // py_a1 = np.argpartition(a, 4, 1)
+        // py_a2 = np.argpartition(a, 3, 2)
+
+        auto a0 = xt::argpartition(py_a, 2, 0);
+        auto a1 = xt::argpartition(py_a, 4, 1);
+        auto a2 = xt::argpartition(py_a, 3, 2);
+
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a0, 2, all(), all())), xt::view(a0, 2, all(), all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a1, all(), 4, all())), xt::view(a1, all(), 4, all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a2, all(), all(), 3)), xt::view(a2, all(), all(), 3));
+    }
+
+    /*py
+    a = np.random.permutation(np.arange(5 * 5 * 5)).reshape(5, 5, 5)
+    */
+    TEST(xtest_extended, multi_k_axis_partition)
+    {
+        // py_a
+
+        // py_p0 = np.partition(a, (1, 2), 0)
+        // py_p1 = np.partition(a, (1, 4), 1)
+        // py_p2 = np.partition(a, (1, 3), 2)
+
+        auto p0 = xt::partition(py_a, {1, 2}, 0);
+        auto p1 = xt::partition(py_a, {1, 4}, 1);
+        auto p2 = xt::partition(py_a, {1, 3}, 2);
+
+        EXPECT_EQ(xt::view(py_p0, 2, all(), all()), xt::view(p0, 2, all(), all()));
+        EXPECT_EQ(xt::view(py_p1, all(), 4, all()), xt::view(p1, all(), 4, all()));
+        EXPECT_EQ(xt::view(py_p2, all(), all(), 3), xt::view(p2, all(), all(), 3));
+
+        EXPECT_EQ(xt::view(py_p0, 1, all(), all()), xt::view(p0, 1, all(), all()));
+        EXPECT_EQ(xt::view(py_p1, all(), 1, all()), xt::view(p1, all(), 1, all()));
+        EXPECT_EQ(xt::view(py_p2, all(), all(), 1), xt::view(p2, all(), all(), 1));
+
+        // py_a0 = np.argpartition(a, (1, 2), 0)
+        // py_a1 = np.argpartition(a, (1, 4), 1)
+        // py_a2 = np.argpartition(a, (1, 3), 2)
+
+        auto a0 = xt::argpartition(py_a, {1, 2}, 0);
+        auto a1 = xt::argpartition(py_a, {1, 4}, 1);
+        auto a2 = xt::argpartition(py_a, {1, 3}, 2);
+
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a0, 2, all(), all())), xt::view(a0, 2, all(), all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a1, all(), 4, all())), xt::view(a1, all(), 4, all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a2, all(), all(), 3)), xt::view(a2, all(), all(), 3));
+
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a0, 1, all(), all())), xt::view(a0, 1, all(), all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a1, all(), 1, all())), xt::view(a1, all(), 1, all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a2, all(), all(), 1)), xt::view(a2, all(), all(), 1));
+    }
+}
diff --git a/test/files/generate.py b/test/files/generate.py
index 6b1405975..ccb5aa01f 100644
--- a/test/files/generate.py
+++ b/test/files/generate.py
@@ -7,10 +7,10 @@
 include_file = "#include <string>\n\n"
 
 for f in fs:
-	with open(f) as ff:
-		ctn = ff.read()
-		n = f.split("/")[1]
-		include_file += "static std::string {} = R\"xio({})xio\";\n\n\n".format(n[:-4], ctn)
+    with open(f) as ff:
+        ctn = ff.read()
+        n = f.split("/")[1]
+        include_file += "static std::string {} = R\"xio({})xio\";\n\n\n".format(n[:-4], ctn)
 
 with open("xio_expected_results.hpp", "w+") as fo:
-	fo.write(include_file)
\ No newline at end of file
+    fo.write(include_file)
diff --git a/test/files/preprocess.py b/test/files/preprocess.py
index b3a21abbd..9152963fc 100644
--- a/test/files/preprocess.py
+++ b/test/files/preprocess.py
@@ -47,65 +47,68 @@ def get_cpp_initlist(arr, name):
 
 
 def translate_file(contents, f):
-	current_vars = {}
-
-	matches = re.findall(r"\/\*py.*?\*\/", contents, re.MULTILINE | re.DOTALL)
-
-	def exec_comment(txt, upper_level=False):
-		lines = txt.split('\n')
-		if upper_level:
-			txt = '\n'.join(["import numpy as np"] + [x.strip() for x in lines[1:-1]])
-		locals_before = list(locals().keys())
-		exec(txt, globals(), current_vars)
-		current_vars.update(
-			{x: val for x, val in locals().items() if x not in locals_before}
-		)
-
-	result_file = ""
-
-	idx = 0
-	lidx = 0
-	for line in contents.split('\n'):
-		if lidx == 8:
-			f = os.path.split(f)[1]
-			result_file += "// This file is generated from test/files/cppy_source/{} by preprocess.py!".format(f) + '\n\n'
-		lstrip = line.lstrip()
-		if lstrip.startswith("/*py"):
-			exec_comment(matches[idx], True)
-			idx += 1
-		if lstrip.startswith("// py_"):
-			indent_n = len(line) - len(lstrip)
-			if '=' in lstrip:
-				exec_comment(lstrip[6:])
-				var = line.strip()[6:lstrip.index('=')].strip()
-			else:
-				var = line.strip()[6:]
-			indent = line[:indent_n]
-			init_list = get_cpp_initlist(current_vars[var], 'py_' + var)
-			init_list = '\n'.join([indent + x for x in init_list.split('\n')])
-			result_file += line + '\n'
-			result_file += init_list + '\n'
-		else:
-			result_file += line + '\n'
-		lidx += 1
-	return result_file
+    current_vars = {}
+
+    matches = re.findall(r"\/\*py.*?\*\/", contents, re.MULTILINE | re.DOTALL)
+
+    def exec_comment(txt, upper_level=False):
+        lines = txt.split('\n')
+        if upper_level:
+            txt = '\n'.join(["import numpy as np"] + [x.strip() for x in lines[1:-1]])
+        locals_before = list(locals().keys())
+        exec(txt, globals(), current_vars)
+        current_vars.update(
+            {x: val for x, val in locals().items() if x not in locals_before}
+        )
+
+    result_file = ""
+
+    idx = 0
+    lidx = 0
+    for line in contents.split('\n'):
+        if lidx == 8:
+            f = os.path.split(f)[1]
+            result_file += "// This file is generated from test/files/cppy_source/{} by preprocess.py!\n".format(f)
+            result_file += "// Warning: This file should not be modified directly! " \
+                           "Instead, modify the `*.cppy` file.\n\n"
+
+        lstrip = line.lstrip()
+        if lstrip.startswith("/*py"):
+            exec_comment(matches[idx], True)
+            idx += 1
+        if lstrip.startswith("// py_"):
+            indent_n = len(line) - len(lstrip)
+            if '=' in lstrip:
+                exec_comment(lstrip[6:])
+                var = line.strip()[6:lstrip.index('=')].strip()
+            else:
+                var = line.strip()[6:]
+            indent = line[:indent_n]
+            init_list = get_cpp_initlist(current_vars[var], 'py_' + var)
+            init_list = '\n'.join([indent + x for x in init_list.split('\n')])
+            result_file += line + '\n'
+            result_file += init_list + '\n'
+        else:
+            result_file += line + '\n'
+        lidx += 1
+    return result_file
 
 print("::: PREPROCESSING :::\n")
 
 for f in cppy_files:
-	print(" - PROCESSING {}".format(f))
-
-	global current_vars
-	current_vars = {}  # reset
-
-	with open(f) as fi:
-		contents = fi.read()
-
-	# reset global seed
-	np.random.seed(42)
-	result = translate_file(contents, f)
-	f_result = os.path.split(f)[1]
-	with open(my_path + "/../" + f_result[:-1], 'w+') as fo:
-		fo.write(result)
-	print("::: DONE :::")
-	# print(result)
+    print(" - PROCESSING {}".format(f))
+
+    global current_vars
+    current_vars = {}  # reset
+
+    with open(f) as fi:
+        contents = fi.read()
+
+    # reset global seed
+    np.random.seed(42)
+    result = translate_file(contents, f)
+    f_result = os.path.split(f)[1]
+    with open(my_path + "/../" + f_result[:-1], 'w+') as fo:
+        fo.write(result)
+    print("::: DONE :::")
+    # print(result)
diff --git a/test/files/xio_expected_results.hpp b/test/files/xio_expected_results.hpp
index c0e0083d2..4ee25c35c 100644
--- a/test/files/xio_expected_results.hpp
+++ b/test/files/xio_expected_results.hpp
@@ -33,45 +33,45 @@ static std::string big_exp = R"xio({{ 4.259106e+000, -1.430581e+000,  3.817697e+
  {-1.194856e+000, -8.325470e+000,  4.246604e+000, -1.442730e+000}})xio";
 
 
-static std::string complex_numbers = R"xio({{ 4.259106-4.705763i, -1.430581+0.520437i,  3.817697-2.597525i, 
-   4.383006+3.84805i , -0.177621-0.397616i,  5.600555-3.068297i, 
-  -1.781513-2.063075i,  1.593886+3.179275i, -7.200985+0.594874i, 
+static std::string complex_numbers = R"xio({{ 4.259106-4.705763i, -1.430581+0.520437i,  3.817697-2.597525i,
+   4.383006+3.84805i , -0.177621-0.397616i,  5.600555-3.068297i,
+  -1.781513-2.063075i,  1.593886+3.179275i, -7.200985+0.594874i,
   -1.979649+1.779254i},
- { 2.54634 +3.091267i, -3.516982+3.685722i, -5.104814-0.820075i, 
-   3.895104-4.410618i,  1.878048-0.21541i ,  2.63584 +0.211594i, 
-  -1.194856+0.80632i , -8.32547 -1.90801i ,  4.246604+4.198826i, 
+ { 2.54634 +3.091267i, -3.516982+3.685722i, -5.104814-0.820075i,
+   3.895104-4.410618i,  1.878048-0.21541i ,  2.63584 +0.211594i,
+  -1.194856+0.80632i , -8.32547 -1.90801i ,  4.246604+4.198826i,
   -1.44273 +1.553475i},
- {-4.04439 -1.507586i, -0.158305+0.41094i ,  4.805928-0.509466i, 
-  -2.845422-2.17679i , -1.655801-2.041235i,  3.094426+0.63481i , 
-  -2.523971+2.151913i, -5.309743+0.176187i,  9.759906-1.479582i, 
+ {-4.04439 -1.507586i, -0.158305+0.41094i ,  4.805928-0.509466i,
+  -2.845422-2.17679i , -1.655801-2.041235i,  3.094426+0.63481i ,
+  -2.523971+2.151913i, -5.309743+0.176187i,  9.759906-1.479582i,
    5.319919+1.327789i},
- { 5.540089+3.73119i , -9.440361-3.321116i, -6.52187 +4.874783i, 
-  -6.918355-1.505851i, -8.45827 +3.262051i,  7.797314-4.345385i, 
-   5.007574-4.946467i,  3.868065+3.869446i,  0.235268+4.113181i, 
+ { 5.540089+3.73119i , -9.440361-3.321116i, -6.52187 +4.874783i,
+  -6.918355-1.505851i, -8.45827 +3.262051i,  7.797314-4.345385i,
+   5.007574-4.946467i,  3.868065+3.869446i,  0.235268+4.113181i,
   -0.714639-3.005922i},
- { 1.368614-4.724486i, -3.949011+3.173349i, -0.053824-2.581724i, 
-   3.665258-4.43917i ,  8.333974-4.324392i, -7.821421-0.261281i, 
-  -0.090164+0.094293i, -5.343281-0.832049i, -1.262787-2.441571i, 
+ { 1.368614-4.724486i, -3.949011+3.173349i, -0.053824-2.581724i,
+   3.665258-4.43917i ,  8.333974-4.324392i, -7.821421-0.261281i,
+  -0.090164+0.094293i, -5.343281-0.832049i, -1.262787-2.441571i,
    5.03086 -1.184879i},
- {-0.382158+3.073844i,  5.954568+3.110391i, -4.345941+1.861869i, 
-  -1.331635+4.926136i, -9.804853-0.948148i, -3.18408 -3.098263i, 
-   3.78544 -0.118255i,  7.387386+0.023696i, -4.643924-0.966452i, 
+ {-0.382158+3.073844i,  5.954568+3.110391i, -4.345941+1.861869i,
+  -1.331635+4.926136i, -9.804853-0.948148i, -3.18408 -3.098263i,
+   3.78544 -0.118255i,  7.387386+0.023696i, -4.643924-0.966452i,
   -0.865042-3.189046i},
- {-4.634374-4.519702i,  6.741056+1.046913i, -4.589707-2.340888i, 
-   0.60124 +3.81347i , -6.492547+0.840461i, -3.700671-0.225395i, 
-   7.822182-3.28485i , -6.393274-4.4338i  , -0.113676-3.429648i, 
+ {-4.634374-4.519702i,  6.741056+1.046913i, -4.589707-2.340888i,
+   0.60124 +3.81347i , -6.492547+0.840461i, -3.700671-0.225395i,
+   7.822182-3.28485i , -6.393274-4.4338i  , -0.113676-3.429648i,
   -5.754038-1.613825i},
- { 0.417537-0.59357i , -6.798001+1.838431i,  8.381136-2.941283i, 
-   9.885798+1.164337i, -0.459049+4.244716i, -3.80233 -4.203717i, 
-   0.144086-0.146032i, -4.384136+1.985636i,  5.276734-4.184315i, 
+ { 0.417537-0.59357i , -6.798001+1.838431i,  8.381136-2.941283i,
+   9.885798+1.164337i, -0.459049+4.244716i, -3.80233 -4.203717i,
+   0.144086-0.146032i, -4.384136+1.985636i,  5.276734-4.184315i,
   -7.829154+3.691024i},
- { 0.233094-0.668943i,  8.195388-0.056699i, -5.63248 -0.042595i, 
-  -2.737919-1.292779i,  7.099456+4.221287i,  4.227836+3.412782i, 
-  -2.141112+1.555259i, -5.37397 -0.37315i , -2.396506+0.650113i, 
+ { 0.233094-0.668943i,  8.195388-0.056699i, -5.63248 -0.042595i,
+  -2.737919-1.292779i,  7.099456+4.221287i,  4.227836+3.412782i,
+  -2.141112+1.555259i, -5.37397 -0.37315i , -2.396506+0.650113i,
    0.983242-0.760845i},
- { 1.134381-2.117881i, -9.917307-2.360193i,  2.76045 +1.907382i, 
-  -8.84704 +3.328365i, -9.139462+0.923916i,  7.501023-0.334774i, 
-  -4.148248+1.7366i  ,  5.255353-1.085206i, -2.642695+2.021044i, 
+ { 1.134381-2.117881i, -9.917307-2.360193i,  2.76045 +1.907382i,
+  -8.84704 +3.328365i, -9.139462+0.923916i,  7.501023-0.334774i,
+  -4.148248+1.7366i  ,  5.255353-1.085206i, -2.642695+2.021044i,
    7.470045+4.656976i}})xio";
 
 
@@ -85,7 +85,7 @@ static std::string cut_long = R"xio({{1, 1, 1, ..., 1, 1, 1},
 static std::string cut_both = R"xio({{1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
- ..., 
+ ...,
  {1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1}})xio";
@@ -94,259 +94,259 @@ static std::string cut_both = R"xio({{1, 1, 1, ..., 1, 1, 1},
 static std::string cut_4d = R"xio({{{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
- ..., 
+ ...,
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}}})xio";
@@ -356,221 +356,212 @@ static std::string random_strings = R"xio({{          some,         random,
  {       strings,             in, xtensor xarray}})xio";
 
 
-static std::string float_leading_zero = R"xio({{ 0.212955, -0.071529,  0.190885,  0.21915 , -0.008881,  0.280028, 
+static std::string float_leading_zero = R"xio({{ 0.212955, -0.071529,  0.190885,  0.21915 , -0.008881,  0.280028,
   -0.089076,  0.079694, -0.360049, -0.098982},
- { 0.127317, -0.175849, -0.255241,  0.194755,  0.093902,  0.131792, 
+ { 0.127317, -0.175849, -0.255241,  0.194755,  0.093902,  0.131792,
   -0.059743, -0.416274,  0.21233 , -0.072137},
- {-0.20222 , -0.007915,  0.240296, -0.142271, -0.08279 ,  0.154721, 
+ {-0.20222 , -0.007915,  0.240296, -0.142271, -0.08279 ,  0.154721,
   -0.126199, -0.265487,  0.487995,  0.265996},
- { 0.277004, -0.472018, -0.326093, -0.345918, -0.422914,  0.389866, 
+ { 0.277004, -0.472018, -0.326093, -0.345918, -0.422914,  0.389866,
    0.250379,  0.193403,  0.011763, -0.035732},
- { 0.068431, -0.197451, -0.002691,  0.183263,  0.416699, -0.391071, 
+ { 0.068431, -0.197451, -0.002691,  0.183263,  0.416699, -0.391071,
   -0.004508, -0.267164, -0.063139,  0.251543},
- {-0.019108,  0.297728, -0.217297, -0.066582, -0.490243, -0.159204, 
+ {-0.019108,  0.297728, -0.217297, -0.066582, -0.490243, -0.159204,
    0.189272,  0.369369, -0.232196, -0.043252},
- {-0.231719,  0.337053, -0.229485,  0.030062, -0.324627, -0.185034, 
+ {-0.231719,  0.337053, -0.229485,  0.030062, -0.324627, -0.185034,
    0.391109, -0.319664, -0.005684, -0.287702},
- { 0.020877, -0.3399  ,  0.419057,  0.49429 , -0.022952, -0.190116, 
+ { 0.020877, -0.3399  ,  0.419057,  0.49429 , -0.022952, -0.190116,
    0.007204, -0.219207,  0.263837, -0.391458},
- { 0.011655,  0.409769, -0.281624, -0.136896,  0.354973,  0.211392, 
+ { 0.011655,  0.409769, -0.281624, -0.136896,  0.354973,  0.211392,
   -0.107056, -0.268699, -0.119825,  0.049162},
- { 0.056719, -0.495865,  0.138023, -0.442352, -0.456973,  0.375051, 
+ { 0.056719, -0.495865,  0.138023, -0.442352, -0.456973,  0.375051,
   -0.207412,  0.262768, -0.132135,  0.373502}})xio";
 
 
 static std::string cut_high = R"xio({{1},
  {1},
  {1},
- ..., 
+ ...,
  {1},
  {1},
  {1}})xio";
 
 
-static std::string random_nan_inf = R"xio({{ 4.259106, -1.430581,  3.817697,  4.383006, -0.177621,  5.600555, 
-  -1.781513,  1.593886, -7.200985, -1.979649,  2.54634 , -3.516982, 
-  -5.104814,  3.895104,  1.878048,  2.63584 , -1.194856, -8.32547 , 
+static std::string random_nan_inf = R"xio({{ 4.259106, -1.430581,  3.817697,  4.383006, -0.177621,  5.600555,
+  -1.781513,  1.593886, -7.200985, -1.979649,  2.54634 , -3.516982,
+  -5.104814,  3.895104,  1.878048,  2.63584 , -1.194856, -8.32547 ,
    4.246604, -1.44273 },
- {-4.04439 , -1.      ,  1.      , -2.845422, -1.655801,  3.094426, 
-  -2.523971, -5.309743,  9.759906,  5.319919,  5.540089, -9.440361, 
-  -6.52187 , -6.918355, -8.45827 ,  7.797314,  5.007574,  3.868065, 
+ {-4.04439 , -1.      ,  1.      , -2.845422, -1.655801,  3.094426,
+  -2.523971, -5.309743,  9.759906,  5.319919,  5.540089, -9.440361,
+  -6.52187 , -6.918355, -8.45827 ,  7.797314,  5.007574,  3.868065,
    0.235268, -0.714639},
- { 1.368614, -3.949011,       inf,      -inf,  8.333974, -7.821421, 
-  -0.090164, -5.343281, -1.262787,  5.03086 , -0.382158,  5.954568, 
-  -4.345941, -1.331635, -9.804853, -3.18408 ,  3.78544 ,  7.387386, 
+ { 1.368614, -3.949011,       inf,      -inf,  8.333974, -7.821421,
+  -0.090164, -5.343281, -1.262787,  5.03086 , -0.382158,  5.954568,
+  -4.345941, -1.331635, -9.804853, -3.18408 ,  3.78544 ,  7.387386,
   -4.643924, -0.865042},
- {-4.634374,  6.741056, -4.589707,  0.60124 , -6.492547, -3.700671, 
-   7.822182, -6.393274, -0.113676, -5.754038,  0.417537, -6.798001, 
-   8.381136,  9.885798, -0.459049, -3.80233 ,  0.144086, -4.384136, 
+ {-4.634374,  6.741056, -4.589707,  0.60124 , -6.492547, -3.700671,
+   7.822182, -6.393274, -0.113676, -5.754038,  0.417537, -6.798001,
+   8.381136,  9.885798, -0.459049, -3.80233 ,  0.144086, -4.384136,
    5.276734, -7.829154},
- { 0.233094,  8.195388, -5.63248 , -2.737919,       nan,  4.227836, 
-  -2.141112, -5.37397 , -2.396506,  0.983242,  1.134381, -9.917307, 
-   2.76045 , -8.84704 , -9.139462,  7.501023, -4.148248,  5.255353, 
+ { 0.233094,  8.195388, -5.63248 , -2.737919,       nan,  4.227836,
+  -2.141112, -5.37397 , -2.396506,  0.983242,  1.134381, -9.917307,
+   2.76045 , -8.84704 , -9.139462,  7.501023, -4.148248,  5.255353,
   -2.642695,  7.470045},
- {-9.411525,  1.040874, -5.19505 ,  7.6961  , -0.795232, -6.136593, 
-  -4.12615 ,  6.35855 ,  1.189747,  3.558509,  6.182534,  7.371443, 
-  -1.640151, -8.821237, -0.43082 ,  0.423189,  1.61264 , -3.81602 , 
+ {-9.411525,  1.040874, -5.19505 ,  7.6961  , -0.795232, -6.136593,
+  -4.12615 ,  6.35855 ,  1.189747,  3.558509,  6.182534,  7.371443,
+  -1.640151, -8.821237, -0.43082 ,  0.423189,  1.61264 , -3.81602 ,
    8.397652,  3.10695 },
- {-3.015172,  0.821881, -1.018932, -4.353581, -4.08247 ,  1.26962 , 
-   4.303826,  0.352374, -2.959163,  2.655577,  7.462381, -6.642231, 
-   9.749566, -3.011701,  6.524103, -8.690769, -9.892934,  7.738893, 
+ {-3.015172,  0.821881, -1.018932, -4.353581, -4.08247 ,  1.26962 ,
+   4.303826,  0.352374, -2.959163,  2.655577,  7.462381, -6.642231,
+   9.749566, -3.011701,  6.524103, -8.690769, -9.892934,  7.738893,
    8.226363, -6.011844},
- {-9.448972,  6.346698, -5.163448, -8.87834 , -8.648783, -0.522563, 
-   0.188585, -1.664097, -4.883141, -2.369758,  6.147689,  6.220783, 
-   3.723737,  9.852273, -1.896296, -6.196526, -0.23651 ,  0.047393, 
+ {-9.448972,  6.346698, -5.163448, -8.87834 , -8.648783, -0.522563,
+   0.188585, -1.664097, -4.883141, -2.369758,  6.147689,  6.220783,
+   3.723737,  9.852273, -1.896296, -6.196526, -0.23651 ,  0.047393,
   -1.932904, -6.378091},
- {-9.039404,  2.093827, -4.681776,  7.62694 ,  1.680922, -0.45079 , 
-  -6.5697  , -8.8676  , -6.859295, -3.22765 , -1.187141,  3.676862, 
-  -5.882566,  2.328674,  8.489432, -8.407435, -0.292063,  3.971273, 
+ {-9.039404,  2.093827, -4.681776,  7.62694 ,  1.680922, -0.45079 ,
+  -6.5697  , -8.8676  , -6.859295, -3.22765 , -1.187141,  3.676862,
+  -5.882566,  2.328674,  8.489432, -8.407435, -0.292063,  3.971273,
   -8.36863 ,  7.382047},
- {-1.337886, -0.113399, -0.085191, -2.585558,  8.442573,  6.825565, 
-   3.110518, -0.746299,  1.300226, -1.52169 , -4.235761, -4.720386, 
-   3.814765,  6.656731,  1.847831, -0.669548,  3.4732  , -2.170413, 
+ {-1.337886, -0.113399, -0.085191, -2.585558,  8.442573,  6.825565,
+   3.110518, -0.746299,  1.300226, -1.52169 , -4.235761, -4.720386,
+   3.814765,  6.656731,  1.847831, -0.669548,  3.4732  , -2.170413,
    4.042087,  9.313953},
- {-8.189802, -8.837497,  1.760348,  5.023475,  0.226348,  8.410024, 
-  -3.920718, -0.139945,  9.587207, -3.529835, -6.208657, -3.895418, 
-  -3.117761,  3.590606, -8.9237  ,  6.132075,  2.059004,  3.104264, 
+ {-8.189802, -8.837497,  1.760348,  5.023475,  0.226348,  8.410024,
+  -3.920718, -0.139945,  9.587207, -3.529835, -6.208657, -3.895418,
+  -3.117761,  3.590606, -8.9237  ,  6.132075,  2.059004,  3.104264,
    4.953196,  0.712524},
- {-7.81687 , -0.076074, -6.553148,  3.679784,  0.596504,  2.504485, 
-  -3.69714 , -0.169787,  6.402841, -7.347591, -7.57381 , -1.075701, 
-  -9.181317, -3.989666, -1.812192, -2.549612, -3.200597,  6.251402, 
+ {-7.81687 , -0.076074, -6.553148,  3.679784,  0.596504,  2.504485,
+  -3.69714 , -0.169787,  6.402841, -7.347591, -7.57381 , -1.075701,
+  -9.181317, -3.989666, -1.812192, -2.549612, -3.200597,  6.251402,
    0.564111,  1.076542},
- {-7.655863,  5.692096, -1.308276, -8.455545, -6.363769,  0.420217, 
-  -0.413317, -3.72915 , -8.006616,  1.931053, -5.036602,  2.086803, 
-  -3.897727,  7.946099,  1.640307,  4.249848,  3.672309,  8.932418, 
+ {-7.655863,  5.692096, -1.308276, -8.455545, -6.363769,  0.420217,
+  -0.413317, -3.72915 , -8.006616,  1.931053, -5.036602,  2.086803,
+  -3.897727,  7.946099,  1.640307,  4.249848,  3.672309,  8.932418,
    8.264625, -8.974902},
- {-2.39369 ,  1.277131, -7.348525,  1.502706, -3.548645,  9.678551, 
-   1.513316,  2.594553, -1.979754,  4.892601, -1.976282,  5.309503, 
-   9.648625, -6.637665, -0.508106,  0.97881 , -1.277853, -4.065374, 
+ {-2.39369 ,  1.277131, -7.348525,  1.502706, -3.548645,  9.678551,
+   1.513316,  2.594553, -1.979754,  4.892601, -1.976282,  5.309503,
+   9.648625, -6.637665, -0.508106,  0.97881 , -1.277853, -4.065374,
   -2.128725,  6.761622},
- { 3.032851,  9.077939, -0.459995,  7.577871,  5.844156, -4.69285 , 
-   5.248765,  6.454728, -2.940153,  9.48464 ,  3.504667,  3.987593, 
-  -0.808062, -8.605302,  9.959603,  2.755019, -8.636948, -7.077259, 
+ { 3.032851,  9.077939, -0.459995,  7.577871,  5.844156, -4.69285 ,
+   5.248765,  6.454728, -2.940153,  9.48464 ,  3.504667,  3.987593,
+  -0.808062, -8.605302,  9.959603,  2.755019, -8.636948, -7.077259,
    6.778265, -4.456102},
- { 0.789019, -8.391345,  1.326935, -2.750302, -3.635727,  3.070465, 
-  -2.90194 ,  4.305136,  2.56563 ,  9.350227, -4.37165 , -5.072099, 
-  -8.449633,  7.84151 , -9.3091  , -0.170497, -9.981909,  7.783972, 
+ { 0.789019, -8.391345,  1.326935, -2.750302, -3.635727,  3.070465,
+  -2.90194 ,  4.305136,  2.56563 ,  9.350227, -4.37165 , -5.072099,
+  -8.449633,  7.84151 , -9.3091  , -0.170497, -9.981909,  7.783972,
   -3.212051,  2.616364},
- {-3.385869,  7.779795,  4.586448, -8.113584,  4.134024,  7.608333, 
-   0.810756,  9.514617, -0.599935, -9.215927,  0.269787,  0.436816, 
-   1.589945,  6.745015, -2.984754,  8.22778 , -1.991758, -2.205407, 
+ {-3.385869,  7.779795,  4.586448, -8.113584,  4.134024,  7.608333,
+   0.810756,  9.514617, -0.599935, -9.215927,  0.269787,  0.436816,
+   1.589945,  6.745015, -2.984754,  8.22778 , -1.991758, -2.205407,
   -1.954704, -7.920165},
- {-0.681457,  2.961423, -4.046124,  7.84679 , -0.428581, -4.352744, 
-  -1.629202, -1.682069,  5.426159,  4.759028, -0.535463,  0.037947, 
-   6.713306,  4.397586,  0.211848,  4.890704, -3.313785,  0.839388, 
+ {-0.681457,  2.961423, -4.046124,  7.84679 , -0.428581, -4.352744,
+  -1.629202, -1.682069,  5.426159,  4.759028, -0.535463,  0.037947,
+   6.713306,  4.397586,  0.211848,  4.890704, -3.313785,  0.839388,
    1.601047, -8.551511},
- { 3.58872 ,  4.407113,  1.049608,  0.099257, -8.345609,  1.612125, 
-   2.578687,  1.733626,  4.454039, -8.312231,  9.610947, -7.572344, 
-  -7.769007,  0.116085, -1.100301, -6.350003, -1.589225,  7.378157, 
+ { 3.58872 ,  4.407113,  1.049608,  0.099257, -8.345609,  1.612125,
+   2.578687,  1.733626,  4.454039, -8.312231,  9.610947, -7.572344,
+  -7.769007,  0.116085, -1.100301, -6.350003, -1.589225,  7.378157,
    5.114439, -7.273815},
- {-6.417325,  1.029412,  1.246413, -1.370279, -2.788699,  0.373218, 
-  -1.76683 , -9.41086 , -8.920649, -7.659411,  2.569412, -1.410808, 
-  -7.417977, -2.567283,  5.480396,  4.847727, -8.649269,  4.136584, 
+ {-6.417325,  1.029412,  1.246413, -1.370279, -2.788699,  0.373218,
+  -1.76683 , -9.41086 , -8.920649, -7.659411,  2.569412, -1.410808,
+  -7.417977, -2.567283,  5.480396,  4.847727, -8.649269,  4.136584,
   -3.603764,  9.610047}})xio";
 
 
-static std::string print_options_result = R"xio({{ 4.2591064316, -1.4305814994,  3.8176970288,  4.3830061776, -0.1776213445,  5.6005552105, -1.7815126386,  1.5938859511, -7.2009847337, -1.9796489161, ..., 
+static std::string print_options_result = R"xio({{ 4.2591064316, -1.4305814994,  3.8176970288,  4.3830061776, -0.1776213445,  5.6005552105, -1.7815126386,  1.5938859511, -7.2009847337, -1.9796489161, ...,
    1.1343811765, -9.9173071655,  2.760450376 , -8.8470396411, -9.139461943 ,  7.5010227444, -4.1482478699,  5.2553532664, -2.6426947385,  7.4700453614},
- {-9.4115253654,  1.0408744899, -5.1950499364,  7.6961002039, -0.7952315019, -6.1365934617, -4.1261498917,  6.3585501702,  1.1897474893,  3.5585089605, ..., 
+ {-9.4115253654,  1.0408744899, -5.1950499364,  7.6961002039, -0.7952315019, -6.1365934617, -4.1261498917,  6.3585501702,  1.1897474893,  3.5585089605, ...,
   -4.2357610156, -4.7203856627,  3.8147645182,  6.6567306578,  1.8478314906, -0.6695482385,  3.4731996107, -2.1704128909,  4.0420874091,  9.3139529141},
- {-8.1898023489, -8.8374973132,  1.7603482476,  5.0234750844,  0.2263477806,  8.4100238586, -3.9207180445, -0.139945379 ,  9.5872069321, -3.5298347424, ..., 
+ {-8.1898023489, -8.8374973132,  1.7603482476,  5.0234750844,  0.2263477806,  8.4100238586, -3.9207180445, -0.139945379 ,  9.5872069321, -3.5298347424, ...,
    3.5046670094,  3.9875929331, -0.8080616344, -8.6053016645,  9.9596034323,  2.7550191523, -8.6369483274, -7.0772591799,  6.7782654526, -4.4561017137},
- { 0.7890194329, -8.3913445067,  1.3269347791, -2.7503017751, -3.6357272732,  3.0704652279, -2.9019400135,  4.3051361271,  2.5656298621,  9.3502266157, ..., 
+ { 0.7890194329, -8.3913445067,  1.3269347791, -2.7503017751, -3.6357272732,  3.0704652279, -2.9019400135,  4.3051361271,  2.5656298621,  9.3502266157, ...,
    2.5694116162, -1.4108075651, -7.4179767494, -2.5672834157,  5.4803960597,  4.8477269726, -8.6492687081,  4.1365841284, -3.6037635514,  9.6100473723},
- {-6.8688488358, -5.9147360722, -0.3254980504, -0.4432930783, -8.6451064241,  0.4825582218,  6.4742113124, -1.5333826165,  1.6238035236,  5.0456922596, ..., 
+ {-6.8688488358, -5.9147360722, -0.3254980504, -0.4432930783, -8.6451064241,  0.4825582218,  6.4742113124, -1.5333826165,  1.6238035236,  5.0456922596, ...,
   -8.907970271 ,  0.18649803  , -9.9543102044, -6.2819204702,  5.3891564207, -3.3120201622, -4.3563841708, -2.219026429 ,  1.3871931164,  1.2869286246},
- {-6.3042710386, -7.8792950167,  4.8002785251,  5.9913866833,  6.2776804059,  9.7214889689,  5.4955589139,  5.6252921014,  7.577437609 ,  7.257547502 , ..., 
+ {-6.3042710386, -7.8792950167,  4.8002785251,  5.9913866833,  6.2776804059,  9.7214889689,  5.4955589139,  5.6252921014,  7.577437609 ,  7.257547502 , ...,
    8.5663364244,  6.7513786277,  4.5776524274,  1.9506977271,  3.0531497184,  4.2059602795,  3.0692081464, -0.3337777986, -1.1924831894,  5.5755222404},
- {-9.9360143174, -7.8252918939,  0.9357223565, -0.4318962485, -7.4969360956,  8.7757765577,  5.490149909 , -2.9660779553,  5.2321713202,  3.1286268453, ..., 
+ {-9.9360143174, -7.8252918939,  0.9357223565, -0.4318962485, -7.4969360956,  8.7757765577,  5.490149909 , -2.9660779553,  5.2321713202,  3.1286268453, ...,
   -0.7865411543,  7.0944427163, -8.5003798672, -0.9705943392,  4.8865678277,  2.4922847975, -8.259579232 ,  4.8378875582,  0.5414670781,  1.876758001 },
- { 1.293892469 ,  7.8727186438, -4.972623397 , -3.5229320218,  3.3804633975,  5.8755820434, -7.2976530169, -2.5884345174,  3.4962291201,  2.5881180456, ..., 
+ { 1.293892469 ,  7.8727186438, -4.972623397 , -3.5229320218,  3.3804633975,  5.8755820434, -7.2976530169, -2.5884345174,  3.4962291201,  2.5881180456, ...,
   -8.3196069801, -5.8129397724,  3.5503994193,  1.912760341 , -2.9211608073, -1.0535730789,  9.0423519795,  2.0698228727,  0.6368620153,  6.9564823215},
- { 3.9358404762,  0.5809243981, -0.9498240938,  6.898440392 , -5.4818767592, -5.0017919505, -2.9829227958,  5.7145039411, -8.1874937034, -9.2677064906, ..., 
+ { 3.9358404762,  0.5809243981, -0.9498240938,  6.898440392 , -5.4818767592, -5.0017919505, -2.9829227958,  5.7145039411, -8.1874937034, -9.2677064906, ...,
    2.0794398741,  2.4170323022,  7.8038475493, -7.7127253907,  7.2106577371,  7.7389202457,  1.6675980486,  8.4511451276,  3.792580503 , -6.1656516322},
- { 9.0866831126,  5.9443540369,  7.1534989647, -7.508772471 , -8.0987910974,  3.4886813262,  2.1691338193, -2.2854097703, -6.8156659851, -0.1224009932, ..., 
+ { 9.0866831126,  5.9443540369,  7.1534989647, -7.508772471 , -8.0987910974,  3.4886813262,  2.1691338193, -2.2854097703, -6.8156659851, -0.1224009932, ...,
   -4.4368127712,  1.0803095673, -3.7147775314,  6.4971630142,  8.3919628599,  4.0877859866,  4.8276491821, -1.742215113 , -8.597945096 ,  6.8729988406},
- ..., 
- {-3.151856391 ,  2.4390118942,  9.8334549245,  2.8587256739, -4.083950175 , -6.1374355029,  0.7666708995,  8.8843617064, -4.0865416894,  3.460927625 , ..., 
+ ...,
+ {-3.151856391 ,  2.4390118942,  9.8334549245,  2.8587256739, -4.083950175 , -6.1374355029,  0.7666708995,  8.8843617064, -4.0865416894,  3.460927625 , ...,
    9.1923774994,  2.2861329136,  8.9983777704, -7.9231060177, -0.9049750831,  4.4464730624, -5.4762394472,  7.8770915099,  5.7033579537,  0.016548383 },
- {-2.4788852044,  1.1656576499,  6.5928665383, -6.1366555538, -8.6411857519,  5.2052450675, -3.5959077694,  3.3344935488, -2.2047991068,  9.3559814814, ..., 
+ {-2.4788852044,  1.1656576499,  6.5928665383, -6.1366555538, -8.6411857519,  5.2052450675, -3.5959077694,  3.3344935488, -2.2047991068,  9.3559814814, ...,
   -7.4537355115, -7.1201607588,  2.3992745913, -5.6769048416, -1.108305959 ,  6.1092005967, -3.526292617 , -3.031207394 , -3.2672616002,  6.2747284327},
- { 1.2279588003, -3.6163419543, -2.0786564667, -5.1491621651,  4.8967947546,  2.0128427608,  6.5801679558, -7.7133407724,  1.2911925826, -4.3470470189, ..., 
+ { 1.2279588003, -3.6163419543, -2.0786564667, -5.1491621651,  4.8967947546,  2.0128427608,  6.5801679558, -7.7133407724,  1.2911925826, -4.3470470189, ...,
    2.4885760741,  0.516281461 ,  2.0317043678,  9.8593572754,  9.39050558  , -6.5182817973, -6.2139035714, -6.892220281 , -4.4423667759,  0.2460085642},
- { 1.1550892391, -9.9888950269,  3.6677261546, -1.9225639445, -3.9742847089,  9.8369094525,  1.0094657806,  7.0237851259,  4.7613542349, -2.5126619176, ..., 
+ { 1.1550892391, -9.9888950269,  3.6677261546, -1.9225639445, -3.9742847089,  9.8369094525,  1.0094657806,  7.0237851259,  4.7613542349, -2.5126619176, ...,
   -8.4162629587, -3.24552804  , -3.5550699051,  8.5579495749,  4.0636289088, -3.1650726073,  4.791227718 , -6.6433645946,  6.1247442938, -2.3697889754},
- { 0.1790187416,  3.7869978784, -3.7214265386, -5.430811068 ,  0.0320440687,  7.9734318597, -8.3428800195,  8.4875692138, -8.0981588233,  5.1545232452, ..., 
+ { 0.1790187416,  3.7869978784, -3.7214265386, -5.430811068 ,  0.0320440687,  7.9734318597, -8.3428800195,  8.4875692138, -8.0981588233,  5.1545232452, ...,
    6.2912773739,  4.9564293744,  0.0382712411, -0.2348270118, -8.732937865 ,  8.8921533464, -2.630946671 ,  3.0153719251,  9.9166161566, -6.6299812283},
- { 9.1449987496,  2.4201323765,  5.8399717306,  8.0367330041, -9.7451837364,  1.6830851238, -2.1287651061, -6.8869386991, -3.0261938917,  9.1932040255, ..., 
+ { 9.1449987496,  2.4201323765,  5.8399717306,  8.0367330041, -9.7451837364,  1.6830851238, -2.1287651061, -6.8869386991, -3.0261938917,  9.1932040255, ...,
   -1.4246246026,  9.4138344923, -4.0763188341, -7.8716496381, -4.5449281491, -1.0316709948, -7.7429029029, -5.8385824545, -1.6484059172,  7.6987670572},
- {-3.2993450647,  0.1656660217, -5.741487258 ,  7.6658710517,  7.4421535525, -8.7237405417, -1.6565722798, -9.5092800257, -2.9103572582, -9.0512625226, ..., 
+ {-3.2993450647,  0.1656660217, -5.741487258 ,  7.6658710517,  7.4421535525, -8.7237405417, -1.6565722798, -9.5092800257, -2.9103572582, -9.0512625226, ...,
    0.956576245 , -2.1176214529,  1.224063253 ,  9.4574798674,  1.5253960498,  9.0468728933,  1.4632485328,  5.388738737 , -5.0804525812,  9.9405982276},
- {-3.8595565152,  3.9711250838, -0.7466613442, -7.8472288594, -9.7060944334,  5.8814551806,  1.5839099422, -3.2811630355, -2.5670295888, -2.2946266962, ..., 
+ {-3.8595565152,  3.9711250838, -0.7466613442, -7.8472288594, -9.7060944334,  5.8814551806,  1.5839099422, -3.2811630355, -2.5670295888, -2.2946266962, ...,
   -8.3226376255, -6.1266055234, -8.53220412  ,  0.0712064945, -8.6836749392,  1.1484328631, -9.9792581277, -7.8110753489,  9.4993486219,  6.8471466225},
- { 4.0164446191,  2.6124123025,  3.009438323 , -5.5299690191, -4.4891102742,  5.137638025 ,  5.7287509146, -2.275257769 ,  5.6551393668, -5.2959856257, ..., 
+ { 4.0164446191,  2.6124123025,  3.009438323 , -5.5299690191, -4.4891102742,  5.137638025 ,  5.7287509146, -2.275257769 ,  5.6551393668, -5.2959856257, ...,
   -0.671183266 ,  6.450851233 ,  1.0147749194, -4.3992512334, -5.7095954354,  7.7680651531,  2.5030521106,  6.6729805346,  5.0310323451, -7.5703964152},
- { 0.5886834152,  4.6679436689, -8.592678009 , -7.6868968194,  7.1161214125, -1.4239915896,  6.2509497685,  8.4953751982,  9.7493446122,  7.2939809954, ..., 
+ { 0.5886834152,  4.6679436689, -8.592678009 , -7.6868968194,  7.1161214125, -1.4239915896,  6.2509497685,  8.4953751982,  9.7493446122,  7.2939809954, ...,
    5.6044133488, -4.1291454101, -8.28053945  ,  3.5683828275, -1.2860306048, -9.0687648703,  3.8310462403, -9.0213947232,  2.1923222357, -6.3506701839}})xio";
 
 
 static std::string long_strings = R"xio({{some, random very long and very very, boring},
  {strings, in, xtensor xarray}})xio";
 
-static std::string bool_fn_rm = R"xio({{ true, false,  true,  true, false},
+static std::string bool_fn = R"xio({{ true, false,  true,  true, false},
  { true, false,  true, false, false},
  { true, false, false,  true,  true},
  { true, false, false,  true, false},
  {false, false,  true, false, false}})xio";
 
-static std::string bool_fn_cm = R"xio({{ true,  true,  true,  true, false},
- {false, false, false, false, false},
- { true,  true, false, false,  true},
- { true, false,  true,  true, false},
- {false, false,  true, false, false}})xio";
-
-
 static std::string custom_formatter_result = R"xio({{     0x1,      0x2,      0x3,      0x4},
  {    0x64,     0xc8,    0x3e8, 0x989680}})xio";
 
 
-static std::string complex_zero_erasing = R"xio({{ 0.212955-0.470576i, -0.071529+0.052044i,  0.190885-0.259752i, 
-   0.21915 +0.384805i, -0.008881-0.039762i,  0.280028-0.30683i , 
-  -0.089076-0.206307i,  0.079694+0.317928i, -0.360049+0.059487i, 
+static std::string complex_zero_erasing = R"xio({{ 0.212955-0.470576i, -0.071529+0.052044i,  0.190885-0.259752i,
+   0.21915 +0.384805i, -0.008881-0.039762i,  0.280028-0.30683i ,
+  -0.089076-0.206307i,  0.079694+0.317928i, -0.360049+0.059487i,
   -0.098982+0.177925i},
- { 0.127317+0.309127i, -0.175849+0.368572i, -0.255241-0.082008i, 
-   0.194755-0.441062i,  0.093902-0.021541i,  0.131792+0.021159i, 
-  -0.059743+0.080632i, -0.416274-0.190801i,  0.21233 +0.419883i, 
+ { 0.127317+0.309127i, -0.175849+0.368572i, -0.255241-0.082008i,
+   0.194755-0.441062i,  0.093902-0.021541i,  0.131792+0.021159i,
+  -0.059743+0.080632i, -0.416274-0.190801i,  0.21233 +0.419883i,
   -0.072137+0.155348i},
- {-0.20222 -0.150759i, -0.007915+0.041094i,  0.240296-0.050947i, 
-  -0.142271-0.217679i, -0.08279 -0.204123i,  0.154721+0.063481i, 
-  -0.126199+0.215191i, -0.265487+0.017619i,  0.487995-0.147958i, 
+ {-0.20222 -0.150759i, -0.007915+0.041094i,  0.240296-0.050947i,
+  -0.142271-0.217679i, -0.08279 -0.204123i,  0.154721+0.063481i,
+  -0.126199+0.215191i, -0.265487+0.017619i,  0.487995-0.147958i,
    0.265996+0.132779i},
- { 0.277004+0.373119i, -0.472018-0.332112i, -0.326093+0.487478i, 
-  -0.345918-0.150585i, -0.422914+0.326205i,  0.389866-0.434538i, 
-   0.250379-0.494647i,  0.193403+0.386945i,  0.011763+0.411318i, 
+ { 0.277004+0.373119i, -0.472018-0.332112i, -0.326093+0.487478i,
+  -0.345918-0.150585i, -0.422914+0.326205i,  0.389866-0.434538i,
+   0.250379-0.494647i,  0.193403+0.386945i,  0.011763+0.411318i,
   -0.035732-0.300592i},
- { 0.068431-0.472449i, -0.197451+0.317335i, -0.002691-0.258172i, 
-   0.183263-0.443917i,  0.416699-0.432439i, -0.391071-0.026128i, 
-  -0.004508+0.009429i, -0.267164-0.083205i, -0.063139-0.244157i, 
+ { 0.068431-0.472449i, -0.197451+0.317335i, -0.002691-0.258172i,
+   0.183263-0.443917i,  0.416699-0.432439i, -0.391071-0.026128i,
+  -0.004508+0.009429i, -0.267164-0.083205i, -0.063139-0.244157i,
    0.251543-0.118488i},
- {-0.019108+0.307384i,  0.297728+0.311039i, -0.217297+0.186187i, 
-  -0.066582+0.492614i, -0.490243-0.094815i, -0.159204-0.309826i, 
-   0.189272-0.011826i,  0.369369+0.00237i , -0.232196-0.096645i, 
+ {-0.019108+0.307384i,  0.297728+0.311039i, -0.217297+0.186187i,
+  -0.066582+0.492614i, -0.490243-0.094815i, -0.159204-0.309826i,
+   0.189272-0.011826i,  0.369369+0.00237i , -0.232196-0.096645i,
   -0.043252-0.318905i},
- {-0.231719-0.45197i ,  0.337053+0.104691i, -0.229485-0.234089i, 
-   0.030062+0.381347i, -0.324627+0.084046i, -0.185034-0.02254i , 
-   0.391109-0.328485i, -0.319664-0.44338i , -0.005684-0.342965i, 
+ {-0.231719-0.45197i ,  0.337053+0.104691i, -0.229485-0.234089i,
+   0.030062+0.381347i, -0.324627+0.084046i, -0.185034-0.02254i ,
+   0.391109-0.328485i, -0.319664-0.44338i , -0.005684-0.342965i,
   -0.287702-0.161383i},
- { 0.020877-0.059357i, -0.3399  +0.183843i,  0.419057-0.294128i, 
-   0.49429 +0.116434i, -0.022952+0.424472i, -0.190116-0.420372i, 
-   0.007204-0.014603i, -0.219207+0.198564i,  0.263837-0.418432i, 
+ { 0.020877-0.059357i, -0.3399  +0.183843i,  0.419057-0.294128i,
+   0.49429 +0.116434i, -0.022952+0.424472i, -0.190116-0.420372i,
+   0.007204-0.014603i, -0.219207+0.198564i,  0.263837-0.418432i,
   -0.391458+0.369102i},
- { 0.011655-0.066894i,  0.409769-0.00567i , -0.281624-0.00426i , 
-  -0.136896-0.129278i,  0.354973+0.422129i,  0.211392+0.341278i, 
-  -0.107056+0.155526i, -0.268699-0.037315i, -0.119825+0.065011i, 
+ { 0.011655-0.066894i,  0.409769-0.00567i , -0.281624-0.00426i ,
+  -0.136896-0.129278i,  0.354973+0.422129i,  0.211392+0.341278i,
+  -0.107056+0.155526i, -0.268699-0.037315i, -0.119825+0.065011i,
    0.049162-0.076084i},
- { 0.056719-0.211788i, -0.495865-0.236019i,  0.138023+0.190738i, 
-  -0.442352+0.332837i, -0.456973+0.092392i,  0.375051-0.033477i, 
-  -0.207412+0.17366i ,  0.262768-0.108521i, -0.132135+0.202104i, 
+ { 0.056719-0.211788i, -0.495865-0.236019i,  0.138023+0.190738i,
+  -0.442352+0.332837i, -0.456973+0.092392i,  0.375051-0.033477i,
+  -0.207412+0.17366i ,  0.262768-0.108521i, -0.132135+0.202104i,
    0.373502+0.465698i}})xio";
-
-
diff --git a/test/files/xio_expected_results/big_exp.txt b/test/files/xio_expected_results/big_exp.txt
index d300864fe..407072cf1 100644
--- a/test/files/xio_expected_results/big_exp.txt
+++ b/test/files/xio_expected_results/big_exp.txt
@@ -2,4 +2,4 @@
  {-1.776213e-001,  1.000000e+220,  1.000000e-124,  1.593886e+000},
  {-7.200985e+000, -1.979649e+000,  2.546340e+000, -3.516982e+000},
  {-5.104814e+000,  3.895104e+000,  1.878048e+000,  2.635840e+000},
- {-1.194856e+000, -8.325470e+000,  4.246604e+000, -1.442730e+000}}
\ No newline at end of file
+ {-1.194856e+000, -8.325470e+000,  4.246604e+000, -1.442730e+000}}
diff --git a/test/files/xio_expected_results/bool_fn.txt b/test/files/xio_expected_results/bool_fn.txt
index 053541f57..262b829f1 100644
--- a/test/files/xio_expected_results/bool_fn.txt
+++ b/test/files/xio_expected_results/bool_fn.txt
@@ -2,4 +2,4 @@
  { true, false,  true, false, false},
  { true, false, false,  true,  true},
  { true, false, false,  true, false},
- {false, false,  true, false, false}}
\ No newline at end of file
+ {false, false,  true, false, false}}
diff --git a/test/files/xio_expected_results/complex_numbers.txt b/test/files/xio_expected_results/complex_numbers.txt
index f7baa81a1..4bc443578 100644
--- a/test/files/xio_expected_results/complex_numbers.txt
+++ b/test/files/xio_expected_results/complex_numbers.txt
@@ -1,40 +1,40 @@
-{{ 4.259106-4.705763i, -1.430581+0.520437i,  3.817697-2.597525i, 
-   4.383006+3.84805i , -0.177621-0.397616i,  5.600555-3.068297i, 
-  -1.781513-2.063075i,  1.593886+3.179275i, -7.200985+0.594874i, 
+{{ 4.259106-4.705763i, -1.430581+0.520437i,  3.817697-2.597525i,
+   4.383006+3.84805i , -0.177621-0.397616i,  5.600555-3.068297i,
+  -1.781513-2.063075i,  1.593886+3.179275i, -7.200985+0.594874i,
   -1.979649+1.779254i},
- { 2.54634 +3.091267i, -3.516982+3.685722i, -5.104814-0.820075i, 
-   3.895104-4.410618i,  1.878048-0.21541i ,  2.63584 +0.211594i, 
-  -1.194856+0.80632i , -8.32547 -1.90801i ,  4.246604+4.198826i, 
+ { 2.54634 +3.091267i, -3.516982+3.685722i, -5.104814-0.820075i,
+   3.895104-4.410618i,  1.878048-0.21541i ,  2.63584 +0.211594i,
+  -1.194856+0.80632i , -8.32547 -1.90801i ,  4.246604+4.198826i,
   -1.44273 +1.553475i},
- {-4.04439 -1.507586i, -0.158305+0.41094i ,  4.805928-0.509466i, 
-  -2.845422-2.17679i , -1.655801-2.041235i,  3.094426+0.63481i , 
-  -2.523971+2.151913i, -5.309743+0.176187i,  9.759906-1.479582i, 
+ {-4.04439 -1.507586i, -0.158305+0.41094i ,  4.805928-0.509466i,
+  -2.845422-2.17679i , -1.655801-2.041235i,  3.094426+0.63481i ,
+  -2.523971+2.151913i, -5.309743+0.176187i,  9.759906-1.479582i,
    5.319919+1.327789i},
- { 5.540089+3.73119i , -9.440361-3.321116i, -6.52187 +4.874783i, 
-  -6.918355-1.505851i, -8.45827 +3.262051i,  7.797314-4.345385i, 
-   5.007574-4.946467i,  3.868065+3.869446i,  0.235268+4.113181i, 
+ { 5.540089+3.73119i , -9.440361-3.321116i, -6.52187 +4.874783i,
+  -6.918355-1.505851i, -8.45827 +3.262051i,  7.797314-4.345385i,
+   5.007574-4.946467i,  3.868065+3.869446i,  0.235268+4.113181i,
   -0.714639-3.005922i},
- { 1.368614-4.724486i, -3.949011+3.173349i, -0.053824-2.581724i, 
-   3.665258-4.43917i ,  8.333974-4.324392i, -7.821421-0.261281i, 
-  -0.090164+0.094293i, -5.343281-0.832049i, -1.262787-2.441571i, 
+ { 1.368614-4.724486i, -3.949011+3.173349i, -0.053824-2.581724i,
+   3.665258-4.43917i ,  8.333974-4.324392i, -7.821421-0.261281i,
+  -0.090164+0.094293i, -5.343281-0.832049i, -1.262787-2.441571i,
    5.03086 -1.184879i},
- {-0.382158+3.073844i,  5.954568+3.110391i, -4.345941+1.861869i, 
-  -1.331635+4.926136i, -9.804853-0.948148i, -3.18408 -3.098263i, 
-   3.78544 -0.118255i,  7.387386+0.023696i, -4.643924-0.966452i, 
+ {-0.382158+3.073844i,  5.954568+3.110391i, -4.345941+1.861869i,
+  -1.331635+4.926136i, -9.804853-0.948148i, -3.18408 -3.098263i,
+   3.78544 -0.118255i,  7.387386+0.023696i, -4.643924-0.966452i,
   -0.865042-3.189046i},
- {-4.634374-4.519702i,  6.741056+1.046913i, -4.589707-2.340888i, 
-   0.60124 +3.81347i , -6.492547+0.840461i, -3.700671-0.225395i, 
-   7.822182-3.28485i , -6.393274-4.4338i  , -0.113676-3.429648i, 
+ {-4.634374-4.519702i,  6.741056+1.046913i, -4.589707-2.340888i,
+   0.60124 +3.81347i , -6.492547+0.840461i, -3.700671-0.225395i,
+   7.822182-3.28485i , -6.393274-4.4338i  , -0.113676-3.429648i,
   -5.754038-1.613825i},
- { 0.417537-0.59357i , -6.798001+1.838431i,  8.381136-2.941283i, 
-   9.885798+1.164337i, -0.459049+4.244716i, -3.80233 -4.203717i, 
-   0.144086-0.146032i, -4.384136+1.985636i,  5.276734-4.184315i, 
+ { 0.417537-0.59357i , -6.798001+1.838431i,  8.381136-2.941283i,
+   9.885798+1.164337i, -0.459049+4.244716i, -3.80233 -4.203717i,
+   0.144086-0.146032i, -4.384136+1.985636i,  5.276734-4.184315i,
   -7.829154+3.691024i},
- { 0.233094-0.668943i,  8.195388-0.056699i, -5.63248 -0.042595i, 
-  -2.737919-1.292779i,  7.099456+4.221287i,  4.227836+3.412782i, 
-  -2.141112+1.555259i, -5.37397 -0.37315i , -2.396506+0.650113i, 
+ { 0.233094-0.668943i,  8.195388-0.056699i, -5.63248 -0.042595i,
+  -2.737919-1.292779i,  7.099456+4.221287i,  4.227836+3.412782i,
+  -2.141112+1.555259i, -5.37397 -0.37315i , -2.396506+0.650113i,
    0.983242-0.760845i},
- { 1.134381-2.117881i, -9.917307-2.360193i,  2.76045 +1.907382i, 
-  -8.84704 +3.328365i, -9.139462+0.923916i,  7.501023-0.334774i, 
-  -4.148248+1.7366i  ,  5.255353-1.085206i, -2.642695+2.021044i, 
-   7.470045+4.656976i}}
\ No newline at end of file
+ { 1.134381-2.117881i, -9.917307-2.360193i,  2.76045 +1.907382i,
+  -8.84704 +3.328365i, -9.139462+0.923916i,  7.501023-0.334774i,
+  -4.148248+1.7366i  ,  5.255353-1.085206i, -2.642695+2.021044i,
+   7.470045+4.656976i}}
diff --git a/test/files/xio_expected_results/complex_zero_erasing.txt b/test/files/xio_expected_results/complex_zero_erasing.txt
index db203c894..55cafaa24 100644
--- a/test/files/xio_expected_results/complex_zero_erasing.txt
+++ b/test/files/xio_expected_results/complex_zero_erasing.txt
@@ -1,40 +1,40 @@
-{{ 0.212955-0.470576i, -0.071529+0.052044i,  0.190885-0.259752i, 
-   0.21915 +0.384805i, -0.008881-0.039762i,  0.280028-0.30683i , 
-  -0.089076-0.206307i,  0.079694+0.317928i, -0.360049+0.059487i, 
+{{ 0.212955-0.470576i, -0.071529+0.052044i,  0.190885-0.259752i,
+   0.21915 +0.384805i, -0.008881-0.039762i,  0.280028-0.30683i ,
+  -0.089076-0.206307i,  0.079694+0.317928i, -0.360049+0.059487i,
   -0.098982+0.177925i},
- { 0.127317+0.309127i, -0.175849+0.368572i, -0.255241-0.082008i, 
-   0.194755-0.441062i,  0.093902-0.021541i,  0.131792+0.021159i, 
-  -0.059743+0.080632i, -0.416274-0.190801i,  0.21233 +0.419883i, 
+ { 0.127317+0.309127i, -0.175849+0.368572i, -0.255241-0.082008i,
+   0.194755-0.441062i,  0.093902-0.021541i,  0.131792+0.021159i,
+  -0.059743+0.080632i, -0.416274-0.190801i,  0.21233 +0.419883i,
   -0.072137+0.155348i},
- {-0.20222 -0.150759i, -0.007915+0.041094i,  0.240296-0.050947i, 
-  -0.142271-0.217679i, -0.08279 -0.204123i,  0.154721+0.063481i, 
-  -0.126199+0.215191i, -0.265487+0.017619i,  0.487995-0.147958i, 
+ {-0.20222 -0.150759i, -0.007915+0.041094i,  0.240296-0.050947i,
+  -0.142271-0.217679i, -0.08279 -0.204123i,  0.154721+0.063481i,
+  -0.126199+0.215191i, -0.265487+0.017619i,  0.487995-0.147958i,
    0.265996+0.132779i},
- { 0.277004+0.373119i, -0.472018-0.332112i, -0.326093+0.487478i, 
-  -0.345918-0.150585i, -0.422914+0.326205i,  0.389866-0.434538i, 
-   0.250379-0.494647i,  0.193403+0.386945i,  0.011763+0.411318i, 
+ { 0.277004+0.373119i, -0.472018-0.332112i, -0.326093+0.487478i,
+  -0.345918-0.150585i, -0.422914+0.326205i,  0.389866-0.434538i,
+   0.250379-0.494647i,  0.193403+0.386945i,  0.011763+0.411318i,
   -0.035732-0.300592i},
- { 0.068431-0.472449i, -0.197451+0.317335i, -0.002691-0.258172i, 
-   0.183263-0.443917i,  0.416699-0.432439i, -0.391071-0.026128i, 
-  -0.004508+0.009429i, -0.267164-0.083205i, -0.063139-0.244157i, 
+ { 0.068431-0.472449i, -0.197451+0.317335i, -0.002691-0.258172i,
+   0.183263-0.443917i,  0.416699-0.432439i, -0.391071-0.026128i,
+  -0.004508+0.009429i, -0.267164-0.083205i, -0.063139-0.244157i,
    0.251543-0.118488i},
- {-0.019108+0.307384i,  0.297728+0.311039i, -0.217297+0.186187i, 
-  -0.066582+0.492614i, -0.490243-0.094815i, -0.159204-0.309826i, 
-   0.189272-0.011826i,  0.369369+0.00237i , -0.232196-0.096645i, 
+ {-0.019108+0.307384i,  0.297728+0.311039i, -0.217297+0.186187i,
+  -0.066582+0.492614i, -0.490243-0.094815i, -0.159204-0.309826i,
+   0.189272-0.011826i,  0.369369+0.00237i , -0.232196-0.096645i,
   -0.043252-0.318905i},
- {-0.231719-0.45197i ,  0.337053+0.104691i, -0.229485-0.234089i, 
-   0.030062+0.381347i, -0.324627+0.084046i, -0.185034-0.02254i , 
-   0.391109-0.328485i, -0.319664-0.44338i , -0.005684-0.342965i, 
+ {-0.231719-0.45197i ,  0.337053+0.104691i, -0.229485-0.234089i,
+   0.030062+0.381347i, -0.324627+0.084046i, -0.185034-0.02254i ,
+   0.391109-0.328485i, -0.319664-0.44338i , -0.005684-0.342965i,
   -0.287702-0.161383i},
- { 0.020877-0.059357i, -0.3399  +0.183843i,  0.419057-0.294128i, 
-   0.49429 +0.116434i, -0.022952+0.424472i, -0.190116-0.420372i, 
-   0.007204-0.014603i, -0.219207+0.198564i,  0.263837-0.418432i, 
+ { 0.020877-0.059357i, -0.3399  +0.183843i,  0.419057-0.294128i,
+   0.49429 +0.116434i, -0.022952+0.424472i, -0.190116-0.420372i,
+   0.007204-0.014603i, -0.219207+0.198564i,  0.263837-0.418432i,
   -0.391458+0.369102i},
- { 0.011655-0.066894i,  0.409769-0.00567i , -0.281624-0.00426i , 
-  -0.136896-0.129278i,  0.354973+0.422129i,  0.211392+0.341278i, 
-  -0.107056+0.155526i, -0.268699-0.037315i, -0.119825+0.065011i, 
+ { 0.011655-0.066894i,  0.409769-0.00567i , -0.281624-0.00426i ,
+  -0.136896-0.129278i,  0.354973+0.422129i,  0.211392+0.341278i,
+  -0.107056+0.155526i, -0.268699-0.037315i, -0.119825+0.065011i,
    0.049162-0.076084i},
- { 0.056719-0.211788i, -0.495865-0.236019i,  0.138023+0.190738i, 
-  -0.442352+0.332837i, -0.456973+0.092392i,  0.375051-0.033477i, 
-  -0.207412+0.17366i ,  0.262768-0.108521i, -0.132135+0.202104i, 
-   0.373502+0.465698i}}
\ No newline at end of file
+ { 0.056719-0.211788i, -0.495865-0.236019i,  0.138023+0.190738i,
+  -0.442352+0.332837i, -0.456973+0.092392i,  0.375051-0.033477i,
+  -0.207412+0.17366i ,  0.262768-0.108521i, -0.132135+0.202104i,
+   0.373502+0.465698i}}
diff --git a/test/files/xio_expected_results/custom_formatter_result.txt b/test/files/xio_expected_results/custom_formatter_result.txt
index 4dbbf3d23..0b4bdfd52 100644
--- a/test/files/xio_expected_results/custom_formatter_result.txt
+++ b/test/files/xio_expected_results/custom_formatter_result.txt
@@ -1,2 +1,2 @@
 {{     0x1,      0x2,      0x3,      0x4},
- {    0x64,     0xc8,    0x3e8, 0x989680}}
\ No newline at end of file
+ {    0x64,     0xc8,    0x3e8, 0x989680}}
diff --git a/test/files/xio_expected_results/cut_4d.txt b/test/files/xio_expected_results/cut_4d.txt
index 76e2e0f4f..5ab93f324 100644
--- a/test/files/xio_expected_results/cut_4d.txt
+++ b/test/files/xio_expected_results/cut_4d.txt
@@ -1,259 +1,259 @@
 {{{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
- ..., 
+ ...,
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}}},
  {{{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
-  ..., 
+  ...,
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1}},
   {{1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   ..., 
+   ...,
    {1, 1, 1, ..., 1, 1, 1},
    {1, 1, 1, ..., 1, 1, 1},
-   {1, 1, 1, ..., 1, 1, 1}}}}
\ No newline at end of file
+   {1, 1, 1, ..., 1, 1, 1}}}}
diff --git a/test/files/xio_expected_results/cut_both.txt b/test/files/xio_expected_results/cut_both.txt
index 1157d5407..8eb25ebd6 100644
--- a/test/files/xio_expected_results/cut_both.txt
+++ b/test/files/xio_expected_results/cut_both.txt
@@ -1,7 +1,7 @@
 {{1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
- ..., 
+ ...,
  {1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
- {1, 1, 1, ..., 1, 1, 1}}
\ No newline at end of file
+ {1, 1, 1, ..., 1, 1, 1}}
diff --git a/test/files/xio_expected_results/cut_high.txt b/test/files/xio_expected_results/cut_high.txt
index 7187709be..6f51c03c5 100644
--- a/test/files/xio_expected_results/cut_high.txt
+++ b/test/files/xio_expected_results/cut_high.txt
@@ -1,7 +1,7 @@
 {{1},
  {1},
  {1},
- ..., 
+ ...,
  {1},
  {1},
- {1}}
\ No newline at end of file
+ {1}}
diff --git a/test/files/xio_expected_results/cut_long.txt b/test/files/xio_expected_results/cut_long.txt
index 89e49a76d..e3c3a843e 100644
--- a/test/files/xio_expected_results/cut_long.txt
+++ b/test/files/xio_expected_results/cut_long.txt
@@ -2,4 +2,4 @@
  {1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
  {1, 1, 1, ..., 1, 1, 1},
- {1, 1, 1, ..., 1, 1, 1}}
\ No newline at end of file
+ {1, 1, 1, ..., 1, 1, 1}}
diff --git a/test/files/xio_expected_results/float_leading_zero.txt b/test/files/xio_expected_results/float_leading_zero.txt
index b30ab4c3b..eb2b7c148 100644
--- a/test/files/xio_expected_results/float_leading_zero.txt
+++ b/test/files/xio_expected_results/float_leading_zero.txt
@@ -1,20 +1,20 @@
-{{ 0.212955, -0.071529,  0.190885,  0.21915 , -0.008881,  0.280028, 
+{{ 0.212955, -0.071529,  0.190885,  0.21915 , -0.008881,  0.280028,
   -0.089076,  0.079694, -0.360049, -0.098982},
- { 0.127317, -0.175849, -0.255241,  0.194755,  0.093902,  0.131792, 
+ { 0.127317, -0.175849, -0.255241,  0.194755,  0.093902,  0.131792,
   -0.059743, -0.416274,  0.21233 , -0.072137},
- {-0.20222 , -0.007915,  0.240296, -0.142271, -0.08279 ,  0.154721, 
+ {-0.20222 , -0.007915,  0.240296, -0.142271, -0.08279 ,  0.154721,
   -0.126199, -0.265487,  0.487995,  0.265996},
- { 0.277004, -0.472018, -0.326093, -0.345918, -0.422914,  0.389866, 
+ { 0.277004, -0.472018, -0.326093, -0.345918, -0.422914,  0.389866,
    0.250379,  0.193403,  0.011763, -0.035732},
- { 0.068431, -0.197451, -0.002691,  0.183263,  0.416699, -0.391071, 
+ { 0.068431, -0.197451, -0.002691,  0.183263,  0.416699, -0.391071,
   -0.004508, -0.267164, -0.063139,  0.251543},
- {-0.019108,  0.297728, -0.217297, -0.066582, -0.490243, -0.159204, 
+ {-0.019108,  0.297728, -0.217297, -0.066582, -0.490243, -0.159204,
    0.189272,  0.369369, -0.232196, -0.043252},
- {-0.231719,  0.337053, -0.229485,  0.030062, -0.324627, -0.185034, 
+ {-0.231719,  0.337053, -0.229485,  0.030062, -0.324627, -0.185034,
    0.391109, -0.319664, -0.005684, -0.287702},
- { 0.020877, -0.3399  ,  0.419057,  0.49429 , -0.022952, -0.190116, 
+ { 0.020877, -0.3399  ,  0.419057,  0.49429 , -0.022952, -0.190116,
    0.007204, -0.219207,  0.263837, -0.391458},
- { 0.011655,  0.409769, -0.281624, -0.136896,  0.354973,  0.211392, 
+ { 0.011655,  0.409769, -0.281624, -0.136896,  0.354973,  0.211392,
   -0.107056, -0.268699, -0.119825,  0.049162},
- { 0.056719, -0.495865,  0.138023, -0.442352, -0.456973,  0.375051, 
-  -0.207412,  0.262768, -0.132135,  0.373502}}
\ No newline at end of file
+ { 0.056719, -0.495865,  0.138023, -0.442352, -0.456973,  0.375051,
+  -0.207412,  0.262768, -0.132135,  0.373502}}
diff --git a/test/files/xio_expected_results/long_strings.txt b/test/files/xio_expected_results/long_strings.txt
index f72176046..8426e29b4 100644
--- a/test/files/xio_expected_results/long_strings.txt
+++ b/test/files/xio_expected_results/long_strings.txt
@@ -1,2 +1,2 @@
 {{some, random very long and very very, boring},
- {strings, in, xtensor xarray}}
\ No newline at end of file
+ {strings, in, xtensor xarray}}
diff --git a/test/files/xio_expected_results/precision.txt b/test/files/xio_expected_results/precision.txt
index 53749121b..06a5d41bd 100644
--- a/test/files/xio_expected_results/precision.txt
+++ b/test/files/xio_expected_results/precision.txt
@@ -2,4 +2,4 @@
  {-0.177621344479,  5.600555210482, -1.781512638644,  1.593885951139},
  {-7.200984733734, -1.979648916087,  2.546340079714, -3.516982077951},
  {-5.104814402579,  3.895103503297,  1.87804795987 ,  2.635840409147},
- {-1.194856450043, -8.325470293986,  4.246603560315, -1.442730205451}}
\ No newline at end of file
+ {-1.194856450043, -8.325470293986,  4.246603560315, -1.442730205451}}
diff --git a/test/files/xio_expected_results/print_options_result.txt b/test/files/xio_expected_results/print_options_result.txt
index 3e29e9777..3bb26cdd6 100644
--- a/test/files/xio_expected_results/print_options_result.txt
+++ b/test/files/xio_expected_results/print_options_result.txt
@@ -1,41 +1,41 @@
-{{ 4.2591064316, -1.4305814994,  3.8176970288,  4.3830061776, -0.1776213445,  5.6005552105, -1.7815126386,  1.5938859511, -7.2009847337, -1.9796489161, ..., 
+{{ 4.2591064316, -1.4305814994,  3.8176970288,  4.3830061776, -0.1776213445,  5.6005552105, -1.7815126386,  1.5938859511, -7.2009847337, -1.9796489161, ...,
    1.1343811765, -9.9173071655,  2.760450376 , -8.8470396411, -9.139461943 ,  7.5010227444, -4.1482478699,  5.2553532664, -2.6426947385,  7.4700453614},
- {-9.4115253654,  1.0408744899, -5.1950499364,  7.6961002039, -0.7952315019, -6.1365934617, -4.1261498917,  6.3585501702,  1.1897474893,  3.5585089605, ..., 
+ {-9.4115253654,  1.0408744899, -5.1950499364,  7.6961002039, -0.7952315019, -6.1365934617, -4.1261498917,  6.3585501702,  1.1897474893,  3.5585089605, ...,
   -4.2357610156, -4.7203856627,  3.8147645182,  6.6567306578,  1.8478314906, -0.6695482385,  3.4731996107, -2.1704128909,  4.0420874091,  9.3139529141},
- {-8.1898023489, -8.8374973132,  1.7603482476,  5.0234750844,  0.2263477806,  8.4100238586, -3.9207180445, -0.139945379 ,  9.5872069321, -3.5298347424, ..., 
+ {-8.1898023489, -8.8374973132,  1.7603482476,  5.0234750844,  0.2263477806,  8.4100238586, -3.9207180445, -0.139945379 ,  9.5872069321, -3.5298347424, ...,
    3.5046670094,  3.9875929331, -0.8080616344, -8.6053016645,  9.9596034323,  2.7550191523, -8.6369483274, -7.0772591799,  6.7782654526, -4.4561017137},
- { 0.7890194329, -8.3913445067,  1.3269347791, -2.7503017751, -3.6357272732,  3.0704652279, -2.9019400135,  4.3051361271,  2.5656298621,  9.3502266157, ..., 
+ { 0.7890194329, -8.3913445067,  1.3269347791, -2.7503017751, -3.6357272732,  3.0704652279, -2.9019400135,  4.3051361271,  2.5656298621,  9.3502266157, ...,
    2.5694116162, -1.4108075651, -7.4179767494, -2.5672834157,  5.4803960597,  4.8477269726, -8.6492687081,  4.1365841284, -3.6037635514,  9.6100473723},
- {-6.8688488358, -5.9147360722, -0.3254980504, -0.4432930783, -8.6451064241,  0.4825582218,  6.4742113124, -1.5333826165,  1.6238035236,  5.0456922596, ..., 
+ {-6.8688488358, -5.9147360722, -0.3254980504, -0.4432930783, -8.6451064241,  0.4825582218,  6.4742113124, -1.5333826165,  1.6238035236,  5.0456922596, ...,
   -8.907970271 ,  0.18649803  , -9.9543102044, -6.2819204702,  5.3891564207, -3.3120201622, -4.3563841708, -2.219026429 ,  1.3871931164,  1.2869286246},
- {-6.3042710386, -7.8792950167,  4.8002785251,  5.9913866833,  6.2776804059,  9.7214889689,  5.4955589139,  5.6252921014,  7.577437609 ,  7.257547502 , ..., 
+ {-6.3042710386, -7.8792950167,  4.8002785251,  5.9913866833,  6.2776804059,  9.7214889689,  5.4955589139,  5.6252921014,  7.577437609 ,  7.257547502 , ...,
    8.5663364244,  6.7513786277,  4.5776524274,  1.9506977271,  3.0531497184,  4.2059602795,  3.0692081464, -0.3337777986, -1.1924831894,  5.5755222404},
- {-9.9360143174, -7.8252918939,  0.9357223565, -0.4318962485, -7.4969360956,  8.7757765577,  5.490149909 , -2.9660779553,  5.2321713202,  3.1286268453, ..., 
+ {-9.9360143174, -7.8252918939,  0.9357223565, -0.4318962485, -7.4969360956,  8.7757765577,  5.490149909 , -2.9660779553,  5.2321713202,  3.1286268453, ...,
   -0.7865411543,  7.0944427163, -8.5003798672, -0.9705943392,  4.8865678277,  2.4922847975, -8.259579232 ,  4.8378875582,  0.5414670781,  1.876758001 },
- { 1.293892469 ,  7.8727186438, -4.972623397 , -3.5229320218,  3.3804633975,  5.8755820434, -7.2976530169, -2.5884345174,  3.4962291201,  2.5881180456, ..., 
+ { 1.293892469 ,  7.8727186438, -4.972623397 , -3.5229320218,  3.3804633975,  5.8755820434, -7.2976530169, -2.5884345174,  3.4962291201,  2.5881180456, ...,
   -8.3196069801, -5.8129397724,  3.5503994193,  1.912760341 , -2.9211608073, -1.0535730789,  9.0423519795,  2.0698228727,  0.6368620153,  6.9564823215},
- { 3.9358404762,  0.5809243981, -0.9498240938,  6.898440392 , -5.4818767592, -5.0017919505, -2.9829227958,  5.7145039411, -8.1874937034, -9.2677064906, ..., 
+ { 3.9358404762,  0.5809243981, -0.9498240938,  6.898440392 , -5.4818767592, -5.0017919505, -2.9829227958,  5.7145039411, -8.1874937034, -9.2677064906, ...,
    2.0794398741,  2.4170323022,  7.8038475493, -7.7127253907,  7.2106577371,  7.7389202457,  1.6675980486,  8.4511451276,  3.792580503 , -6.1656516322},
- { 9.0866831126,  5.9443540369,  7.1534989647, -7.508772471 , -8.0987910974,  3.4886813262,  2.1691338193, -2.2854097703, -6.8156659851, -0.1224009932, ..., 
+ { 9.0866831126,  5.9443540369,  7.1534989647, -7.508772471 , -8.0987910974,  3.4886813262,  2.1691338193, -2.2854097703, -6.8156659851, -0.1224009932, ...,
   -4.4368127712,  1.0803095673, -3.7147775314,  6.4971630142,  8.3919628599,  4.0877859866,  4.8276491821, -1.742215113 , -8.597945096 ,  6.8729988406},
- ..., 
- {-3.151856391 ,  2.4390118942,  9.8334549245,  2.8587256739, -4.083950175 , -6.1374355029,  0.7666708995,  8.8843617064, -4.0865416894,  3.460927625 , ..., 
+ ...,
+ {-3.151856391 ,  2.4390118942,  9.8334549245,  2.8587256739, -4.083950175 , -6.1374355029,  0.7666708995,  8.8843617064, -4.0865416894,  3.460927625 , ...,
    9.1923774994,  2.2861329136,  8.9983777704, -7.9231060177, -0.9049750831,  4.4464730624, -5.4762394472,  7.8770915099,  5.7033579537,  0.016548383 },
- {-2.4788852044,  1.1656576499,  6.5928665383, -6.1366555538, -8.6411857519,  5.2052450675, -3.5959077694,  3.3344935488, -2.2047991068,  9.3559814814, ..., 
+ {-2.4788852044,  1.1656576499,  6.5928665383, -6.1366555538, -8.6411857519,  5.2052450675, -3.5959077694,  3.3344935488, -2.2047991068,  9.3559814814, ...,
   -7.4537355115, -7.1201607588,  2.3992745913, -5.6769048416, -1.108305959 ,  6.1092005967, -3.526292617 , -3.031207394 , -3.2672616002,  6.2747284327},
- { 1.2279588003, -3.6163419543, -2.0786564667, -5.1491621651,  4.8967947546,  2.0128427608,  6.5801679558, -7.7133407724,  1.2911925826, -4.3470470189, ..., 
+ { 1.2279588003, -3.6163419543, -2.0786564667, -5.1491621651,  4.8967947546,  2.0128427608,  6.5801679558, -7.7133407724,  1.2911925826, -4.3470470189, ...,
    2.4885760741,  0.516281461 ,  2.0317043678,  9.8593572754,  9.39050558  , -6.5182817973, -6.2139035714, -6.892220281 , -4.4423667759,  0.2460085642},
- { 1.1550892391, -9.9888950269,  3.6677261546, -1.9225639445, -3.9742847089,  9.8369094525,  1.0094657806,  7.0237851259,  4.7613542349, -2.5126619176, ..., 
+ { 1.1550892391, -9.9888950269,  3.6677261546, -1.9225639445, -3.9742847089,  9.8369094525,  1.0094657806,  7.0237851259,  4.7613542349, -2.5126619176, ...,
   -8.4162629587, -3.24552804  , -3.5550699051,  8.5579495749,  4.0636289088, -3.1650726073,  4.791227718 , -6.6433645946,  6.1247442938, -2.3697889754},
- { 0.1790187416,  3.7869978784, -3.7214265386, -5.430811068 ,  0.0320440687,  7.9734318597, -8.3428800195,  8.4875692138, -8.0981588233,  5.1545232452, ..., 
+ { 0.1790187416,  3.7869978784, -3.7214265386, -5.430811068 ,  0.0320440687,  7.9734318597, -8.3428800195,  8.4875692138, -8.0981588233,  5.1545232452, ...,
    6.2912773739,  4.9564293744,  0.0382712411, -0.2348270118, -8.732937865 ,  8.8921533464, -2.630946671 ,  3.0153719251,  9.9166161566, -6.6299812283},
- { 9.1449987496,  2.4201323765,  5.8399717306,  8.0367330041, -9.7451837364,  1.6830851238, -2.1287651061, -6.8869386991, -3.0261938917,  9.1932040255, ..., 
+ { 9.1449987496,  2.4201323765,  5.8399717306,  8.0367330041, -9.7451837364,  1.6830851238, -2.1287651061, -6.8869386991, -3.0261938917,  9.1932040255, ...,
   -1.4246246026,  9.4138344923, -4.0763188341, -7.8716496381, -4.5449281491, -1.0316709948, -7.7429029029, -5.8385824545, -1.6484059172,  7.6987670572},
- {-3.2993450647,  0.1656660217, -5.741487258 ,  7.6658710517,  7.4421535525, -8.7237405417, -1.6565722798, -9.5092800257, -2.9103572582, -9.0512625226, ..., 
+ {-3.2993450647,  0.1656660217, -5.741487258 ,  7.6658710517,  7.4421535525, -8.7237405417, -1.6565722798, -9.5092800257, -2.9103572582, -9.0512625226, ...,
    0.956576245 , -2.1176214529,  1.224063253 ,  9.4574798674,  1.5253960498,  9.0468728933,  1.4632485328,  5.388738737 , -5.0804525812,  9.9405982276},
- {-3.8595565152,  3.9711250838, -0.7466613442, -7.8472288594, -9.7060944334,  5.8814551806,  1.5839099422, -3.2811630355, -2.5670295888, -2.2946266962, ..., 
+ {-3.8595565152,  3.9711250838, -0.7466613442, -7.8472288594, -9.7060944334,  5.8814551806,  1.5839099422, -3.2811630355, -2.5670295888, -2.2946266962, ...,
   -8.3226376255, -6.1266055234, -8.53220412  ,  0.0712064945, -8.6836749392,  1.1484328631, -9.9792581277, -7.8110753489,  9.4993486219,  6.8471466225},
- { 4.0164446191,  2.6124123025,  3.009438323 , -5.5299690191, -4.4891102742,  5.137638025 ,  5.7287509146, -2.275257769 ,  5.6551393668, -5.2959856257, ..., 
+ { 4.0164446191,  2.6124123025,  3.009438323 , -5.5299690191, -4.4891102742,  5.137638025 ,  5.7287509146, -2.275257769 ,  5.6551393668, -5.2959856257, ...,
   -0.671183266 ,  6.450851233 ,  1.0147749194, -4.3992512334, -5.7095954354,  7.7680651531,  2.5030521106,  6.6729805346,  5.0310323451, -7.5703964152},
- { 0.5886834152,  4.6679436689, -8.592678009 , -7.6868968194,  7.1161214125, -1.4239915896,  6.2509497685,  8.4953751982,  9.7493446122,  7.2939809954, ..., 
-   5.6044133488, -4.1291454101, -8.28053945  ,  3.5683828275, -1.2860306048, -9.0687648703,  3.8310462403, -9.0213947232,  2.1923222357, -6.3506701839}}
\ No newline at end of file
+ { 0.5886834152,  4.6679436689, -8.592678009 , -7.6868968194,  7.1161214125, -1.4239915896,  6.2509497685,  8.4953751982,  9.7493446122,  7.2939809954, ...,
+   5.6044133488, -4.1291454101, -8.28053945  ,  3.5683828275, -1.2860306048, -9.0687648703,  3.8310462403, -9.0213947232,  2.1923222357, -6.3506701839}}
diff --git a/test/files/xio_expected_results/random_nan_inf.txt b/test/files/xio_expected_results/random_nan_inf.txt
index 9ec4ef128..4223869a1 100644
--- a/test/files/xio_expected_results/random_nan_inf.txt
+++ b/test/files/xio_expected_results/random_nan_inf.txt
@@ -1,80 +1,80 @@
-{{ 4.259106, -1.430581,  3.817697,  4.383006, -0.177621,  5.600555, 
-  -1.781513,  1.593886, -7.200985, -1.979649,  2.54634 , -3.516982, 
-  -5.104814,  3.895104,  1.878048,  2.63584 , -1.194856, -8.32547 , 
+{{ 4.259106, -1.430581,  3.817697,  4.383006, -0.177621,  5.600555,
+  -1.781513,  1.593886, -7.200985, -1.979649,  2.54634 , -3.516982,
+  -5.104814,  3.895104,  1.878048,  2.63584 , -1.194856, -8.32547 ,
    4.246604, -1.44273 },
- {-4.04439 , -1.      ,  1.      , -2.845422, -1.655801,  3.094426, 
-  -2.523971, -5.309743,  9.759906,  5.319919,  5.540089, -9.440361, 
-  -6.52187 , -6.918355, -8.45827 ,  7.797314,  5.007574,  3.868065, 
+ {-4.04439 , -1.      ,  1.      , -2.845422, -1.655801,  3.094426,
+  -2.523971, -5.309743,  9.759906,  5.319919,  5.540089, -9.440361,
+  -6.52187 , -6.918355, -8.45827 ,  7.797314,  5.007574,  3.868065,
    0.235268, -0.714639},
- { 1.368614, -3.949011,       inf,      -inf,  8.333974, -7.821421, 
-  -0.090164, -5.343281, -1.262787,  5.03086 , -0.382158,  5.954568, 
-  -4.345941, -1.331635, -9.804853, -3.18408 ,  3.78544 ,  7.387386, 
+ { 1.368614, -3.949011,       inf,      -inf,  8.333974, -7.821421,
+  -0.090164, -5.343281, -1.262787,  5.03086 , -0.382158,  5.954568,
+  -4.345941, -1.331635, -9.804853, -3.18408 ,  3.78544 ,  7.387386,
   -4.643924, -0.865042},
- {-4.634374,  6.741056, -4.589707,  0.60124 , -6.492547, -3.700671, 
-   7.822182, -6.393274, -0.113676, -5.754038,  0.417537, -6.798001, 
-   8.381136,  9.885798, -0.459049, -3.80233 ,  0.144086, -4.384136, 
+ {-4.634374,  6.741056, -4.589707,  0.60124 , -6.492547, -3.700671,
+   7.822182, -6.393274, -0.113676, -5.754038,  0.417537, -6.798001,
+   8.381136,  9.885798, -0.459049, -3.80233 ,  0.144086, -4.384136,
    5.276734, -7.829154},
- { 0.233094,  8.195388, -5.63248 , -2.737919,       nan,  4.227836, 
-  -2.141112, -5.37397 , -2.396506,  0.983242,  1.134381, -9.917307, 
-   2.76045 , -8.84704 , -9.139462,  7.501023, -4.148248,  5.255353, 
+ { 0.233094,  8.195388, -5.63248 , -2.737919,       nan,  4.227836,
+  -2.141112, -5.37397 , -2.396506,  0.983242,  1.134381, -9.917307,
+   2.76045 , -8.84704 , -9.139462,  7.501023, -4.148248,  5.255353,
   -2.642695,  7.470045},
- {-9.411525,  1.040874, -5.19505 ,  7.6961  , -0.795232, -6.136593, 
-  -4.12615 ,  6.35855 ,  1.189747,  3.558509,  6.182534,  7.371443, 
-  -1.640151, -8.821237, -0.43082 ,  0.423189,  1.61264 , -3.81602 , 
+ {-9.411525,  1.040874, -5.19505 ,  7.6961  , -0.795232, -6.136593,
+  -4.12615 ,  6.35855 ,  1.189747,  3.558509,  6.182534,  7.371443,
+  -1.640151, -8.821237, -0.43082 ,  0.423189,  1.61264 , -3.81602 ,
    8.397652,  3.10695 },
- {-3.015172,  0.821881, -1.018932, -4.353581, -4.08247 ,  1.26962 , 
-   4.303826,  0.352374, -2.959163,  2.655577,  7.462381, -6.642231, 
-   9.749566, -3.011701,  6.524103, -8.690769, -9.892934,  7.738893, 
+ {-3.015172,  0.821881, -1.018932, -4.353581, -4.08247 ,  1.26962 ,
+   4.303826,  0.352374, -2.959163,  2.655577,  7.462381, -6.642231,
+   9.749566, -3.011701,  6.524103, -8.690769, -9.892934,  7.738893,
    8.226363, -6.011844},
- {-9.448972,  6.346698, -5.163448, -8.87834 , -8.648783, -0.522563, 
-   0.188585, -1.664097, -4.883141, -2.369758,  6.147689,  6.220783, 
-   3.723737,  9.852273, -1.896296, -6.196526, -0.23651 ,  0.047393, 
+ {-9.448972,  6.346698, -5.163448, -8.87834 , -8.648783, -0.522563,
+   0.188585, -1.664097, -4.883141, -2.369758,  6.147689,  6.220783,
+   3.723737,  9.852273, -1.896296, -6.196526, -0.23651 ,  0.047393,
   -1.932904, -6.378091},
- {-9.039404,  2.093827, -4.681776,  7.62694 ,  1.680922, -0.45079 , 
-  -6.5697  , -8.8676  , -6.859295, -3.22765 , -1.187141,  3.676862, 
-  -5.882566,  2.328674,  8.489432, -8.407435, -0.292063,  3.971273, 
+ {-9.039404,  2.093827, -4.681776,  7.62694 ,  1.680922, -0.45079 ,
+  -6.5697  , -8.8676  , -6.859295, -3.22765 , -1.187141,  3.676862,
+  -5.882566,  2.328674,  8.489432, -8.407435, -0.292063,  3.971273,
   -8.36863 ,  7.382047},
- {-1.337886, -0.113399, -0.085191, -2.585558,  8.442573,  6.825565, 
-   3.110518, -0.746299,  1.300226, -1.52169 , -4.235761, -4.720386, 
-   3.814765,  6.656731,  1.847831, -0.669548,  3.4732  , -2.170413, 
+ {-1.337886, -0.113399, -0.085191, -2.585558,  8.442573,  6.825565,
+   3.110518, -0.746299,  1.300226, -1.52169 , -4.235761, -4.720386,
+   3.814765,  6.656731,  1.847831, -0.669548,  3.4732  , -2.170413,
    4.042087,  9.313953},
- {-8.189802, -8.837497,  1.760348,  5.023475,  0.226348,  8.410024, 
-  -3.920718, -0.139945,  9.587207, -3.529835, -6.208657, -3.895418, 
-  -3.117761,  3.590606, -8.9237  ,  6.132075,  2.059004,  3.104264, 
+ {-8.189802, -8.837497,  1.760348,  5.023475,  0.226348,  8.410024,
+  -3.920718, -0.139945,  9.587207, -3.529835, -6.208657, -3.895418,
+  -3.117761,  3.590606, -8.9237  ,  6.132075,  2.059004,  3.104264,
    4.953196,  0.712524},
- {-7.81687 , -0.076074, -6.553148,  3.679784,  0.596504,  2.504485, 
-  -3.69714 , -0.169787,  6.402841, -7.347591, -7.57381 , -1.075701, 
-  -9.181317, -3.989666, -1.812192, -2.549612, -3.200597,  6.251402, 
+ {-7.81687 , -0.076074, -6.553148,  3.679784,  0.596504,  2.504485,
+  -3.69714 , -0.169787,  6.402841, -7.347591, -7.57381 , -1.075701,
+  -9.181317, -3.989666, -1.812192, -2.549612, -3.200597,  6.251402,
    0.564111,  1.076542},
- {-7.655863,  5.692096, -1.308276, -8.455545, -6.363769,  0.420217, 
-  -0.413317, -3.72915 , -8.006616,  1.931053, -5.036602,  2.086803, 
-  -3.897727,  7.946099,  1.640307,  4.249848,  3.672309,  8.932418, 
+ {-7.655863,  5.692096, -1.308276, -8.455545, -6.363769,  0.420217,
+  -0.413317, -3.72915 , -8.006616,  1.931053, -5.036602,  2.086803,
+  -3.897727,  7.946099,  1.640307,  4.249848,  3.672309,  8.932418,
    8.264625, -8.974902},
- {-2.39369 ,  1.277131, -7.348525,  1.502706, -3.548645,  9.678551, 
-   1.513316,  2.594553, -1.979754,  4.892601, -1.976282,  5.309503, 
-   9.648625, -6.637665, -0.508106,  0.97881 , -1.277853, -4.065374, 
+ {-2.39369 ,  1.277131, -7.348525,  1.502706, -3.548645,  9.678551,
+   1.513316,  2.594553, -1.979754,  4.892601, -1.976282,  5.309503,
+   9.648625, -6.637665, -0.508106,  0.97881 , -1.277853, -4.065374,
   -2.128725,  6.761622},
- { 3.032851,  9.077939, -0.459995,  7.577871,  5.844156, -4.69285 , 
-   5.248765,  6.454728, -2.940153,  9.48464 ,  3.504667,  3.987593, 
-  -0.808062, -8.605302,  9.959603,  2.755019, -8.636948, -7.077259, 
+ { 3.032851,  9.077939, -0.459995,  7.577871,  5.844156, -4.69285 ,
+   5.248765,  6.454728, -2.940153,  9.48464 ,  3.504667,  3.987593,
+  -0.808062, -8.605302,  9.959603,  2.755019, -8.636948, -7.077259,
    6.778265, -4.456102},
- { 0.789019, -8.391345,  1.326935, -2.750302, -3.635727,  3.070465, 
-  -2.90194 ,  4.305136,  2.56563 ,  9.350227, -4.37165 , -5.072099, 
-  -8.449633,  7.84151 , -9.3091  , -0.170497, -9.981909,  7.783972, 
+ { 0.789019, -8.391345,  1.326935, -2.750302, -3.635727,  3.070465,
+  -2.90194 ,  4.305136,  2.56563 ,  9.350227, -4.37165 , -5.072099,
+  -8.449633,  7.84151 , -9.3091  , -0.170497, -9.981909,  7.783972,
   -3.212051,  2.616364},
- {-3.385869,  7.779795,  4.586448, -8.113584,  4.134024,  7.608333, 
-   0.810756,  9.514617, -0.599935, -9.215927,  0.269787,  0.436816, 
-   1.589945,  6.745015, -2.984754,  8.22778 , -1.991758, -2.205407, 
+ {-3.385869,  7.779795,  4.586448, -8.113584,  4.134024,  7.608333,
+   0.810756,  9.514617, -0.599935, -9.215927,  0.269787,  0.436816,
+   1.589945,  6.745015, -2.984754,  8.22778 , -1.991758, -2.205407,
   -1.954704, -7.920165},
- {-0.681457,  2.961423, -4.046124,  7.84679 , -0.428581, -4.352744, 
-  -1.629202, -1.682069,  5.426159,  4.759028, -0.535463,  0.037947, 
-   6.713306,  4.397586,  0.211848,  4.890704, -3.313785,  0.839388, 
+ {-0.681457,  2.961423, -4.046124,  7.84679 , -0.428581, -4.352744,
+  -1.629202, -1.682069,  5.426159,  4.759028, -0.535463,  0.037947,
+   6.713306,  4.397586,  0.211848,  4.890704, -3.313785,  0.839388,
    1.601047, -8.551511},
- { 3.58872 ,  4.407113,  1.049608,  0.099257, -8.345609,  1.612125, 
-   2.578687,  1.733626,  4.454039, -8.312231,  9.610947, -7.572344, 
-  -7.769007,  0.116085, -1.100301, -6.350003, -1.589225,  7.378157, 
+ { 3.58872 ,  4.407113,  1.049608,  0.099257, -8.345609,  1.612125,
+   2.578687,  1.733626,  4.454039, -8.312231,  9.610947, -7.572344,
+  -7.769007,  0.116085, -1.100301, -6.350003, -1.589225,  7.378157,
    5.114439, -7.273815},
- {-6.417325,  1.029412,  1.246413, -1.370279, -2.788699,  0.373218, 
-  -1.76683 , -9.41086 , -8.920649, -7.659411,  2.569412, -1.410808, 
-  -7.417977, -2.567283,  5.480396,  4.847727, -8.649269,  4.136584, 
-  -3.603764,  9.610047}}
\ No newline at end of file
+ {-6.417325,  1.029412,  1.246413, -1.370279, -2.788699,  0.373218,
+  -1.76683 , -9.41086 , -8.920649, -7.659411,  2.569412, -1.410808,
+  -7.417977, -2.567283,  5.480396,  4.847727, -8.649269,  4.136584,
+  -3.603764,  9.610047}}
diff --git a/test/files/xio_expected_results/random_strings.txt b/test/files/xio_expected_results/random_strings.txt
index 403e0c9cd..f6fa0599d 100644
--- a/test/files/xio_expected_results/random_strings.txt
+++ b/test/files/xio_expected_results/random_strings.txt
@@ -1,2 +1,2 @@
 {{          some,         random,         boring},
- {       strings,             in, xtensor xarray}}
\ No newline at end of file
+ {       strings,             in, xtensor xarray}}
diff --git a/test/files/xio_expected_results/threed_double.txt b/test/files/xio_expected_results/threed_double.txt
index 5681e8d9a..a30f611c3 100644
--- a/test/files/xio_expected_results/threed_double.txt
+++ b/test/files/xio_expected_results/threed_double.txt
@@ -9,4 +9,4 @@
  {{  5.,  26.},
   {  7.,   8.},
   { 10.,   8.},
-  {  4.,   3.}}}
\ No newline at end of file
+  {  4.,   3.}}}
diff --git a/test/files/xio_expected_results/twod_double.txt b/test/files/xio_expected_results/twod_double.txt
index 5bb17fbc8..5b48af392 100644
--- a/test/files/xio_expected_results/twod_double.txt
+++ b/test/files/xio_expected_results/twod_double.txt
@@ -1,3 +1,3 @@
 {{  1.,   2.,   3.,   4.},
  {  5.,   6.,   7.,   8.},
- {  9.,  10.,  11.,  12.}}
\ No newline at end of file
+ {  9.,  10.,  11.,  12.}}
diff --git a/test/files/xnpy_files/bool.be.npy b/test/files/xnpy_files/bool.be.npy
new file mode 100644
index 000000000..528c0eefb
Binary files /dev/null and b/test/files/xnpy_files/bool.be.npy differ
diff --git a/test/files/xnpy_files/bool.le.npy b/test/files/xnpy_files/bool.le.npy
new file mode 100644
index 000000000..528c0eefb
Binary files /dev/null and b/test/files/xnpy_files/bool.le.npy differ
diff --git a/test/files/xnpy_files/bool.npy b/test/files/xnpy_files/bool.npy
deleted file mode 100644
index 3e4cd6e1c..000000000
Binary files a/test/files/xnpy_files/bool.npy and /dev/null differ
diff --git a/test/files/xnpy_files/bool_fortran.be.npy b/test/files/xnpy_files/bool_fortran.be.npy
new file mode 100644
index 000000000..a6766f6a4
Binary files /dev/null and b/test/files/xnpy_files/bool_fortran.be.npy differ
diff --git a/test/files/xnpy_files/bool_fortran.le.npy b/test/files/xnpy_files/bool_fortran.le.npy
new file mode 100644
index 000000000..a6766f6a4
Binary files /dev/null and b/test/files/xnpy_files/bool_fortran.le.npy differ
diff --git a/test/files/xnpy_files/bool_fortran.npy b/test/files/xnpy_files/bool_fortran.npy
deleted file mode 100644
index 5068b335d..000000000
Binary files a/test/files/xnpy_files/bool_fortran.npy and /dev/null differ
diff --git a/test/files/xnpy_files/double.npy b/test/files/xnpy_files/double.be.npy
similarity index 62%
rename from test/files/xnpy_files/double.npy
rename to test/files/xnpy_files/double.be.npy
index e5ef17013..b4eb19a0d 100644
Binary files a/test/files/xnpy_files/double.npy and b/test/files/xnpy_files/double.be.npy differ
diff --git a/test/files/xnpy_files/double.le.npy b/test/files/xnpy_files/double.le.npy
new file mode 100644
index 000000000..b4eb19a0d
Binary files /dev/null and b/test/files/xnpy_files/double.le.npy differ
diff --git a/test/files/xnpy_files/double_fortran.npy b/test/files/xnpy_files/double_fortran.be.npy
similarity index 62%
rename from test/files/xnpy_files/double_fortran.npy
rename to test/files/xnpy_files/double_fortran.be.npy
index c6a0bb776..0d395e90b 100644
Binary files a/test/files/xnpy_files/double_fortran.npy and b/test/files/xnpy_files/double_fortran.be.npy differ
diff --git a/test/files/xnpy_files/double_fortran.le.npy b/test/files/xnpy_files/double_fortran.le.npy
new file mode 100644
index 000000000..0d395e90b
Binary files /dev/null and b/test/files/xnpy_files/double_fortran.le.npy differ
diff --git a/test/files/xnpy_files/int.be.npy b/test/files/xnpy_files/int.be.npy
new file mode 100644
index 000000000..d24dd3f56
Binary files /dev/null and b/test/files/xnpy_files/int.be.npy differ
diff --git a/test/files/xnpy_files/int.le.npy b/test/files/xnpy_files/int.le.npy
new file mode 100644
index 000000000..d24dd3f56
Binary files /dev/null and b/test/files/xnpy_files/int.le.npy differ
diff --git a/test/files/xnpy_files/unsignedlong.be.npy b/test/files/xnpy_files/unsignedlong.be.npy
new file mode 100644
index 000000000..4c6863fb9
Binary files /dev/null and b/test/files/xnpy_files/unsignedlong.be.npy differ
diff --git a/test/files/xnpy_files/unsignedlong.le.npy b/test/files/xnpy_files/unsignedlong.le.npy
new file mode 100644
index 000000000..4c6863fb9
Binary files /dev/null and b/test/files/xnpy_files/unsignedlong.le.npy differ
diff --git a/test/files/xnpy_files/unsignedlong.npy b/test/files/xnpy_files/unsignedlong.npy
deleted file mode 100644
index f46368574..000000000
Binary files a/test/files/xnpy_files/unsignedlong.npy and /dev/null differ
diff --git a/test/files/xnpy_files/unsignedlong_fortran.be.npy b/test/files/xnpy_files/unsignedlong_fortran.be.npy
new file mode 100644
index 000000000..4c6863fb9
Binary files /dev/null and b/test/files/xnpy_files/unsignedlong_fortran.be.npy differ
diff --git a/test/files/xnpy_files/unsignedlong_fortran.le.npy b/test/files/xnpy_files/unsignedlong_fortran.le.npy
new file mode 100644
index 000000000..4c6863fb9
Binary files /dev/null and b/test/files/xnpy_files/unsignedlong_fortran.le.npy differ
diff --git a/test/files/xnpy_files/unsignedlong_fortran.npy b/test/files/xnpy_files/unsignedlong_fortran.npy
deleted file mode 100644
index f46368574..000000000
Binary files a/test/files/xnpy_files/unsignedlong_fortran.npy and /dev/null differ
diff --git a/test/main.cpp b/test/main.cpp
index 8ca1e4384..f16c661eb 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -1,15 +1,5 @@
-/***************************************************************************
-* 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 "gtest/gtest.h"
-
-int main(int argc, char* argv[])
-{
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}
+#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#if defined(XTENSOR_DISABLE_EXCEPTIONS)
+#define DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
+#endif
+#include "doctest/doctest.h"
diff --git a/test/msan_suppressions.txt b/test/msan_suppressions.txt
new file mode 100644
index 000000000..73be572ea
--- /dev/null
+++ b/test/msan_suppressions.txt
@@ -0,0 +1,5 @@
+# MSan false positive: doctest reporter registration during static init
+# doctest::String has internal padding that MSan flags as uninitialized
+# when std::map compares keys during insert.
+fun:*doctest::detail::registerReporterImpl*
+src:*doctest/doctest.h
diff --git a/test/set_compiler_flag.cmake b/test/set_compiler_flag.cmake
new file mode 100644
index 000000000..1ce8c86c6
--- /dev/null
+++ b/test/set_compiler_flag.cmake
@@ -0,0 +1,66 @@
+# Copied from
+# https://github.com/dev-cafe/cmake-cookbook/blob/master/chapter-07/recipe-03/c-cxx-example/set_compiler_flag.cmake
+# Adapted from
+# https://github.com/robertodr/ddPCM/blob/expose-C-api/cmake/custom/compilers/SetCompilerFlag.cmake
+# which was adapted by Roberto Di Remigio from
+# https://github.com/SethMMorton/cmake_fortran_template/blob/master/cmake/Modules/SetCompileFlag.cmake
+
+# Given a list of flags, this stateless function will try each, one at a time,
+# and set result to the first flag that works.
+# If none of the flags works, result is "".
+# If the REQUIRED key is given and no flag is found, a FATAL_ERROR is raised.
+#
+# Call is:
+# set_compile_flag(result (Fortran|C|CXX) <REQUIRED> flag1 flag2 ...)
+#
+# Example:
+# set_compiler_flag(working_compile_flag C REQUIRED "-Wall" "-warn all")
+
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+include(CheckFortranCompilerFlag)
+
+function(set_compiler_flag _result _lang)
+  # build a list of flags from the arguments
+  set(_list_of_flags)
+  # also figure out whether the function
+  # is required to find a flag
+  set(_flag_is_required FALSE)
+  foreach(_arg IN ITEMS ${ARGN})
+    string(TOUPPER "${_arg}" _arg_uppercase)
+    if(_arg_uppercase STREQUAL "REQUIRED")
+      set(_flag_is_required TRUE)
+    else()
+      list(APPEND _list_of_flags "${_arg}")
+    endif()
+  endforeach()
+
+  set(_flag_found FALSE)
+  # loop over all flags, try to find the first which works
+  foreach(flag IN ITEMS ${_list_of_flags})
+
+    unset(_${flag}_works CACHE)
+    if(_lang STREQUAL "C")
+      check_c_compiler_flag("${flag}" _${flag}_works)
+    elseif(_lang STREQUAL "CXX")
+      check_cxx_compiler_flag("${flag}" _${flag}_works)
+    elseif(_lang STREQUAL "Fortran")
+      check_Fortran_compiler_flag("${flag}" _${flag}_works)
+    else()
+      message(FATAL_ERROR "Unknown language in set_compiler_flag: ${_lang}")
+    endif()
+
+    # if the flag works, use it, and exit
+    # otherwise try next flag
+    if(_${flag}_works)
+      set(${_result} "${flag}" PARENT_SCOPE)
+      set(_flag_found TRUE)
+      break()
+    endif()
+  endforeach()
+
+  # raise an error if no flag was found
+  if(_flag_is_required AND NOT _flag_found)
+    message(FATAL_ERROR "None of the required flags were supported")
+  endif()
+endfunction()
diff --git a/test/test_common.hpp b/test/test_common.hpp
index ff93ca008..3134c0bfe 100644
--- a/test/test_common.hpp
+++ b/test/test_common.hpp
@@ -1,19 +1,61 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 TEST_COMMON_HPP
 #define TEST_COMMON_HPP
 
-#include "xtensor/xlayout.hpp"
-#include "xtensor/xmanipulation.hpp"
+#include <sstream>
+
+#include "xtensor/core/xlayout.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/reducers/xreducer.hpp"  // tuple_idx_of
+
+#include "test_common_macros.hpp"
+
+// the tests used to be implemented with gtest
+// testing::Types<...> and testing::Test
+// where introduced to keep compatible
+// with the gtest test where we can
+namespace testing
+{
+    template <class... ARGS>
+    using Types = std::tuple<ARGS...>;
+
+    struct Test
+    {
+    };
+}
 
 namespace xt
 {
+    template <class C>
+    std::string stringify(const C& container)
+    {
+        std::size_t i = 0;
+        std::stringstream ss;
+        ss << "[";
+        for (auto&& c : container)
+        {
+            if (i + 1 == container.size())
+            {
+                ss << c;
+            }
+            else
+            {
+                ss << c << ",";
+            }
+            ++i;
+        }
+        ss << "]";
+        return ss.str();
+    }
+
     template <class T, class A, class AV>
     bool operator==(const uvector<T, A>& lhs, const std::vector<T, AV>& rhs)
     {
@@ -60,12 +102,35 @@ namespace xt
         layout_type m_layout;
         assigner_type m_assigner;
 
-        inline size_type size() const { return m_data.size(); }
-        inline const shape_type& shape() const { return m_shape; }
-        inline const strides_type& strides() const { return m_strides; }
-        inline const strides_type& backstrides() const { return m_backstrides; }
-        inline layout_type layout() const { return m_layout; }
-        inline const vector_type& storage() const { return m_data; }
+        inline size_type size() const
+        {
+            return m_data.size();
+        }
+
+        inline const shape_type& shape() const
+        {
+            return m_shape;
+        }
+
+        inline const strides_type& strides() const
+        {
+            return m_strides;
+        }
+
+        inline const strides_type& backstrides() const
+        {
+            return m_backstrides;
+        }
+
+        inline layout_type layout() const
+        {
+            return m_layout;
+        }
+
+        inline const vector_type& storage() const
+        {
+            return m_data;
+        }
     };
 
     template <class C = dynamic_shape<std::size_t>>
@@ -75,9 +140,8 @@ namespace xt
         {
             this->m_strides = {8, 4, 1};
             this->m_backstrides = {16, 4, 3};
-            this->m_data = {-1, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-                            10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-                            20, 21, 22, 23};
+            this->m_data = {-1, 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
+                            12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};
             this->m_layout = layout_type::row_major;
         }
     };
@@ -89,10 +153,8 @@ namespace xt
         {
             this->m_strides = {1, 3, 6};
             this->m_backstrides = {2, 3, 18};
-            this->m_data = {-1, 8, 16, 4, 12, 20,
-                             1, 9, 17, 5, 13, 21,
-                             2, 10, 18, 6, 14, 22,
-                             3, 11, 19, 7, 15, 23};
+            this->m_data = {-1, 8,  16, 4, 12, 20, 1, 9,  17, 5, 13, 21,
+                            2,  10, 18, 6, 14, 22, 3, 11, 19, 7, 15, 23};
             this->m_layout = layout_type::column_major;
         }
     };
@@ -104,9 +166,8 @@ namespace xt
         {
             this->m_strides = {8, 1, 2};
             this->m_backstrides = {16, 1, 6};
-            this->m_data = {-1, 4, 1, 5, 2, 6, 3, 7,
-                            8, 12, 9, 13, 10, 14, 11, 15,
-                            16, 20, 17, 21, 18, 22, 19, 23};
+            this->m_data = {-1, 4,  1,  5,  2,  6,  3,  7,  8,  12, 9,  13,
+                            10, 14, 11, 15, 16, 20, 17, 21, 18, 22, 19, 23};
             this->m_layout = layout_type::dynamic;
         }
     };
@@ -146,12 +207,35 @@ namespace xt
         layout_type m_layout;
         assigner_type m_assigner;
 
-        inline size_type size() const { return m_data.size(); }
-        inline const shape_type& shape() const { return m_shape; }
-        inline const strides_type& strides() const { return m_strides; }
-        inline const strides_type& backstrides() const { return m_backstrides; }
-        inline layout_type layout() const { return m_layout; }
-        inline const vector_type& storage() const { return m_data; }
+        inline size_type size() const
+        {
+            return m_data.size();
+        }
+
+        inline const shape_type& shape() const
+        {
+            return m_shape;
+        }
+
+        inline const strides_type& strides() const
+        {
+            return m_strides;
+        }
+
+        inline const strides_type& backstrides() const
+        {
+            return m_backstrides;
+        }
+
+        inline layout_type layout() const
+        {
+            return m_layout;
+        }
+
+        inline const vector_type& storage() const
+        {
+            return m_data;
+        }
     };
 
     template <class V, class R>
@@ -159,7 +243,9 @@ namespace xt
     {
         EXPECT_TRUE(std::equal(vec.shape().cbegin(), vec.shape().cend(), result.shape().cbegin()));
         EXPECT_TRUE(std::equal(vec.strides().cbegin(), vec.strides().cend(), result.strides().cbegin()));
-        EXPECT_TRUE(std::equal(vec.backstrides().cbegin(), vec.backstrides().cend(), result.backstrides().cbegin()));
+        EXPECT_TRUE(
+            std::equal(vec.backstrides().cbegin(), vec.backstrides().cend(), result.backstrides().cbegin())
+        );
         EXPECT_EQ(vec.size(), result.size());
         if (compare_layout)
         {
@@ -171,14 +257,14 @@ namespace xt
     void test_resize(V& vec)
     {
         {
-            SCOPED_TRACE("row_major resize");
+            INFO("row_major resize");
             row_major_result<C> rm;
             vec.resize(rm.m_shape, layout_type::row_major);
             compare_shape(vec, rm);
         }
 
         {
-            SCOPED_TRACE("different types resize");
+            INFO("different types resize");
             row_major_result<C> rm;
             auto v_copy_a = vec;
             auto v_copy_b = vec;
@@ -191,21 +277,21 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("column_major resize");
+            INFO("column_major resize");
             column_major_result<C> cm;
             vec.resize(cm.m_shape, layout_type::column_major);
             compare_shape(vec, cm);
         }
 
         {
-            SCOPED_TRACE("central_major resize");
+            INFO("central_major resize");
             central_major_result<C> cem;
             vec.resize(cem.m_shape, cem.m_strides);
             compare_shape(vec, cem);
         }
 
         {
-            SCOPED_TRACE("unit_shape resize");
+            INFO("unit_shape resize");
             unit_shape_result<C> usr;
             vec.resize(usr.m_shape, layout_type::row_major);
             compare_shape(vec, usr, false);
@@ -217,7 +303,7 @@ namespace xt
     void test_reshape(V& vec)
     {
         {
-            SCOPED_TRACE("row_major reshape");
+            INFO("row_major reshape");
             row_major_result<C> rm;
             auto shape = rm.m_shape;
             std::size_t sz = compute_size(shape);
@@ -232,9 +318,27 @@ namespace xt
             vec.resize(shape);
             vec.reshape(signed_shape, layout_type::row_major);
             compare_shape(vec, rm);
+
+            vec.resize(shape);
+            vec.reshape({3, -1, 4}, layout_type::row_major);
+            compare_shape(vec, rm);
+
+            auto& vec_ref = vec.reshape({3, -1, 4}, layout_type::row_major);
+            compare_shape(vec_ref, rm);
+
             shape = rm.m_shape;
             shape.front() += 123;
-            EXPECT_THROW(vec.reshape(shape), std::runtime_error);
+            XT_EXPECT_THROW(vec_ref.reshape(shape), std::runtime_error);
+        }
+    }
+
+    template <class V>
+    void test_throwing_reshape(V& vec)
+    {
+        {
+            INFO("throwing reshape");
+            vec = xt::arange(6);
+            XT_EXPECT_THROW(vec.reshape({2}), std::runtime_error);
         }
     }
 
@@ -243,8 +347,9 @@ namespace xt
     {
         using shape_type = typename V::shape_type;
         using strides_type = typename V::strides_type;
+
         {
-            SCOPED_TRACE("transpose");
+            INFO("transpose");
             shape_type shape_new = vec.shape();
             auto vt = transpose(vec);
             std::reverse(shape_new.begin(), shape_new.end());
@@ -252,7 +357,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("transpose with data");
+            INFO("transpose with data");
             row_major_result<C> rm;
             vec.resize(rm.shape(), layout_type::row_major);
 
@@ -267,14 +372,10 @@ namespace xt
             EXPECT_EQ(vt.shape(), shape_new);
             EXPECT_TRUE(std::equal(vt.storage().cbegin(), vt.storage().cend(), rm.m_data.cbegin()));
 
-            strides_type new_strides = {rm.m_strides[2],
-                                        rm.m_strides[1],
-                                        rm.m_strides[0]};
+            strides_type new_strides = {rm.m_strides[2], rm.m_strides[1], rm.m_strides[0]};
             EXPECT_EQ(vt.strides(), new_strides);
 
-            strides_type new_backstrides = {rm.m_backstrides[2],
-                                            rm.m_backstrides[1],
-                                            rm.m_backstrides[0]};
+            strides_type new_backstrides = {rm.m_backstrides[2], rm.m_backstrides[1], rm.m_backstrides[0]};
             EXPECT_EQ(vt.backstrides(), new_backstrides);
 
             EXPECT_EQ(vec_copy(0, 0, 0), vt(0, 0, 0));
@@ -284,7 +385,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("transpose with permutation");
+            INFO("transpose with permutation");
             row_major_result<C> rm;
             vec.resize(rm.shape(), layout_type::row_major);
 
@@ -299,14 +400,10 @@ namespace xt
             EXPECT_TRUE(std::equal(vt.shape().cbegin(), vt.shape().cend(), shape_new.begin()));
             EXPECT_TRUE(std::equal(vt.storage().cbegin(), vt.storage().cend(), rm.m_data.cbegin()));
 
-            strides_type new_strides = {rm.m_strides[1],
-                                        rm.m_strides[0],
-                                        rm.m_strides[2]};
+            strides_type new_strides = {rm.m_strides[1], rm.m_strides[0], rm.m_strides[2]};
             EXPECT_EQ(vt.strides(), new_strides);
 
-            strides_type new_backstrides = {rm.m_backstrides[1],
-                                            rm.m_backstrides[0],
-                                            rm.m_backstrides[2]};
+            strides_type new_backstrides = {rm.m_backstrides[1], rm.m_backstrides[0], rm.m_backstrides[2]};
             EXPECT_EQ(vt.backstrides(), new_backstrides);
 
             EXPECT_EQ(vec_copy(0, 0, 0), vt(0, 0, 0));
@@ -320,14 +417,14 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("transpose permutation throws");
+            INFO("transpose permutation throws");
             row_major_result<C> rm;
             vec.reshape(rm.shape(), layout_type::row_major);
 
-            EXPECT_THROW(transpose(vec, {1, 1, 0}, check_policy::full()), transpose_error);
-            EXPECT_THROW(transpose(vec, {1, 0, 2, 3}, check_policy::full()), transpose_error);
-            EXPECT_THROW(transpose(vec, {1, 2}, check_policy::full()), transpose_error);
-            EXPECT_THROW(transpose(vec, {3, 0, 1}, check_policy::full()), transpose_error);
+            XT_EXPECT_THROW(transpose(vec, {1, 1, 0}, check_policy::full()), transpose_error);
+            XT_EXPECT_THROW(transpose(vec, {1, 0, 2, 3}, check_policy::full()), transpose_error);
+            XT_EXPECT_THROW(transpose(vec, {1, 2}, check_policy::full()), transpose_error);
+            XT_EXPECT_THROW(transpose(vec, {3, 0, 1}, check_policy::full()), transpose_error);
         }
     }
 
@@ -360,28 +457,29 @@ namespace xt
             }
         }
     }
+
     template <class V>
     void test_bound_check(V& vec)
     {
-#ifdef XTENSOR_ENABLE_ASSERT
-        EXPECT_ANY_THROW(vec(10, 10, 10));
+#if XTENSOR_ENABLE_ASSERT
+        XT_EXPECT_ANY_THROW(vec(10, 10, 10));
 #else
-        (void)vec;
+        (void) vec;
 #endif
     }
 
     template <class V>
     void test_access_check(V& vec)
     {
-        EXPECT_ANY_THROW(vec.at(10, 10, 10));
-        EXPECT_ANY_THROW(vec.at(0, 0, 0, 0, 0, 0));
+        XT_EXPECT_ANY_THROW(vec.at(10, 10, 10));
+        XT_EXPECT_ANY_THROW(vec.at(0, 0, 0, 0, 0, 0));
     }
 
     template <class V, class C = dynamic_shape<std::size_t>>
     void test_access(V& vec)
     {
         {
-            SCOPED_TRACE("row_major access");
+            INFO("row_major access");
             row_major_result<C> rm;
             vec.resize(rm.m_shape, layout_type::row_major);
             assign_array(vec, rm.m_assigner);
@@ -392,7 +490,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("column_major access");
+            INFO("column_major access");
             column_major_result<C> cm;
             vec.resize(cm.m_shape, layout_type::column_major);
             assign_array(vec, cm.m_assigner);
@@ -403,7 +501,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("central_major access");
+            INFO("central_major access");
             central_major_result<C> cem;
             vec.resize(cem.m_shape, cem.m_strides);
             assign_array(vec, cem.m_assigner);
@@ -414,7 +512,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("unit_shape access");
+            INFO("unit_shape access");
             unit_shape_result<C> usr;
             vec.resize(usr.m_shape, layout_type::row_major);
             assign_array(vec, usr.m_assigner);
@@ -429,7 +527,7 @@ namespace xt
     void test_unchecked(V& vec)
     {
         {
-            SCOPED_TRACE("row_major access");
+            INFO("row_major access");
             row_major_result<C> rm;
             vec.resize(rm.m_shape, layout_type::row_major);
             assign_array(vec, rm.m_assigner);
@@ -438,7 +536,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("column_major access");
+            INFO("column_major access");
             column_major_result<C> cm;
             vec.resize(cm.m_shape, layout_type::column_major);
             assign_array(vec, cm.m_assigner);
@@ -447,7 +545,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("central_major access");
+            INFO("central_major access");
             central_major_result<C> cem;
             vec.resize(cem.m_shape, cem.m_strides);
             assign_array(vec, cem.m_assigner);
@@ -456,7 +554,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("unit_shape access");
+            INFO("unit_shape access");
             unit_shape_result<C> usr;
             vec.resize(usr.m_shape, layout_type::row_major);
             assign_array(vec, usr.m_assigner);
@@ -469,7 +567,7 @@ namespace xt
     void test_at(V& vec)
     {
         {
-            SCOPED_TRACE("row_major access");
+            INFO("row_major access");
             row_major_result<C> rm;
             vec.resize(rm.m_shape, layout_type::row_major);
             safe_assign_array(vec, rm.m_assigner);
@@ -478,7 +576,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("column_major access");
+            INFO("column_major access");
             column_major_result<C> cm;
             vec.resize(cm.m_shape, layout_type::column_major);
             safe_assign_array(vec, cm.m_assigner);
@@ -487,7 +585,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("central_major access");
+            INFO("central_major access");
             central_major_result<C> cem;
             vec.resize(cem.m_shape, cem.m_strides);
             safe_assign_array(vec, cem.m_assigner);
@@ -496,7 +594,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("unit_shape access");
+            INFO("unit_shape access");
             unit_shape_result<C> usr;
             vec.resize(usr.m_shape, layout_type::row_major);
             safe_assign_array(vec, usr.m_assigner);
@@ -509,7 +607,7 @@ namespace xt
     void test_element(V& vec)
     {
         {
-            SCOPED_TRACE("row_major access");
+            INFO("row_major access");
             row_major_result<C> rm;
             vec.resize(rm.m_shape, layout_type::row_major);
             assign_array(vec, rm.m_assigner);
@@ -524,7 +622,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("column_major access");
+            INFO("column_major access");
             column_major_result<C> cm;
             vec.resize(cm.m_shape, layout_type::column_major);
             assign_array(vec, cm.m_assigner);
@@ -539,7 +637,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("central_major access");
+            INFO("central_major access");
             central_major_result<C> cem;
             vec.resize(cem.m_shape, cem.m_strides);
             assign_array(vec, cem.m_assigner);
@@ -554,7 +652,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("unit_shape access");
+            INFO("unit_shape access");
             unit_shape_result<C> usr;
             vec.resize(usr.m_shape, layout_type::row_major);
             assign_array(vec, usr.m_assigner);
@@ -594,7 +692,7 @@ namespace xt
         xindex index1 = {1, 1};
         xindex index2 = {2, 2, 2, 1, 3};
         {
-            SCOPED_TRACE("row_major access");
+            INFO("row_major access");
             row_major_result<C> rm;
             vec.resize(rm.m_shape, layout_type::row_major);
             indexed_assign_array(vec, rm.m_assigner);
@@ -606,7 +704,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("column_major access");
+            INFO("column_major access");
             column_major_result<C> cm;
             vec.resize(cm.m_shape, layout_type::column_major);
             indexed_assign_array(vec, cm.m_assigner);
@@ -618,7 +716,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("central_major access");
+            INFO("central_major access");
             central_major_result<C> cem;
             vec.resize(cem.m_shape, cem.m_strides);
             indexed_assign_array(vec, cem.m_assigner);
@@ -630,7 +728,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("unit_shape access");
+            INFO("unit_shape access");
             unit_shape_result<C> usr;
             vec.resize(usr.m_shape, layout_type::row_major);
             indexed_assign_array(vec, usr.m_assigner);
@@ -653,7 +751,7 @@ namespace xt
         vec.resize(s);
 
         {
-            SCOPED_TRACE("same shape");
+            INFO("same shape");
             shape_type s1 = s;
             bool res = vec.broadcast_shape(s1);
             EXPECT_EQ(s1, s);
@@ -661,7 +759,7 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("different shape");
+            INFO("different shape");
             shape_type s2 = {3, 5, 1, 2};
             shape_type s2r = {3, 5, 4, 2};
             bool res = vec.broadcast_shape(s2);
@@ -670,9 +768,9 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("incompatible shapes");
+            INFO("incompatible shapes");
             shape_type s4 = {2, 1, 3, 2};
-            EXPECT_THROW(vec.broadcast_shape(s4), broadcast_error);
+            XT_EXPECT_THROW(vec.broadcast_shape(s4), broadcast_error);
         }
     }
 
@@ -685,7 +783,7 @@ namespace xt
         vec.resize(s);
 
         {
-            SCOPED_TRACE("different dimensions");
+            INFO("different dimensions");
             shape_type s3 = {5, 3, 1, 4, 2};
             shape_type s3r = s3;
             bool res = vec.broadcast_shape(s3);
@@ -698,7 +796,7 @@ namespace xt
     void test_iterator(VRM& vecrm, VCM& veccm)
     {
         {
-            SCOPED_TRACE("row_major storage iterator");
+            INFO("row_major storage iterator");
             row_major_result<C> rm;
             vecrm.resize(rm.m_shape, layout_type::row_major);
             std::copy(rm.storage().cbegin(), rm.storage().cend(), vecrm.template begin<layout_type::row_major>());
@@ -707,10 +805,14 @@ namespace xt
         }
 
         {
-            SCOPED_TRACE("column_major storage iterator");
+            INFO("column_major storage iterator");
             column_major_result<C> cm;
             veccm.resize(cm.m_shape, layout_type::column_major);
-            std::copy(cm.storage().cbegin(), cm.storage().cend(), veccm.template begin<layout_type::column_major>());
+            std::copy(
+                cm.storage().cbegin(),
+                cm.storage().cend(),
+                veccm.template begin<layout_type::column_major>()
+            );
             EXPECT_TRUE(std::equal(cm.storage().cbegin(), cm.storage().cend(), veccm.storage().cbegin()));
             EXPECT_EQ(veccm.template end<layout_type::column_major>(), veccm.storage().end());
         }
@@ -720,7 +822,7 @@ namespace xt
     void test_fill(V& vec)
     {
         using value_type = typename V::value_type;
-        vec.resize({ 3, 4 });
+        vec.resize({3, 4});
         value_type v(4);
         vec.fill(v);
         for (auto it = vec.cbegin(); it != vec.cend(); ++it)
@@ -738,8 +840,8 @@ namespace xt
         size_t nb_iter = vec.size() / 2;
         using shape_type = std::vector<size_t>;
 
-        // broadcast_iterator
         {
+            INFO("broadcast_iterator");
             auto iter = vec.template begin<layout_type::row_major>();
             auto iter_end = vec.template end<layout_type::row_major>();
             for (size_t i = 0; i < nb_iter; ++i)
@@ -754,8 +856,8 @@ namespace xt
             EXPECT_EQ(iter, iter_end);
         }
 
-        // shaped_xiterator
         {
+            INFO("shaped_xiterator");
             shape_type shape(rm.m_shape.size() + 1);
             std::copy(rm.m_shape.begin(), rm.m_shape.end(), shape.begin() + 1);
             shape[0] = 2;
@@ -773,8 +875,8 @@ namespace xt
             EXPECT_EQ(iter, iter_end);
         }
 
-        // column broadcast_iterator
         {
+            INFO("column broadcast_iterator");
             auto iter = vec.template begin<layout_type::column_major>();
             auto iter_end = vec.template end<layout_type::column_major>();
             for (size_t i = 0; i < nb_iter; ++i)
@@ -789,8 +891,8 @@ namespace xt
             EXPECT_EQ(iter, iter_end);
         }
 
-        // column shaped_xiterator
         {
+            INFO("column shaped_xiterator");
             shape_type shape(rm.m_shape.size() + 1);
             std::copy(rm.m_shape.begin(), rm.m_shape.end(), shape.begin() + 1);
             shape[0] = 2;
@@ -817,8 +919,8 @@ namespace xt
         indexed_assign_array(vec, rm.m_assigner);
         size_t nb_iter = vec.size() / 2;
 
-        // broadcast_iterator
         {
+            INFO("broadcast_iterator");
             auto iter = vec.template rbegin<layout_type::row_major>();
             auto iter_end = vec.template rend<layout_type::row_major>();
             for (size_t i = 0; i < nb_iter; ++i)
@@ -833,8 +935,8 @@ namespace xt
             EXPECT_EQ(iter, iter_end);
         }
 
-        // shaped_xiterator
         {
+            INFO("shaped_xiterator");
             using shape_type = std::vector<size_t>;
             shape_type shape(rm.m_shape.size() + 1);
             std::copy(rm.m_shape.begin(), rm.m_shape.end(), shape.begin() + 1);
@@ -853,6 +955,66 @@ namespace xt
             EXPECT_EQ(iter, iter_end);
         }
     }
+
+    // C: container type (xarray<int>, xtensor<int>)
+    // SIT: storage iterator (int*, std::vector<int>::iterator)
+    // SCIT: storage const iterator (const int*, std::vector<int>::const_iterator)
+    template <class C, class SIT, class SCIT>
+    void test_iterator_types()
+    {
+        using stepper = xstepper<C>;
+        using const_stepper = xstepper<const C>;
+        using shape_type = typename C::shape_type;
+
+        using rm_layout_iterator = typename C::template layout_iterator<layout_type::row_major>;
+        using rm_const_layout_iterator = typename C::template const_layout_iterator<layout_type::row_major>;
+        using rm_reverse_layout_iterator = typename C::template reverse_layout_iterator<layout_type::row_major>;
+        using rm_const_reverse_layout_iterator = typename C::template const_reverse_layout_iterator<
+            layout_type::row_major>;
+
+        using exp_rm_layout_iterator = xiterator<stepper, shape_type*, layout_type::row_major>;
+        using exp_rm_const_layout_iterator = xiterator<const_stepper, shape_type*, layout_type::row_major>;
+        using exp_rm_reverse_layout_iterator = std::reverse_iterator<rm_layout_iterator>;
+        using exp_rm_const_reverse_layout_iterator = std::reverse_iterator<rm_const_layout_iterator>;
+
+        EXPECT_TRUE((std::is_same<rm_layout_iterator, exp_rm_layout_iterator>::value));
+        EXPECT_TRUE((std::is_same<rm_const_layout_iterator, exp_rm_const_layout_iterator>::value));
+        EXPECT_TRUE((std::is_same<rm_reverse_layout_iterator, exp_rm_reverse_layout_iterator>::value));
+        EXPECT_TRUE((std::is_same<rm_const_reverse_layout_iterator, exp_rm_const_reverse_layout_iterator>::value
+        ));
+
+        using cm_layout_iterator = typename C::template layout_iterator<layout_type::column_major>;
+        using cm_const_layout_iterator = typename C::template const_layout_iterator<layout_type::column_major>;
+        using cm_reverse_layout_iterator = typename C::template reverse_layout_iterator<layout_type::column_major>;
+        using cm_const_reverse_layout_iterator = typename C::template const_reverse_layout_iterator<
+            layout_type::column_major>;
+
+        using exp_cm_layout_iterator = xiterator<stepper, shape_type*, layout_type::column_major>;
+        using exp_cm_const_layout_iterator = xiterator<const_stepper, shape_type*, layout_type::column_major>;
+        using exp_cm_reverse_layout_iterator = std::reverse_iterator<cm_layout_iterator>;
+        using exp_cm_const_reverse_layout_iterator = std::reverse_iterator<cm_const_layout_iterator>;
+
+        EXPECT_TRUE((std::is_same<cm_layout_iterator, exp_cm_layout_iterator>::value));
+        EXPECT_TRUE((std::is_same<cm_const_layout_iterator, exp_cm_const_layout_iterator>::value));
+        EXPECT_TRUE((std::is_same<cm_reverse_layout_iterator, exp_cm_reverse_layout_iterator>::value));
+        EXPECT_TRUE((std::is_same<cm_const_reverse_layout_iterator, exp_cm_const_reverse_layout_iterator>::value
+        ));
+
+        using linear_iterator = typename C::linear_iterator;
+        using const_linear_iterator = typename C::const_linear_iterator;
+        using reverse_linear_iterator = typename C::reverse_linear_iterator;
+        using const_reverse_linear_iterator = typename C::const_reverse_linear_iterator;
+
+        using exp_linear_iterator = SIT;
+        using exp_const_linear_iterator = SCIT;
+        using exp_reverse_linear_iterator = std::reverse_iterator<SIT>;
+        using exp_const_reverse_linear_iterator = std::reverse_iterator<SCIT>;
+
+        EXPECT_TRUE((std::is_same<linear_iterator, exp_linear_iterator>::value));
+        EXPECT_TRUE((std::is_same<const_linear_iterator, exp_const_linear_iterator>::value));
+        EXPECT_TRUE((std::is_same<reverse_linear_iterator, exp_reverse_linear_iterator>::value));
+        EXPECT_TRUE((std::is_same<const_reverse_linear_iterator, exp_const_reverse_linear_iterator>::value));
+    }
 }
 
 #endif
diff --git a/test/test_common_macros.hpp b/test/test_common_macros.hpp
new file mode 100644
index 000000000..5d359a62d
--- /dev/null
+++ b/test/test_common_macros.hpp
@@ -0,0 +1,65 @@
+#ifndef TEST_COMMON_MACROS_HPP
+#define TEST_COMMON_MACROS_HPP
+
+#if defined(XTENSOR_DISABLE_EXCEPTIONS)
+#define DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
+#endif
+
+#include "xtensor/core/xtensor_config.hpp"
+
+#include "doctest/doctest.h"
+#include "test_utils.hpp"
+
+#if defined(XTENSOR_DISABLE_EXCEPTIONS)
+#warning "XT_EXPECT_THROW, XT_ASSERT_THROW, XT_EXPECT_ANY_THROW and XT_ASSERT_ANY_THROW are disabled"
+#define XT_EXPECT_THROW(x, y)
+#define XT_ASSERT_THROW(x, y)
+#define XT_EXPECT_ANY_THROW(x)
+#define XT_ASSERT_ANY_THROW(x)
+#define XT_EXPECT_NO_THROW(x) x;
+#define XT_ASSERT_NO_THROW(x) x;
+
+#else
+
+#define XT_EXPECT_THROW(x, y) CHECK_THROWS_AS(x, y);
+#define XT_ASSERT_THROW(x, y) REQUIRE_THROWS_AS(x, y);
+#define XT_EXPECT_ANY_THROW(x) CHECK_THROWS_AS(x, std::exception);
+#define XT_ASSERT_ANY_THROW(x) REQUIRE_THROWS_AS(x, std::exception);
+#define XT_EXPECT_NO_THROW(x) x;
+#define XT_ASSERT_NO_THROW(x) x;
+#endif
+
+
+#define EXPECT_NO_THROW(x) XT_EXPECT_NO_THROW(x)
+#define EXPECT_THROW(x, y) XT_EXPECT_THROW(x, y)
+
+#define TEST(A, B) TEST_CASE(#A "." #B)
+#define EXPECT_EQ(A, B) CHECK_EQ(A, B)
+#define EXPECT_NE(A, B) CHECK_NE(A, B)
+#define EXPECT_LE(A, B) CHECK_LE(A, B)
+#define EXPECT_GE(A, B) CHECK_GE(A, B)
+#define EXPECT_LT(A, B) CHECK_LT(A, B)
+#define EXPECT_GT(A, B) CHECK_GT(A, B)
+#define EXPECT_TRUE(A) CHECK_EQ(A, true)
+#define EXPECT_FALSE(A) CHECK_FALSE(A)
+
+#define ASSERT_EQ(A, B) REQUIRE_EQ(A, B)
+#define ASSERT_NE(A, B) REQUIRE_NE(A, B)
+#define ASSERT_LE(A, B) REQUIRE_LE(A, B)
+#define ASSERT_GE(A, B) REQUIRE_GE(A, B)
+#define ASSERT_LT(A, B) REQUIRE_LT(A, B)
+#define ASSERT_GT(A, B) REQUIRE_GT(A, B)
+#define ASSERT_TRUE(A) REQUIRE_EQ(A, true)
+#define ASSERT_FALSE(A) REQUIRE_FALSE(A)
+
+#define EXPECT_DOUBLE_EQ(x, y) CHECK(xt::scalar_near(x, y));
+#define EXPECT_TENSOR_EQ(x, y) CHECK(xt::tensor_near(x, y));
+
+#define TEST_F(FIXTURE_CLASS, NAME) TEST_CASE_FIXTURE(FIXTURE_CLASS, #NAME)
+
+#define HETEROGEN_PARAMETRIZED_DEFINE(ID) TEST_CASE_TEMPLATE_DEFINE(#ID, TypeParam, ID)
+
+#define HETEROGEN_PARAMETRIZED_TEST_APPLY(ID, TEST_FUNC) \
+    TEST_CASE_TEMPLATE_APPLY(ID, augment_t<std::decay_t<decltype(TEST_FUNC())>>)
+
+#endif
diff --git a/test/test_extended_broadcast_view.cpp b/test/test_extended_broadcast_view.cpp
index 7eba16010..a0237255c 100644
--- a/test/test_extended_broadcast_view.cpp
+++ b/test/test_extended_broadcast_view.cpp
@@ -1,22 +1,25 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
-
+ * 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. *
+ ****************************************************************************/
 // This file is generated from test/files/cppy_source/test_extended_broadcast_view.cppy by preprocess.py!
+// Warning: This file should not be modified directly! Instead, modify the `*.cppy` file.
+
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xstrided_view.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xview.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/views/xstrided_view.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -28,42 +31,44 @@ namespace xt
     TEST(xtest_extended, negative_slices_twod)
     {
         // py_a
-        xarray<double> py_a = {{ 0., 1., 2., 3., 4., 5., 6.},
-                               { 7., 8., 9.,10.,11.,12.,13.},
-                               {14.,15.,16.,17.,18.,19.,20.},
-                               {21.,22.,23.,24.,25.,26.,27.},
-                               {28.,29.,30.,31.,32.,33.,34.}};
+        xarray<double> py_a = {
+            {0., 1., 2., 3., 4., 5., 6.},
+            {7., 8., 9., 10., 11., 12., 13.},
+            {14., 15., 16., 17., 18., 19., 20.},
+            {21., 22., 23., 24., 25., 26., 27.},
+            {28., 29., 30., 31., 32., 33., 34.}
+        };
         // py_av0 = a[:-2, ::-1]
-        xarray<double> py_av0 = {{ 6., 5., 4., 3., 2., 1., 0.},
-                                 {13.,12.,11.,10., 9., 8., 7.},
-                                 {20.,19.,18.,17.,16.,15.,14.}};
-        auto av0 = xt::strided_view(py_a, {_r|_|-2, _r|_|_|-1});
+        xarray<double> py_av0 = {
+            {6., 5., 4., 3., 2., 1., 0.},
+            {13., 12., 11., 10., 9., 8., 7.},
+            {20., 19., 18., 17., 16., 15., 14.}
+        };
+        auto av0 = xt::strided_view(py_a, {_r | _ | -2, _r | _ | _ | -1});
         EXPECT_EQ(av0, py_av0);
         // py_av1 = a[::-1, ::-1]
-        xarray<double> py_av1 = {{34.,33.,32.,31.,30.,29.,28.},
-                                 {27.,26.,25.,24.,23.,22.,21.},
-                                 {20.,19.,18.,17.,16.,15.,14.},
-                                 {13.,12.,11.,10., 9., 8., 7.},
-                                 { 6., 5., 4., 3., 2., 1., 0.}};
-        auto av1 = xt::strided_view(py_a, {_r|_|_|-1, _r|_|_|-1});
+        xarray<double> py_av1 = {
+            {34., 33., 32., 31., 30., 29., 28.},
+            {27., 26., 25., 24., 23., 22., 21.},
+            {20., 19., 18., 17., 16., 15., 14.},
+            {13., 12., 11., 10., 9., 8., 7.},
+            {6., 5., 4., 3., 2., 1., 0.}
+        };
+        auto av1 = xt::strided_view(py_a, {_r | _ | _ | -1, _r | _ | _ | -1});
         EXPECT_EQ(av1, py_av1);
         // py_av2 = a[1:-3, -3:2:-1]
-        xarray<double> py_av2 = {{11.,10.}};
-        auto av2 = xt::strided_view(py_a, {_r|1|-3, _r|-3|2|-1});
+        xarray<double> py_av2 = {{11., 10.}};
+        auto av2 = xt::strided_view(py_a, {_r | 1 | -3, _r | -3 | 2 | -1});
         EXPECT_EQ(av2, py_av2);
         // py_av3 = a[-1:-4:-1, -3:1:-2]
-        xarray<double> py_av3 = {{32.,30.},
-                                 {25.,23.},
-                                 {18.,16.}};
-        auto av3 = xt::strided_view(py_a, {_r|-1|-4|-1, _r|-3|1|-2});
+        xarray<double> py_av3 = {{32., 30.}, {25., 23.}, {18., 16.}};
+        auto av3 = xt::strided_view(py_a, {_r | -1 | -4 | -1, _r | -3 | 1 | -2});
         EXPECT_EQ(av3, py_av3);
-        auto av4 = xt::strided_view(py_a, {_r|-3|-5, _r|-3|10});
+        auto av4 = xt::strided_view(py_a, {_r | -3 | -5, _r | -3 | 10});
         EXPECT_EQ(av4.size(), size_t(0));
         // py_av5 = a[-5:-2, -3:10]
-        xarray<double> py_av5 = {{ 4., 5., 6.},
-                                 {11.,12.,13.},
-                                 {18.,19.,20.}};
-        auto av5 = xt::strided_view(py_a, {_r|-5|-2, _r|-3|10});
+        xarray<double> py_av5 = {{4., 5., 6.}, {11., 12., 13.}, {18., 19., 20.}};
+        auto av5 = xt::strided_view(py_a, {_r | -5 | -2, _r | -3 | 10});
         EXPECT_EQ(av5, py_av5);
     }
 
@@ -77,26 +82,32 @@ namespace xt
     TEST(xtest_extended, negative_slices_math)
     {
         // py_a0
-        xarray<long> py_a0 = {{ 0, 1, 2, 3, 4, 5, 6},
-                              { 7, 8, 9,10,11,12,13},
-                              {14,15,16,17,18,19,20},
-                              {21,22,23,24,25,26,27},
-                              {28,29,30,31,32,33,34}};
-        strided_view(py_a0, {_r|0|-2}) += strided_view(py_a0, {{_r|_|3|-1}});
+        xarray<long> py_a0 = {
+            {0, 1, 2, 3, 4, 5, 6},
+            {7, 8, 9, 10, 11, 12, 13},
+            {14, 15, 16, 17, 18, 19, 20},
+            {21, 22, 23, 24, 25, 26, 27},
+            {28, 29, 30, 31, 32, 33, 34}
+        };
+        strided_view(py_a0, {_r | 0 | -2}) += strided_view(py_a0, {{_r | _ | 3 | -1}});
         // py_a
-        xarray<long> py_a = {{28,30,32,34,36,38,40},
-                             {35,37,39,41,43,45,47},
-                             {42,44,46,48,50,52,54},
-                             {21,22,23,24,25,26,27},
-                             {28,29,30,31,32,33,34}};
+        xarray<long> py_a = {
+            {28, 30, 32, 34, 36, 38, 40},
+            {35, 37, 39, 41, 43, 45, 47},
+            {42, 44, 46, 48, 50, 52, 54},
+            {21, 22, 23, 24, 25, 26, 27},
+            {28, 29, 30, 31, 32, 33, 34}
+        };
         EXPECT_EQ(py_a0, py_a);
-        strided_view(py_a0, {_r|_|_|-2}) += strided_view(py_a0, {_r|_|_|2});
+        strided_view(py_a0, {_r | _ | _ | -2}) += strided_view(py_a0, {_r | _ | _ | 2});
         // py_at
-        xarray<long> py_at = {{ 56, 59, 62, 65, 68, 71, 74},
-                              { 35, 37, 39, 41, 43, 45, 47},
-                              { 84, 88, 92, 96,100,104,108},
-                              { 21, 22, 23, 24, 25, 26, 27},
-                              { 56, 59, 62, 65, 68, 71, 74}};
+        xarray<long> py_at = {
+            {56, 59, 62, 65, 68, 71, 74},
+            {35, 37, 39, 41, 43, 45, 47},
+            {84, 88, 92, 96, 100, 104, 108},
+            {21, 22, 23, 24, 25, 26, 27},
+            {56, 59, 62, 65, 68, 71, 74}
+        };
         EXPECT_EQ(py_a0, py_at);
     }
 
@@ -115,331 +126,665 @@ namespace xt
     TEST(xtest_extended, broadcasting)
     {
         // py_a1
-        xarray<long> py_a1 = {{{ 0, 1, 2, 3, 4, 5, 6}},
-                             
-                              {{ 7, 8, 9,10,11,12,13}},
-                             
-                              {{14,15,16,17,18,19,20}},
-                             
-                              {{21,22,23,24,25,26,27}},
-                             
-                              {{28,29,30,31,32,33,34}}};
+        xarray<long> py_a1 = {
+            {{0, 1, 2, 3, 4, 5, 6}},
+
+            {{7, 8, 9, 10, 11, 12, 13}},
+
+            {{14, 15, 16, 17, 18, 19, 20}},
+
+            {{21, 22, 23, 24, 25, 26, 27}},
+
+            {{28, 29, 30, 31, 32, 33, 34}}
+        };
         // py_a2
-        xarray<long> py_a2 = {{{{28,30,32,34,36,38,40}},
-                             
-                               {{35,37,39,41,43,45,47}},
-                             
-                               {{42,44,46,48,50,52,54}},
-                             
-                               {{21,22,23,24,25,26,27}},
-                             
-                               {{28,29,30,31,32,33,34}}}};
+        xarray<long> py_a2 = {
+            {{{28, 30, 32, 34, 36, 38, 40}},
+
+             {{35, 37, 39, 41, 43, 45, 47}},
+
+             {{42, 44, 46, 48, 50, 52, 54}},
+
+             {{21, 22, 23, 24, 25, 26, 27}},
+
+             {{28, 29, 30, 31, 32, 33, 34}}}
+        };
         // py_b1
-        xarray<long> py_b1 = {0,1,2,3,4,5,6};
+        xarray<long> py_b1 = {0, 1, 2, 3, 4, 5, 6};
         // py_b2
-        xarray<long> py_b2 = {{{{0,1,2,3,4,5,6}}}};
+        xarray<long> py_b2 = {{{{0, 1, 2, 3, 4, 5, 6}}}};
         // py_b3
-        xarray<double> py_b3 = {{{{0.3745401188473625,0.9507143064099162,0.7319939418114051,
-                                   0.5986584841970366,0.1560186404424365,0.1559945203362026,
-                                   0.0580836121681995},
-                                  {0.8661761457749352,0.6011150117432088,0.7080725777960455,
-                                   0.0205844942958024,0.9699098521619943,0.8324426408004217,
-                                   0.2123391106782762},
-                                  {0.1818249672071006,0.1834045098534338,0.3042422429595377,
-                                   0.5247564316322378,0.4319450186421158,0.2912291401980419,
-                                   0.6118528947223795},
-                                  {0.1394938606520418,0.2921446485352182,0.3663618432936917,
-                                   0.4560699842170359,0.7851759613930136,0.1996737821583597,
-                                   0.5142344384136116}},
-                               
-                                 {{0.5924145688620425,0.0464504127199977,0.6075448519014384,
-                                   0.1705241236872915,0.0650515929852795,0.9488855372533332,
-                                   0.9656320330745594},
-                                  {0.8083973481164611,0.3046137691733707,0.0976721140063839,
-                                   0.6842330265121569,0.4401524937396013,0.1220382348447788,
-                                   0.4951769101112702},
-                                  {0.0343885211152184,0.9093204020787821,0.2587799816000169,
-                                   0.662522284353982 ,0.311711076089411 ,0.5200680211778108,
-                                   0.5467102793432796},
-                                  {0.184854455525527 ,0.9695846277645586,0.7751328233611146,
-                                   0.9394989415641891,0.8948273504276488,0.5978999788110851,
-                                   0.9218742350231168}},
-                               
-                                 {{0.0884925020519195,0.1959828624191452,0.0452272889105381,
-                                   0.3253303307632643,0.388677289689482 ,0.2713490317738959,
-                                   0.8287375091519293},
-                                  {0.3567533266935893,0.2809345096873808,0.5426960831582485,
-                                   0.1409242249747626,0.8021969807540397,0.0745506436797708,
-                                   0.9868869366005173},
-                                  {0.7722447692966574,0.1987156815341724,0.0055221171236024,
-                                   0.8154614284548342,0.7068573438476171,0.7290071680409873,
-                                   0.7712703466859457},
-                                  {0.0740446517340904,0.3584657285442726,0.1158690595251297,
-                                   0.8631034258755935,0.6232981268275579,0.3308980248526492,
-                                   0.0635583502860236}},
-                               
-                                 {{0.3109823217156622,0.325183322026747 ,0.7296061783380641,
-                                   0.6375574713552131,0.8872127425763265,0.4722149251619493,
-                                   0.1195942459383017},
-                                  {0.713244787222995 ,0.7607850486168974,0.5612771975694962,
-                                   0.770967179954561 ,0.4937955963643907,0.5227328293819941,
-                                   0.4275410183585496},
-                                  {0.0254191267440952,0.1078914269933045,0.0314291856867343,
-                                   0.6364104112637804,0.3143559810763267,0.5085706911647028,
-                                   0.907566473926093 },
-                                  {0.2492922291488749,0.4103829230356297,0.7555511385430487,
-                                   0.2287981654916225,0.076979909828793 ,0.289751452913768 ,
-                                   0.1612212872540044}},
-                               
-                                 {{0.9296976523425731,0.808120379564417 ,0.6334037565104235,
-                                   0.8714605901877177,0.8036720768991145,0.1865700588860358,
-                                   0.8925589984899778},
-                                  {0.5393422419156507,0.8074401551640625,0.8960912999234932,
-                                   0.3180034749718639,0.1100519245276768,0.2279351625419417,
-                                   0.4271077886262563},
-                                  {0.8180147659224931,0.8607305832563434,0.0069521305311907,
-                                   0.5107473025775657,0.417411003148779 ,0.2221078104707302,
-                                   0.1198653673336828},
-                                  {0.337615171403628 ,0.9429097039125192,0.3232029320207552,
-                                   0.5187906217433661,0.7030189588951778,0.363629602379294 ,
-                                   0.9717820827209607}}},
-                               
-                               
-                                {{{0.9624472949421112,0.2517822958253642,0.4972485058923855,
-                                   0.3008783098167697,0.2848404943774676,0.0368869473545328,
-                                   0.6095643339798968},
-                                  {0.5026790232288615,0.0514787512499894,0.2786464642366114,
-                                   0.9082658859666537,0.2395618906669724,0.1448948720912231,
-                                   0.489452760277563 },
-                                  {0.9856504541106007,0.2420552715115004,0.6721355474058786,
-                                   0.7616196153287176,0.2376375439923997,0.7282163486118596,
-                                   0.3677831327192532},
-                                  {0.6323058305935795,0.6335297107608947,0.5357746840747585,
-                                   0.0902897700544083,0.835302495589238 ,0.3207800649717358,
-                                   0.1865185103998542}},
-                               
-                                 {{0.0407751415547639,0.5908929431882418,0.6775643618422824,
-                                   0.0165878289278562,0.512093058299281 ,0.226495775197938 ,
-                                   0.6451727904094499},
-                                  {0.1743664290049914,0.690937738102466 ,0.3867353463005374,
-                                   0.9367299887367345,0.1375209441459933,0.3410663510502585,
-                                   0.1134735212405891},
-                                  {0.9246936182785628,0.877339353380981 ,0.2579416277151556,
-                                   0.659984046034179 ,0.8172222002012158,0.5552008115994623,
-                                   0.5296505783560065},
-                                  {0.2418522909004517,0.0931027678058992,0.8972157579533268,
-                                   0.9004180571633305,0.6331014572732679,0.3390297910487007,
-                                   0.3492095746126609}},
-                               
-                                 {{0.7259556788702394,0.8971102599525771,0.8870864242651173,
-                                   0.7798755458576239,0.6420316461542878,0.0841399649950488,
-                                   0.1616287140946138},
-                                  {0.8985541885270792,0.6064290596595899,0.0091970516166296,
-                                   0.1014715428660321,0.6635017691080558,0.0050615838462187,
-                                   0.1608080514174987},
-                                  {0.5487337893665861,0.6918951976926933,0.6519612595026005,
-                                   0.2242693094605598,0.7121792213475359,0.2372490874968001,
-                                   0.3253996981592677},
-                                  {0.7464914051180241,0.6496328990472147,0.8492234104941779,
-                                   0.6576128923003434,0.5683086033354716,0.0936747678280925,
-                                   0.3677158030594335}},
-                               
-                                 {{0.2652023676817254,0.2439896433790836,0.9730105547524456,
-                                   0.3930977246667604,0.8920465551771133,0.6311386259972629,
-                                   0.7948113035416484},
-                                  {0.5026370931051921,0.5769038846263591,0.4925176938188639,
-                                   0.1952429877980445,0.7224521152615053,0.2807723624408558,
-                                   0.0243159664314538},
-                                  {0.6454722959071678,0.1771106794070489,0.9404585843529143,
-                                   0.9539285770025874,0.9148643902204485,0.3701587002554444,
-                                   0.0154566165288674},
-                                  {0.9283185625877254,0.4281841483173143,0.9666548190436696,
-                                   0.9636199770892528,0.8530094554673601,0.2944488920695857,
-                                   0.3850977286019253}},
-                               
-                                 {{0.8511366715168569,0.3169220051562777,0.1694927466860925,
-                                   0.5568012624583502,0.936154774160781 ,0.696029796674973 ,
-                                   0.570061170089365 },
-                                  {0.0971764937707685,0.6150072266991697,0.9900538501042633,
-                                   0.140084015236524 ,0.5183296523637367,0.8773730719279554,
-                                   0.7407686177542044},
-                                  {0.697015740995268 ,0.7024840839871093,0.3594911512197552,
-                                   0.2935918442644934,0.8093611554785136,0.8101133946791808,
-                                   0.8670723185801037},
-                                  {0.9132405525564713,0.5113423988609378,0.5015162946871996,
-                                   0.7982951789667752,0.6499639307777652,0.7019668772577033,
-                                   0.795792669436101 }}}};
+        xarray<double> py_b3 = {
+            {{{0.3745401188473625,
+               0.9507143064099162,
+               0.7319939418114051,
+               0.5986584841970366,
+               0.1560186404424365,
+               0.1559945203362026,
+               0.0580836121681995},
+              {0.8661761457749352,
+               0.6011150117432088,
+               0.7080725777960455,
+               0.0205844942958024,
+               0.9699098521619943,
+               0.8324426408004217,
+               0.2123391106782762},
+              {0.1818249672071006,
+               0.1834045098534338,
+               0.3042422429595377,
+               0.5247564316322378,
+               0.4319450186421158,
+               0.2912291401980419,
+               0.6118528947223795},
+              {0.1394938606520418,
+               0.2921446485352182,
+               0.3663618432936917,
+               0.4560699842170359,
+               0.7851759613930136,
+               0.1996737821583597,
+               0.5142344384136116}},
+
+             {{0.5924145688620425,
+               0.0464504127199977,
+               0.6075448519014384,
+               0.1705241236872915,
+               0.0650515929852795,
+               0.9488855372533332,
+               0.9656320330745594},
+              {0.8083973481164611,
+               0.3046137691733707,
+               0.0976721140063839,
+               0.6842330265121569,
+               0.4401524937396013,
+               0.1220382348447788,
+               0.4951769101112702},
+              {0.0343885211152184,
+               0.9093204020787821,
+               0.2587799816000169,
+               0.662522284353982,
+               0.311711076089411,
+               0.5200680211778108,
+               0.5467102793432796},
+              {0.184854455525527,
+               0.9695846277645586,
+               0.7751328233611146,
+               0.9394989415641891,
+               0.8948273504276488,
+               0.5978999788110851,
+               0.9218742350231168}},
+
+             {{0.0884925020519195,
+               0.1959828624191452,
+               0.0452272889105381,
+               0.3253303307632643,
+               0.388677289689482,
+               0.2713490317738959,
+               0.8287375091519293},
+              {0.3567533266935893,
+               0.2809345096873808,
+               0.5426960831582485,
+               0.1409242249747626,
+               0.8021969807540397,
+               0.0745506436797708,
+               0.9868869366005173},
+              {0.7722447692966574,
+               0.1987156815341724,
+               0.0055221171236024,
+               0.8154614284548342,
+               0.7068573438476171,
+               0.7290071680409873,
+               0.7712703466859457},
+              {0.0740446517340904,
+               0.3584657285442726,
+               0.1158690595251297,
+               0.8631034258755935,
+               0.6232981268275579,
+               0.3308980248526492,
+               0.0635583502860236}},
+
+             {{0.3109823217156622,
+               0.325183322026747,
+               0.7296061783380641,
+               0.6375574713552131,
+               0.8872127425763265,
+               0.4722149251619493,
+               0.1195942459383017},
+              {0.713244787222995,
+               0.7607850486168974,
+               0.5612771975694962,
+               0.770967179954561,
+               0.4937955963643907,
+               0.5227328293819941,
+               0.4275410183585496},
+              {0.0254191267440952,
+               0.1078914269933045,
+               0.0314291856867343,
+               0.6364104112637804,
+               0.3143559810763267,
+               0.5085706911647028,
+               0.907566473926093},
+              {0.2492922291488749,
+               0.4103829230356297,
+               0.7555511385430487,
+               0.2287981654916225,
+               0.076979909828793,
+               0.289751452913768,
+               0.1612212872540044}},
+
+             {{0.9296976523425731,
+               0.808120379564417,
+               0.6334037565104235,
+               0.8714605901877177,
+               0.8036720768991145,
+               0.1865700588860358,
+               0.8925589984899778},
+              {0.5393422419156507,
+               0.8074401551640625,
+               0.8960912999234932,
+               0.3180034749718639,
+               0.1100519245276768,
+               0.2279351625419417,
+               0.4271077886262563},
+              {0.8180147659224931,
+               0.8607305832563434,
+               0.0069521305311907,
+               0.5107473025775657,
+               0.417411003148779,
+               0.2221078104707302,
+               0.1198653673336828},
+              {0.337615171403628,
+               0.9429097039125192,
+               0.3232029320207552,
+               0.5187906217433661,
+               0.7030189588951778,
+               0.363629602379294,
+               0.9717820827209607}}},
+
+
+            {{{0.9624472949421112,
+               0.2517822958253642,
+               0.4972485058923855,
+               0.3008783098167697,
+               0.2848404943774676,
+               0.0368869473545328,
+               0.6095643339798968},
+              {0.5026790232288615,
+               0.0514787512499894,
+               0.2786464642366114,
+               0.9082658859666537,
+               0.2395618906669724,
+               0.1448948720912231,
+               0.489452760277563},
+              {0.9856504541106007,
+               0.2420552715115004,
+               0.6721355474058786,
+               0.7616196153287176,
+               0.2376375439923997,
+               0.7282163486118596,
+               0.3677831327192532},
+              {0.6323058305935795,
+               0.6335297107608947,
+               0.5357746840747585,
+               0.0902897700544083,
+               0.835302495589238,
+               0.3207800649717358,
+               0.1865185103998542}},
+
+             {{0.0407751415547639,
+               0.5908929431882418,
+               0.6775643618422824,
+               0.0165878289278562,
+               0.512093058299281,
+               0.226495775197938,
+               0.6451727904094499},
+              {0.1743664290049914,
+               0.690937738102466,
+               0.3867353463005374,
+               0.9367299887367345,
+               0.1375209441459933,
+               0.3410663510502585,
+               0.1134735212405891},
+              {0.9246936182785628,
+               0.877339353380981,
+               0.2579416277151556,
+               0.659984046034179,
+               0.8172222002012158,
+               0.5552008115994623,
+               0.5296505783560065},
+              {0.2418522909004517,
+               0.0931027678058992,
+               0.8972157579533268,
+               0.9004180571633305,
+               0.6331014572732679,
+               0.3390297910487007,
+               0.3492095746126609}},
+
+             {{0.7259556788702394,
+               0.8971102599525771,
+               0.8870864242651173,
+               0.7798755458576239,
+               0.6420316461542878,
+               0.0841399649950488,
+               0.1616287140946138},
+              {0.8985541885270792,
+               0.6064290596595899,
+               0.0091970516166296,
+               0.1014715428660321,
+               0.6635017691080558,
+               0.0050615838462187,
+               0.1608080514174987},
+              {0.5487337893665861,
+               0.6918951976926933,
+               0.6519612595026005,
+               0.2242693094605598,
+               0.7121792213475359,
+               0.2372490874968001,
+               0.3253996981592677},
+              {0.7464914051180241,
+               0.6496328990472147,
+               0.8492234104941779,
+               0.6576128923003434,
+               0.5683086033354716,
+               0.0936747678280925,
+               0.3677158030594335}},
+
+             {{0.2652023676817254,
+               0.2439896433790836,
+               0.9730105547524456,
+               0.3930977246667604,
+               0.8920465551771133,
+               0.6311386259972629,
+               0.7948113035416484},
+              {0.5026370931051921,
+               0.5769038846263591,
+               0.4925176938188639,
+               0.1952429877980445,
+               0.7224521152615053,
+               0.2807723624408558,
+               0.0243159664314538},
+              {0.6454722959071678,
+               0.1771106794070489,
+               0.9404585843529143,
+               0.9539285770025874,
+               0.9148643902204485,
+               0.3701587002554444,
+               0.0154566165288674},
+              {0.9283185625877254,
+               0.4281841483173143,
+               0.9666548190436696,
+               0.9636199770892528,
+               0.8530094554673601,
+               0.2944488920695857,
+               0.3850977286019253}},
+
+             {{0.8511366715168569,
+               0.3169220051562777,
+               0.1694927466860925,
+               0.5568012624583502,
+               0.936154774160781,
+               0.696029796674973,
+               0.570061170089365},
+              {0.0971764937707685,
+               0.6150072266991697,
+               0.9900538501042633,
+               0.140084015236524,
+               0.5183296523637367,
+               0.8773730719279554,
+               0.7407686177542044},
+              {0.697015740995268,
+               0.7024840839871093,
+               0.3594911512197552,
+               0.2935918442644934,
+               0.8093611554785136,
+               0.8101133946791808,
+               0.8670723185801037},
+              {0.9132405525564713,
+               0.5113423988609378,
+               0.5015162946871996,
+               0.7982951789667752,
+               0.6499639307777652,
+               0.7019668772577033,
+               0.795792669436101}}}
+        };
         xt::xarray<long> a1_a2 = py_a1 + py_a2;
         // py_a1_a2
-        xarray<long> py_a1_a2 = {{{{28,31,34,37,40,43,46}},
-                                
-                                  {{42,45,48,51,54,57,60}},
-                                
-                                  {{56,59,62,65,68,71,74}},
-                                
-                                  {{42,44,46,48,50,52,54}},
-                                
-                                  {{56,58,60,62,64,66,68}}}};
+        xarray<long> py_a1_a2 = {
+            {{{28, 31, 34, 37, 40, 43, 46}},
+
+             {{42, 45, 48, 51, 54, 57, 60}},
+
+             {{56, 59, 62, 65, 68, 71, 74}},
+
+             {{42, 44, 46, 48, 50, 52, 54}},
+
+             {{56, 58, 60, 62, 64, 66, 68}}}
+        };
         EXPECT_EQ(a1_a2, py_a1_a2);
 
         xt::xarray<long> b1_a1 = py_b1 + py_a1;
         // py_b1_a1
-        xarray<long> py_b1_a1 = {{{ 0, 2, 4, 6, 8,10,12}},
-                                
-                                 {{ 7, 9,11,13,15,17,19}},
-                                
-                                 {{14,16,18,20,22,24,26}},
-                                
-                                 {{21,23,25,27,29,31,33}},
-                                
-                                 {{28,30,32,34,36,38,40}}};
+        xarray<long> py_b1_a1 = {
+            {{0, 2, 4, 6, 8, 10, 12}},
+
+            {{7, 9, 11, 13, 15, 17, 19}},
+
+            {{14, 16, 18, 20, 22, 24, 26}},
+
+            {{21, 23, 25, 27, 29, 31, 33}},
+
+            {{28, 30, 32, 34, 36, 38, 40}}
+        };
         EXPECT_EQ(b1_a1, py_b1_a1);
 
         xt::xarray<long> a1_b2 = py_a1 + py_b2;
         // py_a1_b2
-        xarray<long> py_a1_b2 = {{{{ 0, 2, 4, 6, 8,10,12}},
-                                
-                                  {{ 7, 9,11,13,15,17,19}},
-                                
-                                  {{14,16,18,20,22,24,26}},
-                                
-                                  {{21,23,25,27,29,31,33}},
-                                
-                                  {{28,30,32,34,36,38,40}}}};
+        xarray<long> py_a1_b2 = {
+            {{{0, 2, 4, 6, 8, 10, 12}},
+
+             {{7, 9, 11, 13, 15, 17, 19}},
+
+             {{14, 16, 18, 20, 22, 24, 26}},
+
+             {{21, 23, 25, 27, 29, 31, 33}},
+
+             {{28, 30, 32, 34, 36, 38, 40}}}
+        };
         EXPECT_EQ(a1_b2, py_a1_b2);
 
         xt::xarray<double> a2_b3 = xt::cast<double>(py_a2) + py_b3;
         // py_a2_b3
-        xarray<double> py_a2_b3 = {{{{28.374540118847364,30.950714306409917,32.7319939418114  ,
-                                      34.59865848419704 ,36.15601864044244 ,38.1559945203362  ,
-                                      40.0580836121682  },
-                                     {28.866176145774936,30.601115011743207,32.708072577796045,
-                                      34.020584494295804,36.969909852162   ,38.83244264080042 ,
-                                      40.21233911067828 },
-                                     {28.1818249672071  ,30.183404509853435,32.30424224295954 ,
-                                      34.52475643163224 ,36.43194501864212 ,38.29122914019804 ,
-                                      40.61185289472238 },
-                                     {28.139493860652042,30.292144648535217,32.36636184329369 ,
-                                      34.45606998421704 ,36.785175961393016,38.19967378215836 ,
-                                      40.51423443841361 }},
-                                  
-                                    {{35.59241456886204 ,37.04645041272    ,39.60754485190144 ,
-                                      41.170524123687294,43.06505159298528 ,45.94888553725333 ,
-                                      47.965632033074556},
-                                     {35.80839734811646 ,37.30461376917337 ,39.097672114006386,
-                                      41.68423302651216 ,43.4401524937396  ,45.12203823484478 ,
-                                      47.49517691011127 },
-                                     {35.03438852111522 ,37.909320402078784,39.258779981600014,
-                                      41.66252228435398 ,43.31171107608941 ,45.52006802117781 ,
-                                      47.54671027934328 },
-                                     {35.184854455525524,37.96958462776456 ,39.77513282336111 ,
-                                      41.93949894156419 ,43.89482735042765 ,45.597899978811085,
-                                      47.92187423502312 }},
-                                  
-                                    {{42.08849250205192 ,44.19598286241914 ,46.04522728891054 ,
-                                      48.325330330763265,50.38867728968948 ,52.271349031773894,
-                                      54.82873750915193 },
-                                     {42.35675332669359 ,44.280934509687384,46.54269608315825 ,
-                                      48.14092422497476 ,50.80219698075404 ,52.07455064367977 ,
-                                      54.98688693660052 },
-                                     {42.772244769296655,44.198715681534175,46.005522117123604,
-                                      48.81546142845483 ,50.70685734384762 ,52.72900716804099 ,
-                                      54.771270346685945},
-                                     {42.07404465173409 ,44.358465728544274,46.11586905952513 ,
-                                      48.86310342587559 ,50.62329812682756 ,52.33089802485265 ,
-                                      54.06355835028602 }},
-                                  
-                                    {{21.310982321715663,22.325183322026746,23.729606178338063,
-                                      24.637557471355212,25.887212742576327,26.47221492516195 ,
-                                      27.119594245938302},
-                                     {21.713244787222994,22.760785048616896,23.561277197569495,
-                                      24.77096717995456 ,25.49379559636439 ,26.522732829381994,
-                                      27.42754101835855 },
-                                     {21.025419126744094,22.107891426993305,23.031429185686733,
-                                      24.636410411263782,25.314355981076325,26.508570691164703,
-                                      27.907566473926092},
-                                     {21.249292229148875,22.41038292303563 ,23.755551138543048,
-                                      24.22879816549162 ,25.076979909828793,26.28975145291377 ,
-                                      27.161221287254005}},
-                                  
-                                    {{28.929697652342572,29.808120379564418,30.633403756510422,
-                                      31.871460590187716,32.80367207689911 ,33.18657005888603 ,
-                                      34.892558998489974},
-                                     {28.53934224191565 ,29.807440155164063,30.896091299923494,
-                                      31.318003474971864,32.110051924527674,33.22793516254194 ,
-                                      34.42710778862626 },
-                                     {28.81801476592249 ,29.860730583256345,30.00695213053119 ,
-                                      31.510747302577567,32.41741100314878 ,33.22210781047073 ,
-                                      34.11986536733368 },
-                                     {28.337615171403627,29.94290970391252 ,30.323202932020756,
-                                      31.518790621743367,32.70301895889518 ,33.36362960237929 ,
-                                      34.971782082720964}}},
-                                  
-                                  
-                                   {{{28.962447294942113,30.251782295825365,32.49724850589239 ,
-                                      34.30087830981677 ,36.28484049437747 ,38.03688694735453 ,
-                                      40.6095643339799  },
-                                     {28.50267902322886 ,30.051478751249988,32.27864646423661 ,
-                                      34.90826588596666 ,36.23956189066697 ,38.14489487209122 ,
-                                      40.489452760277565},
-                                     {28.9856504541106  ,30.2420552715115  ,32.67213554740588 ,
-                                      34.76161961532872 ,36.2376375439924  ,38.72821634861186 ,
-                                      40.367783132719254},
-                                     {28.63230583059358 ,30.633529710760893,32.53577468407476 ,
-                                      34.09028977005441 ,36.83530249558924 ,38.320780064971736,
-                                      40.18651851039986 }},
-                                  
-                                    {{35.04077514155476 ,37.590892943188244,39.67756436184228 ,
-                                      41.016587828927854,43.51209305829928 ,45.22649577519794 ,
-                                      47.64517279040945 },
-                                     {35.17436642900499 ,37.69093773810246 ,39.38673534630054 ,
-                                      41.93672998873674 ,43.13752094414599 ,45.34106635105026 ,
-                                      47.113473521240586},
-                                     {35.92469361827856 ,37.87733935338098 ,39.257941627715155,
-                                      41.65998404603418 ,43.817222200201215,45.55520081159946 ,
-                                      47.529650578356005},
-                                     {35.241852290900454,37.0931027678059  ,39.897215757953326,
-                                      41.90041805716333 ,43.63310145727327 ,45.3390297910487  ,
-                                      47.34920957461266 }},
-                                  
-                                    {{42.72595567887024 ,44.897110259952576,46.88708642426512 ,
-                                      48.77987554585762 ,50.64203164615429 ,52.084139964995046,
-                                      54.16162871409461 },
-                                     {42.89855418852708 ,44.60642905965959 ,46.00919705161663 ,
-                                      48.10147154286603 ,50.66350176910806 ,52.00506158384622 ,
-                                      54.1608080514175  },
-                                     {42.54873378936659 ,44.691895197692695,46.6519612595026  ,
-                                      48.22426930946056 ,50.71217922134753 ,52.2372490874968  ,
-                                      54.325399698159266},
-                                     {42.74649140511802 ,44.64963289904721 ,46.849223410494176,
-                                      48.65761289230034 ,50.568308603335474,52.09367476782809 ,
-                                      54.36771580305943 }},
-                                  
-                                    {{21.265202367681724,22.243989643379084,23.973010554752445,
-                                      24.39309772466676 ,25.892046555177114,26.631138625997263,
-                                      27.79481130354165 },
-                                     {21.502637093105193,22.576903884626358,23.492517693818865,
-                                      24.195242987798043,25.722452115261504,26.280772362440857,
-                                      27.024315966431455},
-                                     {21.64547229590717 ,22.17711067940705 ,23.940458584352914,
-                                      24.953928577002586,25.914864390220448,26.370158700255445,
-                                      27.015456616528866},
-                                     {21.928318562587727,22.428184148317314,23.96665481904367 ,
-                                      24.96361997708925 ,25.85300945546736 ,26.294448892069585,
-                                      27.385097728601924}},
-                                  
-                                    {{28.85113667151686 ,29.31692200515628 ,30.169492746686092,
-                                      31.55680126245835 ,32.936154774160784,33.69602979667497 ,
-                                      34.57006117008937 },
-                                     {28.097176493770768,29.61500722669917 ,30.990053850104264,
-                                      31.140084015236525,32.51832965236374 ,33.877373071927956,
-                                      34.740768617754206},
-                                     {28.69701574099527 ,29.70248408398711 ,30.359491151219757,
-                                      31.293591844264494,32.80936115547851 ,33.81011339467918 ,
-                                      34.86707231858011 },
-                                     {28.91324055255647 ,29.511342398860936,30.5015162946872  ,
-                                      31.798295178966775,32.649963930777766,33.7019668772577  ,
-                                      34.7957926694361  }}}};
+        xarray<double> py_a2_b3 = {
+            {{{28.374540118847364,
+               30.950714306409917,
+               32.7319939418114,
+               34.59865848419704,
+               36.15601864044244,
+               38.1559945203362,
+               40.0580836121682},
+              {28.866176145774936,
+               30.601115011743207,
+               32.708072577796045,
+               34.020584494295804,
+               36.969909852162,
+               38.83244264080042,
+               40.21233911067828},
+              {28.1818249672071,
+               30.183404509853435,
+               32.30424224295954,
+               34.52475643163224,
+               36.43194501864212,
+               38.29122914019804,
+               40.61185289472238},
+              {28.139493860652042,
+               30.292144648535217,
+               32.36636184329369,
+               34.45606998421704,
+               36.785175961393016,
+               38.19967378215836,
+               40.51423443841361}},
+
+             {{35.59241456886204,
+               37.04645041272,
+               39.60754485190144,
+               41.170524123687294,
+               43.06505159298528,
+               45.94888553725333,
+               47.965632033074556},
+              {35.80839734811646,
+               37.30461376917337,
+               39.097672114006386,
+               41.68423302651216,
+               43.4401524937396,
+               45.12203823484478,
+               47.49517691011127},
+              {35.03438852111522,
+               37.909320402078784,
+               39.258779981600014,
+               41.66252228435398,
+               43.31171107608941,
+               45.52006802117781,
+               47.54671027934328},
+              {35.184854455525524,
+               37.96958462776456,
+               39.77513282336111,
+               41.93949894156419,
+               43.89482735042765,
+               45.597899978811085,
+               47.92187423502312}},
+
+             {{42.08849250205192,
+               44.19598286241914,
+               46.04522728891054,
+               48.325330330763265,
+               50.38867728968948,
+               52.271349031773894,
+               54.82873750915193},
+              {42.35675332669359,
+               44.280934509687384,
+               46.54269608315825,
+               48.14092422497476,
+               50.80219698075404,
+               52.07455064367977,
+               54.98688693660052},
+              {42.772244769296655,
+               44.198715681534175,
+               46.005522117123604,
+               48.81546142845483,
+               50.70685734384762,
+               52.72900716804099,
+               54.771270346685945},
+              {42.07404465173409,
+               44.358465728544274,
+               46.11586905952513,
+               48.86310342587559,
+               50.62329812682756,
+               52.33089802485265,
+               54.06355835028602}},
+
+             {{21.310982321715663,
+               22.325183322026746,
+               23.729606178338063,
+               24.637557471355212,
+               25.887212742576327,
+               26.47221492516195,
+               27.119594245938302},
+              {21.713244787222994,
+               22.760785048616896,
+               23.561277197569495,
+               24.77096717995456,
+               25.49379559636439,
+               26.522732829381994,
+               27.42754101835855},
+              {21.025419126744094,
+               22.107891426993305,
+               23.031429185686733,
+               24.636410411263782,
+               25.314355981076325,
+               26.508570691164703,
+               27.907566473926092},
+              {21.249292229148875,
+               22.41038292303563,
+               23.755551138543048,
+               24.22879816549162,
+               25.076979909828793,
+               26.28975145291377,
+               27.161221287254005}},
+
+             {{28.929697652342572,
+               29.808120379564418,
+               30.633403756510422,
+               31.871460590187716,
+               32.80367207689911,
+               33.18657005888603,
+               34.892558998489974},
+              {28.53934224191565,
+               29.807440155164063,
+               30.896091299923494,
+               31.318003474971864,
+               32.110051924527674,
+               33.22793516254194,
+               34.42710778862626},
+              {28.81801476592249,
+               29.860730583256345,
+               30.00695213053119,
+               31.510747302577567,
+               32.41741100314878,
+               33.22210781047073,
+               34.11986536733368},
+              {28.337615171403627,
+               29.94290970391252,
+               30.323202932020756,
+               31.518790621743367,
+               32.70301895889518,
+               33.36362960237929,
+               34.971782082720964}}},
+
+
+            {{{28.962447294942113,
+               30.251782295825365,
+               32.49724850589239,
+               34.30087830981677,
+               36.28484049437747,
+               38.03688694735453,
+               40.6095643339799},
+              {28.50267902322886,
+               30.051478751249988,
+               32.27864646423661,
+               34.90826588596666,
+               36.23956189066697,
+               38.14489487209122,
+               40.489452760277565},
+              {28.9856504541106,
+               30.2420552715115,
+               32.67213554740588,
+               34.76161961532872,
+               36.2376375439924,
+               38.72821634861186,
+               40.367783132719254},
+              {28.63230583059358,
+               30.633529710760893,
+               32.53577468407476,
+               34.09028977005441,
+               36.83530249558924,
+               38.320780064971736,
+               40.18651851039986}},
+
+             {{35.04077514155476,
+               37.590892943188244,
+               39.67756436184228,
+               41.016587828927854,
+               43.51209305829928,
+               45.22649577519794,
+               47.64517279040945},
+              {35.17436642900499,
+               37.69093773810246,
+               39.38673534630054,
+               41.93672998873674,
+               43.13752094414599,
+               45.34106635105026,
+               47.113473521240586},
+              {35.92469361827856,
+               37.87733935338098,
+               39.257941627715155,
+               41.65998404603418,
+               43.817222200201215,
+               45.55520081159946,
+               47.529650578356005},
+              {35.241852290900454,
+               37.0931027678059,
+               39.897215757953326,
+               41.90041805716333,
+               43.63310145727327,
+               45.3390297910487,
+               47.34920957461266}},
+
+             {{42.72595567887024,
+               44.897110259952576,
+               46.88708642426512,
+               48.77987554585762,
+               50.64203164615429,
+               52.084139964995046,
+               54.16162871409461},
+              {42.89855418852708,
+               44.60642905965959,
+               46.00919705161663,
+               48.10147154286603,
+               50.66350176910806,
+               52.00506158384622,
+               54.1608080514175},
+              {42.54873378936659,
+               44.691895197692695,
+               46.6519612595026,
+               48.22426930946056,
+               50.71217922134753,
+               52.2372490874968,
+               54.325399698159266},
+              {42.74649140511802,
+               44.64963289904721,
+               46.849223410494176,
+               48.65761289230034,
+               50.568308603335474,
+               52.09367476782809,
+               54.36771580305943}},
+
+             {{21.265202367681724,
+               22.243989643379084,
+               23.973010554752445,
+               24.39309772466676,
+               25.892046555177114,
+               26.631138625997263,
+               27.79481130354165},
+              {21.502637093105193,
+               22.576903884626358,
+               23.492517693818865,
+               24.195242987798043,
+               25.722452115261504,
+               26.280772362440857,
+               27.024315966431455},
+              {21.64547229590717,
+               22.17711067940705,
+               23.940458584352914,
+               24.953928577002586,
+               25.914864390220448,
+               26.370158700255445,
+               27.015456616528866},
+              {21.928318562587727,
+               22.428184148317314,
+               23.96665481904367,
+               24.96361997708925,
+               25.85300945546736,
+               26.294448892069585,
+               27.385097728601924}},
+
+             {{28.85113667151686,
+               29.31692200515628,
+               30.169492746686092,
+               31.55680126245835,
+               32.936154774160784,
+               33.69602979667497,
+               34.57006117008937},
+              {28.097176493770768,
+               29.61500722669917,
+               30.990053850104264,
+               31.140084015236525,
+               32.51832965236374,
+               33.877373071927956,
+               34.740768617754206},
+              {28.69701574099527,
+               29.70248408398711,
+               30.359491151219757,
+               31.293591844264494,
+               32.80936115547851,
+               33.81011339467918,
+               34.86707231858011},
+              {28.91324055255647,
+               29.511342398860936,
+               30.5015162946872,
+               31.798295178966775,
+               32.649963930777766,
+               33.7019668772577,
+               34.7957926694361}}}
+        };
         EXPECT_TRUE(xt::allclose(a2_b3, py_a2_b3));
     }
 
@@ -466,210 +811,144 @@ namespace xt
     TEST(xtest_extended, broadcast_into_view)
     {
         // py_a0
-        xarray<long> py_a0 = {{{  0,  1,  2,  3,  4,  5,  6},
-                               {  7,  8,  9, 10, 11, 12, 13},
-                               { 14, 15, 16, 17, 18, 19, 20}},
-                             
-                              {{ 21, 22, 23, 24, 25, 26, 27},
-                               { 28, 29, 30, 31, 32, 33, 34},
-                               { 35, 36, 37, 38, 39, 40, 41}},
-                             
-                              {{ 42, 43, 44, 45, 46, 47, 48},
-                               { 49, 50, 51, 52, 53, 54, 55},
-                               { 56, 57, 58, 59, 60, 61, 62}},
-                             
-                              {{ 63, 64, 65, 66, 67, 68, 69},
-                               { 70, 71, 72, 73, 74, 75, 76},
-                               { 77, 78, 79, 80, 81, 82, 83}},
-                             
-                              {{ 84, 85, 86, 87, 88, 89, 90},
-                               { 91, 92, 93, 94, 95, 96, 97},
-                               { 98, 99,100,101,102,103,104}}};
+        xarray<long> py_a0 = {
+            {{0, 1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12, 13}, {14, 15, 16, 17, 18, 19, 20}},
+
+            {{21, 22, 23, 24, 25, 26, 27}, {28, 29, 30, 31, 32, 33, 34}, {35, 36, 37, 38, 39, 40, 41}},
+
+            {{42, 43, 44, 45, 46, 47, 48}, {49, 50, 51, 52, 53, 54, 55}, {56, 57, 58, 59, 60, 61, 62}},
+
+            {{63, 64, 65, 66, 67, 68, 69}, {70, 71, 72, 73, 74, 75, 76}, {77, 78, 79, 80, 81, 82, 83}},
+
+            {{84, 85, 86, 87, 88, 89, 90}, {91, 92, 93, 94, 95, 96, 97}, {98, 99, 100, 101, 102, 103, 104}}
+        };
         xt::xarray<long> a = py_a0;
 
         // py_b1
-        xarray<long> py_b1 = {{ 0, 1, 2},
-                              { 3, 4, 5},
-                              { 6, 7, 8},
-                              { 9,10,11},
-                              {12,13,14}};
+        xarray<long> py_b1 = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}, {12, 13, 14}};
         // py_a2
-        xarray<long> py_a2 = {{{  0,  1,  0,  3,  4,  5,  6},
-                               {  7,  8,  1, 10, 11, 12, 13},
-                               { 14, 15,  2, 17, 18, 19, 20}},
-                             
-                              {{ 21, 22,  3, 24, 25, 26, 27},
-                               { 28, 29,  4, 31, 32, 33, 34},
-                               { 35, 36,  5, 38, 39, 40, 41}},
-                             
-                              {{ 42, 43,  6, 45, 46, 47, 48},
-                               { 49, 50,  7, 52, 53, 54, 55},
-                               { 56, 57,  8, 59, 60, 61, 62}},
-                             
-                              {{ 63, 64,  9, 66, 67, 68, 69},
-                               { 70, 71, 10, 73, 74, 75, 76},
-                               { 77, 78, 11, 80, 81, 82, 83}},
-                             
-                              {{ 84, 85, 12, 87, 88, 89, 90},
-                               { 91, 92, 13, 94, 95, 96, 97},
-                               { 98, 99, 14,101,102,103,104}}};
+        xarray<long> py_a2 = {
+            {{0, 1, 0, 3, 4, 5, 6}, {7, 8, 1, 10, 11, 12, 13}, {14, 15, 2, 17, 18, 19, 20}},
+
+            {{21, 22, 3, 24, 25, 26, 27}, {28, 29, 4, 31, 32, 33, 34}, {35, 36, 5, 38, 39, 40, 41}},
+
+            {{42, 43, 6, 45, 46, 47, 48}, {49, 50, 7, 52, 53, 54, 55}, {56, 57, 8, 59, 60, 61, 62}},
+
+            {{63, 64, 9, 66, 67, 68, 69}, {70, 71, 10, 73, 74, 75, 76}, {77, 78, 11, 80, 81, 82, 83}},
+
+            {{84, 85, 12, 87, 88, 89, 90}, {91, 92, 13, 94, 95, 96, 97}, {98, 99, 14, 101, 102, 103, 104}}
+        };
         view(a, all(), all(), 2) = py_b1;
         EXPECT_EQ(a, py_a2);
 
         // py_ar2
-        xarray<long> py_ar2 = {{{ 0, 1, 2, 3, 4, 5, 6}},
-                              
-                               {{ 7, 8, 9,10,11,12,13}},
-                              
-                               {{14,15,16,17,18,19,20}},
-                              
-                               {{21,22,23,24,25,26,27}},
-                              
-                               {{28,29,30,31,32,33,34}}};
+        xarray<long> py_ar2 = {
+            {{0, 1, 2, 3, 4, 5, 6}},
+
+            {{7, 8, 9, 10, 11, 12, 13}},
+
+            {{14, 15, 16, 17, 18, 19, 20}},
+
+            {{21, 22, 23, 24, 25, 26, 27}},
+
+            {{28, 29, 30, 31, 32, 33, 34}}
+        };
         xt::xarray<long> ar2 = py_ar2;
         view(a, all(), 0, newaxis(), all()) = ar2;
 
         // py_a3
-        xarray<long> py_a3 = {{{  0,  1,  2,  3,  4,  5,  6},
-                               {  7,  8,  1, 10, 11, 12, 13},
-                               { 14, 15,  2, 17, 18, 19, 20}},
-                             
-                              {{  7,  8,  9, 10, 11, 12, 13},
-                               { 28, 29,  4, 31, 32, 33, 34},
-                               { 35, 36,  5, 38, 39, 40, 41}},
-                             
-                              {{ 14, 15, 16, 17, 18, 19, 20},
-                               { 49, 50,  7, 52, 53, 54, 55},
-                               { 56, 57,  8, 59, 60, 61, 62}},
-                             
-                              {{ 21, 22, 23, 24, 25, 26, 27},
-                               { 70, 71, 10, 73, 74, 75, 76},
-                               { 77, 78, 11, 80, 81, 82, 83}},
-                             
-                              {{ 28, 29, 30, 31, 32, 33, 34},
-                               { 91, 92, 13, 94, 95, 96, 97},
-                               { 98, 99, 14,101,102,103,104}}};
+        xarray<long> py_a3 = {
+            {{0, 1, 2, 3, 4, 5, 6}, {7, 8, 1, 10, 11, 12, 13}, {14, 15, 2, 17, 18, 19, 20}},
+
+            {{7, 8, 9, 10, 11, 12, 13}, {28, 29, 4, 31, 32, 33, 34}, {35, 36, 5, 38, 39, 40, 41}},
+
+            {{14, 15, 16, 17, 18, 19, 20}, {49, 50, 7, 52, 53, 54, 55}, {56, 57, 8, 59, 60, 61, 62}},
+
+            {{21, 22, 23, 24, 25, 26, 27}, {70, 71, 10, 73, 74, 75, 76}, {77, 78, 11, 80, 81, 82, 83}},
+
+            {{28, 29, 30, 31, 32, 33, 34}, {91, 92, 13, 94, 95, 96, 97}, {98, 99, 14, 101, 102, 103, 104}}
+        };
         EXPECT_EQ(a, py_a3);
 
         view(a, all(), 2, all()) = xt::arange(7);
         // py_a4
-        xarray<long> py_a4 = {{{ 0, 1, 2, 3, 4, 5, 6},
-                               { 7, 8, 1,10,11,12,13},
-                               { 0, 1, 2, 3, 4, 5, 6}},
-                             
-                              {{ 7, 8, 9,10,11,12,13},
-                               {28,29, 4,31,32,33,34},
-                               { 0, 1, 2, 3, 4, 5, 6}},
-                             
-                              {{14,15,16,17,18,19,20},
-                               {49,50, 7,52,53,54,55},
-                               { 0, 1, 2, 3, 4, 5, 6}},
-                             
-                              {{21,22,23,24,25,26,27},
-                               {70,71,10,73,74,75,76},
-                               { 0, 1, 2, 3, 4, 5, 6}},
-                             
-                              {{28,29,30,31,32,33,34},
-                               {91,92,13,94,95,96,97},
-                               { 0, 1, 2, 3, 4, 5, 6}}};
+        xarray<long> py_a4 = {
+            {{0, 1, 2, 3, 4, 5, 6}, {7, 8, 1, 10, 11, 12, 13}, {0, 1, 2, 3, 4, 5, 6}},
+
+            {{7, 8, 9, 10, 11, 12, 13}, {28, 29, 4, 31, 32, 33, 34}, {0, 1, 2, 3, 4, 5, 6}},
+
+            {{14, 15, 16, 17, 18, 19, 20}, {49, 50, 7, 52, 53, 54, 55}, {0, 1, 2, 3, 4, 5, 6}},
+
+            {{21, 22, 23, 24, 25, 26, 27}, {70, 71, 10, 73, 74, 75, 76}, {0, 1, 2, 3, 4, 5, 6}},
+
+            {{28, 29, 30, 31, 32, 33, 34}, {91, 92, 13, 94, 95, 96, 97}, {0, 1, 2, 3, 4, 5, 6}}
+        };
         EXPECT_EQ(a, py_a4);
 
         a = py_a0;
         view(a, 1, all(), all()) = -1;
 
         // py_ax1
-        xarray<long> py_ax1 = {{{  0,  1,  2,  3,  4,  5,  6},
-                                {  7,  8,  9, 10, 11, 12, 13},
-                                { 14, 15, 16, 17, 18, 19, 20}},
-                              
-                               {{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1}},
-                              
-                               {{ 42, 43, 44, 45, 46, 47, 48},
-                                { 49, 50, 51, 52, 53, 54, 55},
-                                { 56, 57, 58, 59, 60, 61, 62}},
-                              
-                               {{ 63, 64, 65, 66, 67, 68, 69},
-                                { 70, 71, 72, 73, 74, 75, 76},
-                                { 77, 78, 79, 80, 81, 82, 83}},
-                              
-                               {{ 84, 85, 86, 87, 88, 89, 90},
-                                { 91, 92, 93, 94, 95, 96, 97},
-                                { 98, 99,100,101,102,103,104}}};
+        xarray<long> py_ax1 = {
+            {{0, 1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12, 13}, {14, 15, 16, 17, 18, 19, 20}},
+
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}},
+
+            {{42, 43, 44, 45, 46, 47, 48}, {49, 50, 51, 52, 53, 54, 55}, {56, 57, 58, 59, 60, 61, 62}},
+
+            {{63, 64, 65, 66, 67, 68, 69}, {70, 71, 72, 73, 74, 75, 76}, {77, 78, 79, 80, 81, 82, 83}},
+
+            {{84, 85, 86, 87, 88, 89, 90}, {91, 92, 93, 94, 95, 96, 97}, {98, 99, 100, 101, 102, 103, 104}}
+        };
         EXPECT_EQ(a, py_ax1);
 
         a = py_a0;
         view(a, range(0, 2), range(0, 2), all()) = -1;
 
         // py_ax2
-        xarray<long> py_ax2 = {{{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { 14, 15, 16, 17, 18, 19, 20}},
-                              
-                               {{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { 35, 36, 37, 38, 39, 40, 41}},
-                              
-                               {{ 42, 43, 44, 45, 46, 47, 48},
-                                { 49, 50, 51, 52, 53, 54, 55},
-                                { 56, 57, 58, 59, 60, 61, 62}},
-                              
-                               {{ 63, 64, 65, 66, 67, 68, 69},
-                                { 70, 71, 72, 73, 74, 75, 76},
-                                { 77, 78, 79, 80, 81, 82, 83}},
-                              
-                               {{ 84, 85, 86, 87, 88, 89, 90},
-                                { 91, 92, 93, 94, 95, 96, 97},
-                                { 98, 99,100,101,102,103,104}}};
+        xarray<long> py_ax2 = {
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {14, 15, 16, 17, 18, 19, 20}},
+
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {35, 36, 37, 38, 39, 40, 41}},
+
+            {{42, 43, 44, 45, 46, 47, 48}, {49, 50, 51, 52, 53, 54, 55}, {56, 57, 58, 59, 60, 61, 62}},
+
+            {{63, 64, 65, 66, 67, 68, 69}, {70, 71, 72, 73, 74, 75, 76}, {77, 78, 79, 80, 81, 82, 83}},
+
+            {{84, 85, 86, 87, 88, 89, 90}, {91, 92, 93, 94, 95, 96, 97}, {98, 99, 100, 101, 102, 103, 104}}
+        };
         EXPECT_EQ(a, py_ax2);
 
         a = py_a0;
         view(a, all(), range(0, 2), all()) = -1;
         // py_ax4
-        xarray<long> py_ax4 = {{{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { 14, 15, 16, 17, 18, 19, 20}},
-                              
-                               {{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { 35, 36, 37, 38, 39, 40, 41}},
-                              
-                               {{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { 56, 57, 58, 59, 60, 61, 62}},
-                              
-                               {{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { 77, 78, 79, 80, 81, 82, 83}},
-                              
-                               {{ -1, -1, -1, -1, -1, -1, -1},
-                                { -1, -1, -1, -1, -1, -1, -1},
-                                { 98, 99,100,101,102,103,104}}};
+        xarray<long> py_ax4 = {
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {14, 15, 16, 17, 18, 19, 20}},
+
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {35, 36, 37, 38, 39, 40, 41}},
+
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {56, 57, 58, 59, 60, 61, 62}},
+
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {77, 78, 79, 80, 81, 82, 83}},
+
+            {{-1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1}, {98, 99, 100, 101, 102, 103, 104}}
+        };
         EXPECT_EQ(a, py_ax4);
 
         a = py_a0;
         view(a, 1, range(0, 2, 2), all()) = -1;
         // py_ax3
-        xarray<long> py_ax3 = {{{  0,  1,  2,  3,  4,  5,  6},
-                                {  7,  8,  9, 10, 11, 12, 13},
-                                { 14, 15, 16, 17, 18, 19, 20}},
-                              
-                               {{ -1, -1, -1, -1, -1, -1, -1},
-                                { 28, 29, 30, 31, 32, 33, 34},
-                                { 35, 36, 37, 38, 39, 40, 41}},
-                              
-                               {{ 42, 43, 44, 45, 46, 47, 48},
-                                { 49, 50, 51, 52, 53, 54, 55},
-                                { 56, 57, 58, 59, 60, 61, 62}},
-                              
-                               {{ 63, 64, 65, 66, 67, 68, 69},
-                                { 70, 71, 72, 73, 74, 75, 76},
-                                { 77, 78, 79, 80, 81, 82, 83}},
-                              
-                               {{ 84, 85, 86, 87, 88, 89, 90},
-                                { 91, 92, 93, 94, 95, 96, 97},
-                                { 98, 99,100,101,102,103,104}}};
+        xarray<long> py_ax3 = {
+            {{0, 1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12, 13}, {14, 15, 16, 17, 18, 19, 20}},
+
+            {{-1, -1, -1, -1, -1, -1, -1}, {28, 29, 30, 31, 32, 33, 34}, {35, 36, 37, 38, 39, 40, 41}},
+
+            {{42, 43, 44, 45, 46, 47, 48}, {49, 50, 51, 52, 53, 54, 55}, {56, 57, 58, 59, 60, 61, 62}},
+
+            {{63, 64, 65, 66, 67, 68, 69}, {70, 71, 72, 73, 74, 75, 76}, {77, 78, 79, 80, 81, 82, 83}},
+
+            {{84, 85, 86, 87, 88, 89, 90}, {91, 92, 93, 94, 95, 96, 97}, {98, 99, 100, 101, 102, 103, 104}}
+        };
         EXPECT_EQ(a, py_ax3);
     }
 
@@ -692,77 +971,63 @@ namespace xt
     TEST(xtest_extended, broadcast_funcs_view)
     {
         // py_a0
-        xarray<long> py_a0 = {{{ 0, 1, 2, 3},
-                               { 4, 5, 6, 7},
-                               { 8, 9,10,11}},
-                             
-                              {{12,13,14,15},
-                               {16,17,18,19},
-                               {20,21,22,23}}};
+        xarray<long> py_a0 = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
         // py_a1
-        xarray<long> py_a1 = {{ 0, 1, 2, 3},
-                              { 4, 5, 6, 7},
-                              { 8, 9,10,11}};
+        xarray<long> py_a1 = {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}};
         // py_a2
-        xarray<long> py_a2 = {{{0,1,2,3}},
-                             
-                              {{4,5,6,7}}};
+        xarray<long> py_a2 = {
+            {{0, 1, 2, 3}},
+
+            {{4, 5, 6, 7}}
+        };
         // py_a3
-        xarray<long> py_a3 = {{{0,1,2,3}}};
+        xarray<long> py_a3 = {{{0, 1, 2, 3}}};
         xt::xarray<long> py_a4 = {0, 1, 2};
         py_a4.reshape({3, 1});
 
         xt::xarray<long> a = py_a0;
         xt::view(a, range(0, 2), all(), all()) = py_a0 * 2 + py_a4;
         // py_a0_cp1
-        xarray<long> py_a0_cp1 = {{{ 0, 2, 4, 6},
-                                   { 9,11,13,15},
-                                   {18,20,22,24}},
-                                 
-                                  {{24,26,28,30},
-                                   {33,35,37,39},
-                                   {42,44,46,48}}};
+        xarray<long> py_a0_cp1 = {
+            {{0, 2, 4, 6}, {9, 11, 13, 15}, {18, 20, 22, 24}},
+
+            {{24, 26, 28, 30}, {33, 35, 37, 39}, {42, 44, 46, 48}}
+        };
         EXPECT_EQ(py_a0_cp1, a);
 
         // py_a0_cp2
-        xarray<long> py_a0_cp2 = {{{   0,  14,  56, 126},
-                                   { 261, 396, 559, 750},
-                                   {1044,1300,1584,1896}},
-                                 
-                                  {{  24,  26,  28,  30},
-                                   {  33,  35,  37,  39},
-                                   {  42,  44,  46,  48}}};
+        xarray<long> py_a0_cp2 = {
+            {{0, 14, 56, 126}, {261, 396, 559, 750}, {1044, 1300, 1584, 1896}},
+
+            {{24, 26, 28, 30}, {33, 35, 37, 39}, {42, 44, 46, 48}}
+        };
         xt::view(a, 0, all(), all()) *= py_a1 * 7 + py_a4;
         EXPECT_EQ(py_a0_cp2, a);
 
         // py_x0
-        xarray<long> py_x0 = {{{ 0, 1},
-                               { 2, 3},
-                               { 4, 5}},
-                             
-                              {{ 6, 7},
-                               { 8, 9},
-                               {10,11}},
-                             
-                              {{12,13},
-                               {14,15},
-                               {16,17}}};
+        xarray<long> py_x0 = {
+            {{0, 1}, {2, 3}, {4, 5}},
+
+            {{6, 7}, {8, 9}, {10, 11}},
+
+            {{12, 13}, {14, 15}, {16, 17}}
+        };
         // py_a0_cp3
-        xarray<long> py_a0_cp3 = {{{   6,  14,   7, 126},
-                                   {   8, 396,   9, 750},
-                                   {  10,1300,  11,1896}},
-                                 
-                                  {{  24,  26,  28,  30},
-                                   {  33,  35,  37,  39},
-                                   {  42,  44,  46,  48}}};
+        xarray<long> py_a0_cp3 = {
+            {{6, 14, 7, 126}, {8, 396, 9, 750}, {10, 1300, 11, 1896}},
+
+            {{24, 26, 28, 30}, {33, 35, 37, 39}, {42, 44, 46, 48}}
+        };
         xt::view(a, 0, all(), range(_, _, 2)) = xt::view(py_x0, 1, all(), all());
         EXPECT_EQ(a, py_a0_cp3);
 
         xt::view(a, 0, all(), all()) = xt::view((py_a0 * py_a0 + 3), 0, all(), all());
         // py_x1 = (a0 * a0 + 3)[0, :, :]
-        xarray<long> py_x1 = {{  3,  4,  7, 12},
-                              { 19, 28, 39, 52},
-                              { 67, 84,103,124}};
+        xarray<long> py_x1 = {{3, 4, 7, 12}, {19, 28, 39, 52}, {67, 84, 103, 124}};
         EXPECT_EQ(py_x1, view(a, 0, all(), all()));
     }
 }
diff --git a/test/test_extended_xhistogram.cpp b/test/test_extended_xhistogram.cpp
index e51eff6bd..f68fc6916 100644
--- a/test/test_extended_xhistogram.cpp
+++ b/test/test_extended_xhistogram.cpp
@@ -1,19 +1,22 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
-
+ * 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. *
+ ****************************************************************************/
 // This file is generated from test/files/cppy_source/test_extended_xhistogram.cppy by preprocess.py!
+// Warning: This file should not be modified directly! Instead, modify the `*.cppy` file.
+
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xhistogram.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/misc/xhistogram.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -31,62 +34,65 @@ namespace xt
     TEST(xtest_extended_histogram, histogram_auto)
     {
         // py_a
-        xarray<long> py_a = {19,48,37,30, 7, 7, 2,44,30,36, 1,49,42,10, 9, 9,15,26,22,14,31, 7,14,18,
-                             23,40,10,26,30, 2,30, 8, 3,48,49,41,15, 4,34,22, 6,25, 1,46,13,33,15,26,
-                             27, 9,49,39,47,45,30,47, 4, 9, 2,16,19,13,42,18,14,27, 7,40, 3,50,39,10,
-                              0,41,36,37,39, 3,18, 5,44,31,16, 3,15,16,37,32,45,24, 6,36,38,28,39,25,
-                             26,21, 1, 5, 1,32,16,25,46,12,20,38,11, 3,14, 8,47,41,32,44,40, 9,45,27,
-                             41,45,16, 5,11,21,41,43, 0,26,21,11, 6,17,48,16,26,35,18,49,49,12,25,15,
-                             14, 1,31,25, 2,14,46,12, 7,24,50,12,34,38,12,37,18,32,32,27, 4,42,16, 9,
-                              2,30,34, 0,26,11,32, 8,35,19,47, 7,17, 5,47,44,13,33,41,28,27,12, 4,45,
-                             45,32,17,17,37,45,45,39,32, 4, 8,45,30, 0, 5,33, 0, 8,27,35,33,11,36,12,
-                             16,38,33,43,33,28, 4,18,13,12,49,20,45,32,40,25,29,25, 9,36,14, 1,32, 9,
-                             47,48,46,18, 0,47,21,49,49,43,15,19,43,16, 8,28,47,35,29, 4,31,50, 7,26,
-                             44,37,35,35,18,14,41,41,44,46,26,25,40,33,35,40,45,17,19, 4,29, 1,23,27,
-                             14,30, 1, 1,41,18, 6,26,39,11,31, 4, 2,27,27,32,37,49,26,16,40,13,22, 4,
-                              1,49,42,35,20, 8, 7,12,28,36,33,14,48,37,28,31,21,12,18,38, 0, 5, 2, 2,
-                             43,35,24, 4,25,24, 8,22,20,31,32, 2,19,31,25,43,33, 8, 3,32, 1,29,47,29,
-                             19,32,23,27,48,19,49,46, 9, 3, 5, 0, 4,34, 3,16,43, 1,41,14, 6,35,32,44,
-                             37,40,14, 9,38,41,50,21,18,39,17,47,43,21,38,38, 5,46,25,42,16,45,19, 0,
-                             46, 4,16,48,48,29,32,22,14,16,34,38,40,40, 4,25, 2,28,22,45,17, 5, 7,38,
-                             31, 5, 4,35, 3,41,36, 4, 4,50,19,18,41,48,50,38,19, 4,39,28,21,46, 5,25,
-                              0,23, 2, 6, 5,33,38,29,49,19,14,44,11,49, 0,49, 2,45,26,50, 3,28,49,26,
-                             32,35,23,32,29,45, 2,14,48,45,23,31,14, 9,23,18,29, 3,49,50,35,27,15,41,
-                             34, 8,46,41,48,37,31,21,47,44, 2, 1,19,41,50, 7,30,19,49,42,42,23,21,13,
-                              2,44,41,50,50,28,39,48,43,12,22, 6,48,30,11,34,31,18, 5,34,26,39,26,43,
-                             28,28,44,20, 6, 1,38,31,35,10, 6, 0,17,30,20,22,46,17,26,39,20,31,43,48,
-                              7,47,25,13,23,49,25,16,32,12, 3, 6, 6, 7, 7,32, 9,17,45,24,34, 8, 9, 2,
-                              8,14, 9, 4, 6,23,10,18,25,35, 2,40,32, 4,44,46, 3,14,41,38, 9,10,18,24,
-                             31,18,23,38, 1,12,36,45,26,27, 5,22,27,12,13,19, 1,16,10,16, 6,45,30,34,
-                             40,25, 4,27,29,38,22, 6,14,18,32,29,18,50,30,12, 5, 7,12, 8, 9,14, 8,45,
-                              4,26,20,50, 5,20,49,44,41,13, 8,34,47,28,29,14,39, 9,16,21,25,12, 5,31,
-                             14,29, 7,24,27, 2,17, 6, 3,50,16,41,12,34,38,30,24,21,17,47,42,49, 6,37,
-                             47, 9, 3,37,29,42, 7,40,10, 8, 8,41,33,26,18,44,20,41,22,19,23,15,38,25,
-                             11,45,19,27,46,31, 5,47,32,17, 7,40,31,27,45,40, 7,15,12,37, 1,29,38,44,
-                             17,41, 5,43, 6,20,40, 7,11,36,36,32,35,27,12,17, 9,46,29,20,23,48, 7,29,
-                             25,31, 0,44,47,28,35,47,36, 7,29,30,21,37,47,47,22, 5,50,42, 6,46,44,26,
-                             30,20, 2,17,40, 0,17,20,27,46,17,17,37,23,11,23, 7, 8,25,21,46,18,29,32,
-                              0,33, 9,49, 7,21, 4,50,25,30, 3,38,10,45,10, 9, 1,24,28, 3,39,23,26,22,
-                             20,28, 7, 9,43,48,19,13,32,20, 1, 7,36,33, 1,11,11,34, 1, 5,40, 9,33,12,
-                              5,12,36,43,42,20,34,10,14,45, 0, 4,10, 1, 9,29,21,45,41,17,13,19,30,13,
-                             31,20,28,22,15,48,38, 7,44,24,45,40,21, 1,13,27,32,13, 7,42,50,26, 8,13,
-                              0,46, 6,29,13,28,33,42,10, 0, 6,45,44,30,30,33, 8,46,21,19,26, 2, 8,37,
-                              4,30,12,19,14,18,36,15,28,24,33,47,37,10, 1,13,30, 2,25,30,17,39, 5, 3,
-                             37,25,35,22,12,41,40,35,13,30,18, 4,46, 6,48,22};
+        xarray<long> py_a = {
+            19, 48, 37, 30, 7,  7,  2,  44, 30, 36, 1,  49, 42, 10, 9,  9,  15, 26, 22, 14, 31, 7,  14, 18,
+            23, 40, 10, 26, 30, 2,  30, 8,  3,  48, 49, 41, 15, 4,  34, 22, 6,  25, 1,  46, 13, 33, 15, 26,
+            27, 9,  49, 39, 47, 45, 30, 47, 4,  9,  2,  16, 19, 13, 42, 18, 14, 27, 7,  40, 3,  50, 39, 10,
+            0,  41, 36, 37, 39, 3,  18, 5,  44, 31, 16, 3,  15, 16, 37, 32, 45, 24, 6,  36, 38, 28, 39, 25,
+            26, 21, 1,  5,  1,  32, 16, 25, 46, 12, 20, 38, 11, 3,  14, 8,  47, 41, 32, 44, 40, 9,  45, 27,
+            41, 45, 16, 5,  11, 21, 41, 43, 0,  26, 21, 11, 6,  17, 48, 16, 26, 35, 18, 49, 49, 12, 25, 15,
+            14, 1,  31, 25, 2,  14, 46, 12, 7,  24, 50, 12, 34, 38, 12, 37, 18, 32, 32, 27, 4,  42, 16, 9,
+            2,  30, 34, 0,  26, 11, 32, 8,  35, 19, 47, 7,  17, 5,  47, 44, 13, 33, 41, 28, 27, 12, 4,  45,
+            45, 32, 17, 17, 37, 45, 45, 39, 32, 4,  8,  45, 30, 0,  5,  33, 0,  8,  27, 35, 33, 11, 36, 12,
+            16, 38, 33, 43, 33, 28, 4,  18, 13, 12, 49, 20, 45, 32, 40, 25, 29, 25, 9,  36, 14, 1,  32, 9,
+            47, 48, 46, 18, 0,  47, 21, 49, 49, 43, 15, 19, 43, 16, 8,  28, 47, 35, 29, 4,  31, 50, 7,  26,
+            44, 37, 35, 35, 18, 14, 41, 41, 44, 46, 26, 25, 40, 33, 35, 40, 45, 17, 19, 4,  29, 1,  23, 27,
+            14, 30, 1,  1,  41, 18, 6,  26, 39, 11, 31, 4,  2,  27, 27, 32, 37, 49, 26, 16, 40, 13, 22, 4,
+            1,  49, 42, 35, 20, 8,  7,  12, 28, 36, 33, 14, 48, 37, 28, 31, 21, 12, 18, 38, 0,  5,  2,  2,
+            43, 35, 24, 4,  25, 24, 8,  22, 20, 31, 32, 2,  19, 31, 25, 43, 33, 8,  3,  32, 1,  29, 47, 29,
+            19, 32, 23, 27, 48, 19, 49, 46, 9,  3,  5,  0,  4,  34, 3,  16, 43, 1,  41, 14, 6,  35, 32, 44,
+            37, 40, 14, 9,  38, 41, 50, 21, 18, 39, 17, 47, 43, 21, 38, 38, 5,  46, 25, 42, 16, 45, 19, 0,
+            46, 4,  16, 48, 48, 29, 32, 22, 14, 16, 34, 38, 40, 40, 4,  25, 2,  28, 22, 45, 17, 5,  7,  38,
+            31, 5,  4,  35, 3,  41, 36, 4,  4,  50, 19, 18, 41, 48, 50, 38, 19, 4,  39, 28, 21, 46, 5,  25,
+            0,  23, 2,  6,  5,  33, 38, 29, 49, 19, 14, 44, 11, 49, 0,  49, 2,  45, 26, 50, 3,  28, 49, 26,
+            32, 35, 23, 32, 29, 45, 2,  14, 48, 45, 23, 31, 14, 9,  23, 18, 29, 3,  49, 50, 35, 27, 15, 41,
+            34, 8,  46, 41, 48, 37, 31, 21, 47, 44, 2,  1,  19, 41, 50, 7,  30, 19, 49, 42, 42, 23, 21, 13,
+            2,  44, 41, 50, 50, 28, 39, 48, 43, 12, 22, 6,  48, 30, 11, 34, 31, 18, 5,  34, 26, 39, 26, 43,
+            28, 28, 44, 20, 6,  1,  38, 31, 35, 10, 6,  0,  17, 30, 20, 22, 46, 17, 26, 39, 20, 31, 43, 48,
+            7,  47, 25, 13, 23, 49, 25, 16, 32, 12, 3,  6,  6,  7,  7,  32, 9,  17, 45, 24, 34, 8,  9,  2,
+            8,  14, 9,  4,  6,  23, 10, 18, 25, 35, 2,  40, 32, 4,  44, 46, 3,  14, 41, 38, 9,  10, 18, 24,
+            31, 18, 23, 38, 1,  12, 36, 45, 26, 27, 5,  22, 27, 12, 13, 19, 1,  16, 10, 16, 6,  45, 30, 34,
+            40, 25, 4,  27, 29, 38, 22, 6,  14, 18, 32, 29, 18, 50, 30, 12, 5,  7,  12, 8,  9,  14, 8,  45,
+            4,  26, 20, 50, 5,  20, 49, 44, 41, 13, 8,  34, 47, 28, 29, 14, 39, 9,  16, 21, 25, 12, 5,  31,
+            14, 29, 7,  24, 27, 2,  17, 6,  3,  50, 16, 41, 12, 34, 38, 30, 24, 21, 17, 47, 42, 49, 6,  37,
+            47, 9,  3,  37, 29, 42, 7,  40, 10, 8,  8,  41, 33, 26, 18, 44, 20, 41, 22, 19, 23, 15, 38, 25,
+            11, 45, 19, 27, 46, 31, 5,  47, 32, 17, 7,  40, 31, 27, 45, 40, 7,  15, 12, 37, 1,  29, 38, 44,
+            17, 41, 5,  43, 6,  20, 40, 7,  11, 36, 36, 32, 35, 27, 12, 17, 9,  46, 29, 20, 23, 48, 7,  29,
+            25, 31, 0,  44, 47, 28, 35, 47, 36, 7,  29, 30, 21, 37, 47, 47, 22, 5,  50, 42, 6,  46, 44, 26,
+            30, 20, 2,  17, 40, 0,  17, 20, 27, 46, 17, 17, 37, 23, 11, 23, 7,  8,  25, 21, 46, 18, 29, 32,
+            0,  33, 9,  49, 7,  21, 4,  50, 25, 30, 3,  38, 10, 45, 10, 9,  1,  24, 28, 3,  39, 23, 26, 22,
+            20, 28, 7,  9,  43, 48, 19, 13, 32, 20, 1,  7,  36, 33, 1,  11, 11, 34, 1,  5,  40, 9,  33, 12,
+            5,  12, 36, 43, 42, 20, 34, 10, 14, 45, 0,  4,  10, 1,  9,  29, 21, 45, 41, 17, 13, 19, 30, 13,
+            31, 20, 28, 22, 15, 48, 38, 7,  44, 24, 45, 40, 21, 1,  13, 27, 32, 13, 7,  42, 50, 26, 8,  13,
+            0,  46, 6,  29, 13, 28, 33, 42, 10, 0,  6,  45, 44, 30, 30, 33, 8,  46, 21, 19, 26, 2,  8,  37,
+            4,  30, 12, 19, 14, 18, 36, 15, 28, 24, 33, 47, 37, 10, 1,  13, 30, 2,  25, 30, 17, 39, 5,  3,
+            37, 25, 35, 22, 12, 41, 40, 35, 13, 30, 18, 4,  46, 6,  48, 22
+        };
         // py_bin_edges
-        xarray<double> py_bin_edges = { 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.,10.,11.,12.,13.,14.,15.,16.,17.,
-                                       18.,19.,20.,21.,22.,23.,24.,25.,26.,27.,28.,29.,30.,31.,32.,33.,34.,35.,
-                                       36.,37.,38.,39.,40.,41.,42.,43.,44.,45.,46.,47.,48.,49.,50.};
+        xarray<double> py_bin_edges = {0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,  10., 11., 12.,
+                                       13., 14., 15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 25.,
+                                       26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38.,
+                                       39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50.};
         // py_count
-        xarray<long> py_count = {18,24,21,18,26,23,21,27,21,24,14,13,24,18,24,11,19,21,23,21,18,18,16,16,
-                                 11,24,23,20,19,21,24,20,27,17,14,19,14,18,21,14,20,25,13,14,19,27,20,21,
-                                 18,38};
+        xarray<long> py_count = {18, 24, 21, 18, 26, 23, 21, 27, 21, 24, 14, 13, 24, 18, 24, 11, 19,
+                                 21, 23, 21, 18, 18, 16, 16, 11, 24, 23, 20, 19, 21, 24, 20, 27, 17,
+                                 14, 19, 14, 18, 21, 14, 20, 25, 13, 14, 19, 27, 20, 21, 18, 38};
         // py_prob
-        xarray<double> py_prob = {0.018,0.024,0.021,0.018,0.026,0.023,0.021,0.027,0.021,0.024,0.014,0.013,
-                                  0.024,0.018,0.024,0.011,0.019,0.021,0.023,0.021,0.018,0.018,0.016,0.016,
-                                  0.011,0.024,0.023,0.02 ,0.019,0.021,0.024,0.02 ,0.027,0.017,0.014,0.019,
-                                  0.014,0.018,0.021,0.014,0.02 ,0.025,0.013,0.014,0.019,0.027,0.02 ,0.021,
-                                  0.018,0.038};
+        xarray<double> py_prob = {0.018, 0.024, 0.021, 0.018, 0.026, 0.023, 0.021, 0.027, 0.021, 0.024,
+                                  0.014, 0.013, 0.024, 0.018, 0.024, 0.011, 0.019, 0.021, 0.023, 0.021,
+                                  0.018, 0.018, 0.016, 0.016, 0.011, 0.024, 0.023, 0.02,  0.019, 0.021,
+                                  0.024, 0.02,  0.027, 0.017, 0.014, 0.019, 0.014, 0.018, 0.021, 0.014,
+                                  0.02,  0.025, 0.013, 0.014, 0.019, 0.027, 0.02,  0.021, 0.018, 0.038};
 
         auto bin_edges = xt::histogram_bin_edges(py_a, std::size_t(50));
 
@@ -100,5 +106,75 @@ namespace xt
 
         EXPECT_EQ(prob, py_prob);
     }
-}
 
+    /*py
+
+    a = (np.random.random(1000) * 51).astype(np.int)
+
+    count, bin_edges  = np.histogram(a, 30, (10, 40))
+
+    */
+    TEST(xtest_extended_histogram, histogram_with_range)
+    {
+        // py_a
+        xarray<long> py_a = {
+            9,  27, 44, 37, 41, 33, 35, 43, 12, 24, 11, 50, 48, 2,  35, 47, 9,  28, 46, 1,  35, 15, 47, 49,
+            48, 24, 43, 43, 16, 42, 1,  30, 11, 6,  3,  35, 17, 36, 3,  16, 27, 40, 16, 31, 45, 31, 11, 1,
+            44, 1,  44, 26, 47, 40, 50, 17, 39, 20, 24, 32, 44, 50, 39, 21, 21, 37, 12, 5,  18, 14, 15, 11,
+            2,  0,  50, 21, 19, 34, 11, 48, 40, 4,  21, 44, 48, 23, 31, 8,  50, 11, 48, 33, 30, 26, 11, 9,
+            11, 9,  39, 17, 2,  49, 45, 47, 50, 8,  20, 38, 35, 7,  41, 11, 11, 27, 30, 29, 4,  44, 13, 6,
+            45, 48, 43, 41, 33, 28, 4,  20, 19, 13, 36, 25, 4,  11, 34, 3,  43, 25, 24, 30, 42, 17, 34, 28,
+            13, 44, 40, 33, 43, 44, 36, 42, 35, 34, 31, 38, 8,  44, 44, 1,  42, 6,  17, 37, 8,  41, 42, 25,
+            0,  14, 31, 50, 32, 13, 32, 27, 39, 5,  38, 27, 49, 17, 32, 47, 5,  47, 35, 3,  15, 36, 3,  29,
+            17, 31, 2,  44, 49, 49, 38, 6,  38, 1,  1,  16, 24, 39, 34, 22, 13, 50, 21, 23, 8,  40, 35, 11,
+            4,  34, 33, 13, 48, 7,  22, 48, 21, 32, 20, 13, 50, 20, 45, 11, 10, 1,  33, 18, 44, 24, 49, 9,
+            44, 39, 39, 43, 38, 31, 6,  1,  46, 31, 40, 24, 5,  6,  34, 21, 10, 25, 3,  29, 13, 40, 15, 23,
+            0,  3,  20, 24, 30, 14, 35, 43, 39, 2,  24, 5,  12, 50, 7,  25, 31, 35, 28, 0,  16, 26, 4,  17,
+            1,  4,  20, 6,  28, 35, 40, 10, 8,  5,  32, 36, 1,  47, 2,  27, 36, 44, 36, 40, 17, 41, 4,  45,
+            27, 41, 23, 32, 26, 37, 4,  3,  12, 8,  44, 11, 49, 17, 9,  40, 33, 25, 28, 36, 11, 50, 49, 33,
+            10, 34, 3,  1,  13, 23, 44, 37, 37, 21, 17, 18, 50, 2,  44, 29, 22, 36, 24, 44, 45, 21, 14, 30,
+            46, 10, 31, 32, 37, 6,  36, 46, 9,  12, 49, 9,  43, 25, 12, 44, 22, 26, 18, 30, 8,  19, 49, 13,
+            33, 16, 39, 6,  49, 23, 12, 3,  8,  26, 17, 42, 21, 12, 31, 36, 8,  8,  1,  37, 33, 24, 43, 41,
+            29, 44, 10, 5,  13, 2,  27, 47, 2,  6,  23, 47, 16, 25, 2,  7,  50, 49, 0,  48, 32, 44, 23, 26,
+            24, 34, 7,  1,  15, 35, 10, 34, 49, 4,  34, 22, 44, 9,  35, 42, 48, 34, 25, 31, 44, 29, 1,  47,
+            35, 34, 10, 33, 20, 33, 5,  33, 50, 2,  49, 20, 44, 39, 28, 37, 44, 20, 16, 34, 41, 38, 40, 22,
+            41, 6,  27, 0,  16, 18, 20, 35, 19, 22, 12, 19, 11, 3,  30, 34, 31, 23, 19, 44, 26, 24, 1,  17,
+            19, 20, 29, 27, 31, 39, 41, 36, 48, 0,  9,  0,  33, 45, 12, 47, 3,  47, 17, 5,  24, 13, 14, 15,
+            40, 27, 15, 31, 36, 13, 21, 6,  9,  34, 9,  26, 36, 5,  28, 13, 49, 24, 41, 28, 2,  32, 48, 30,
+            41, 45, 11, 10, 31, 20, 42, 45, 18, 12, 39, 14, 41, 21, 34, 4,  31, 23, 29, 8,  37, 44, 11, 4,
+            1,  32, 30, 27, 11, 19, 30, 25, 50, 6,  35, 20, 21, 36, 35, 50, 6,  5,  36, 29, 13, 4,  4,  45,
+            9,  16, 11, 18, 3,  26, 3,  40, 11, 27, 44, 33, 27, 16, 16, 34, 50, 33, 28, 37, 23, 3,  28, 48,
+            8,  35, 10, 27, 4,  22, 38, 17, 33, 40, 47, 11, 20, 7,  50, 47, 27, 42, 26, 31, 4,  38, 6,  42,
+            39, 36, 1,  15, 13, 18, 4,  47, 28, 15, 20, 22, 30, 26, 46, 25, 50, 43, 10, 47, 5,  41, 19, 44,
+            44, 41, 40, 15, 4,  20, 8,  35, 17, 49, 32, 41, 6,  43, 47, 24, 30, 39, 8,  25, 20, 7,  18, 3,
+            1,  6,  49, 28, 49, 22, 15, 25, 22, 5,  32, 11, 31, 33, 7,  3,  39, 23, 2,  50, 2,  35, 50, 12,
+            7,  6,  15, 5,  35, 3,  25, 50, 41, 31, 15, 31, 26, 21, 6,  45, 22, 9,  18, 21, 42, 37, 39, 0,
+            21, 24, 0,  13, 38, 6,  27, 10, 0,  12, 49, 40, 48, 24, 5,  27, 23, 43, 5,  24, 7,  16, 37, 24,
+            19, 20, 23, 40, 45, 48, 40, 16, 35, 22, 12, 42, 1,  45, 23, 32, 33, 45, 32, 31, 3,  26, 7,  37,
+            26, 34, 2,  4,  36, 3,  3,  0,  48, 37, 18, 15, 17, 39, 33, 9,  8,  5,  33, 38, 13, 1,  4,  49,
+            15, 39, 31, 19, 10, 6,  31, 39, 32, 27, 2,  49, 40, 14, 49, 30, 29, 38, 41, 33, 6,  17, 47, 11,
+            18, 22, 22, 31, 48, 12, 6,  10, 45, 32, 14, 41, 43, 43, 46, 12, 38, 23, 42, 37, 39, 33, 9,  27,
+            50, 47, 2,  8,  6,  37, 41, 10, 25, 42, 37, 27, 30, 25, 15, 28, 35, 44, 32, 38, 8,  23, 0,  12,
+            37, 50, 5,  20, 40, 10, 28, 37, 31, 9,  18, 39, 28, 0,  38, 1,  38, 10, 48, 18, 16, 7,  15, 44,
+            50, 18, 22, 36, 45, 30, 19, 21, 35, 0,  31, 18, 40, 4,  29, 24, 32, 3,  29, 28, 28, 30, 34, 41,
+            13, 42, 25, 3,  2,  17, 40, 36, 40, 26, 22, 7,  16, 22, 4,  11, 30, 37, 50, 47, 32, 21, 32, 40,
+            6,  20, 42, 19, 29, 29, 9,  18, 17, 1,  1,  42, 13, 26, 15, 47, 13, 21, 44, 42, 9,  40, 23, 24,
+            6,  4,  37, 25, 22, 37, 39, 8,  31, 6,  38, 33, 48, 3,  2,  14
+        };
+        // py_bin_edges
+        xarray<double> py_bin_edges = {10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20.,
+                                       21., 22., 23., 24., 25., 26., 27., 28., 29., 30., 31.,
+                                       32., 33., 34., 35., 36., 37., 38., 39., 40.};
+        // py_count
+        xarray<long> py_count = {17, 25, 17, 21, 9,  18, 16, 20, 17, 13, 21, 19, 19, 18, 22,
+                                 18, 17, 21, 18, 14, 18, 28, 21, 24, 20, 24, 20, 23, 17, 47};
+
+        auto bin_edges = xt::histogram_bin_edges(py_a, 10, 40, std::size_t(30));
+
+        auto count = xt::histogram(py_a, bin_edges);
+
+        EXPECT_EQ(xt::cast<double>(bin_edges), py_bin_edges);
+
+        EXPECT_EQ(count, xt::cast<double>(py_count));
+    }
+}
diff --git a/test/test_extended_xmath_average.cpp b/test/test_extended_xmath_average.cpp
deleted file mode 100644
index 467cb88ee..000000000
--- a/test/test_extended_xmath_average.cpp
+++ /dev/null
@@ -1,1053 +0,0 @@
-
-#include <algorithm>
-
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xmath.hpp"
-
-// This file is generated from test/files/cppy_source/test_extended_xmath_average.cppy by preprocess.py!
-
-namespace xt
-{
-    using namespace xt::placeholders;
-
-    /*py
-    a  = np.random.random(4*5*6*7).reshape(4,5,6,7)
-    w  = np.random.random(4*5*6*7).reshape(4,5,6,7)
-    av = np.average(a, weights=w, axis=(0,1))
-    */
-    TEST(xtest_extended_xmath, average)
-    {
-        // py_a
-        xarray<double> py_a = {{{{9.9676318451371482e-01,3.9730618453933475e-01,
-                                  9.6839544656576582e-01,6.5108387668022183e-02,
-                                  7.4864636830291476e-01,3.7412542406878402e-01,
-                                  7.2359844421248976e-01},
-                                 {4.6378281704115232e-01,8.3205402198057943e-02,
-                                  5.3800895026605455e-02,8.1863806579094744e-01,
-                                  3.1425330771950633e-01,2.6424778168311092e-01,
-                                  7.9621904679323896e-01},
-                                 {6.6899029176131319e-01,4.4882219445708027e-02,
-                                  4.8802761377630965e-01,5.6227664134614408e-01,
-                                  3.4429739250076508e-01,6.5432664885385117e-01,
-                                  6.0038054798714402e-01},
-                                 {4.1888750331718150e-01,9.9663088204204353e-01,
-                                  2.2509494886636794e-01,3.7673711439173663e-01,
-                                  1.3757756090733086e-01,7.1706314955799377e-02,
-                                  8.6495327767338859e-01},
-                                 {4.0264901509095274e-01,3.3817825197233475e-01,
-                                  8.6069042696785791e-01,7.7204934445680806e-01,
-                                  7.9621636366584447e-01,5.2102938942614163e-01,
-                                  3.0073140156846478e-01},
-                                 {3.5195288263760005e-01,8.1601147191971579e-01,
-                                  6.3173810466916480e-01,8.1048518890857169e-01,
-                                  8.9377827059420667e-01,3.9903209327298772e-01,
-                                  6.3809886506120683e-01}},
-                              
-                                {{2.2834604146678894e-01,5.5914577266384591e-01,
-                                  8.2098721870617264e-01,1.9560341320376839e-01,
-                                  7.5198931147458625e-01,3.5309242536793273e-01,
-                                  5.2205928537415580e-01},
-                                 {1.7209479503416369e-01,1.3456772196982170e-01,
-                                  9.5360402690603974e-01,1.1936177185069685e-01,
-                                  2.2031733466447856e-01,2.7418172155916509e-01,
-                                  4.8011690744384405e-01},
-                                 {5.7879294929845726e-01,7.3553276342188201e-01,
-                                  2.6750581205603918e-01,9.8354498580761152e-01,
-                                  9.9721502473777979e-01,4.0485614594926389e-02,
-                                  2.0032769612638934e-01},
-                                 {3.8889809329278535e-01,3.6703777131015236e-01,
-                                  6.5307169622155103e-02,2.0432069737975245e-01,
-                                  6.2696700576741238e-01,1.8493124998385335e-01,
-                                  9.0947936758032144e-01},
-                                 {3.8992294636026104e-01,5.4612125038682457e-01,
-                                  8.9478317414294595e-01,3.6989040217868130e-01,
-                                  1.4606900414025203e-01,8.6287748943970288e-02,
-                                  1.9143613674783966e-01},
-                                 {9.2422969600861515e-01,9.9290074026282593e-01,
-                                  1.6118740424935463e-01,3.9059524266714607e-01,
-                                  1.7975799872575571e-01,1.1598564100250730e-01,
-                                  4.3628758977418480e-01}},
-                              
-                                {{9.3154223618579191e-01,1.5199389532996133e-01,
-                                  6.4604523627073840e-01,3.7025816307037029e-01,
-                                  8.4764066327006060e-01,1.6097524219034209e-02,
-                                  1.4920221645581400e-01},
-                                 {6.3441826774110521e-01,8.5359981718724620e-01,
-                                  6.5175777187400019e-01,2.9513255483508283e-01,
-                                  7.0941026407243368e-01,5.4138419493586942e-01,
-                                  6.8455201680526379e-01},
-                                 {5.1442872070763701e-02,9.5723354665944127e-01,
-                                  9.7712215584877971e-01,7.5512082579103545e-01,
-                                  4.9146441995212398e-01,8.7060164201377443e-01,
-                                  7.7034724378913366e-01},
-                                 {3.3934409638643259e-01,3.2948973037032370e-02,
-                                  5.5085622162260151e-01,7.4699817313728611e-01,
-                                  5.1426343596956858e-02,7.4858337358616522e-01,
-                                  1.1274259609716542e-01},
-                                 {1.9852301512807091e-01,7.8934445217491245e-01,
-                                  4.5217175529975107e-01,5.3470887230283248e-01,
-                                  7.9291896826047625e-01,3.7463995516529014e-03,
-                                  8.4797341781839319e-01},
-                                 {5.5475910963065767e-01,6.6170707229960191e-01,
-                                  1.9054727341434707e-01,3.5999958484276118e-01,
-                                  3.3742234144107208e-01,1.8941324700400997e-02,
-                                  3.3137989786531674e-01}},
-                              
-                                {{8.9911542284376678e-01,9.7957783376649266e-01,
-                                  5.8484260621507966e-01,8.7795859338125792e-01,
-                                  2.4367159407506889e-02,3.8122281896344312e-01,
-                                  4.4501918126119311e-01},
-                                 {7.4825215983441051e-01,7.7096016395534195e-01,
-                                  8.7503509909916621e-01,5.3831192628614688e-02,
-                                  1.3932935252595147e-01,2.0439678934620620e-01,
-                                  4.2565814185201611e-01},
-                                 {3.6371174854536448e-01,9.6435033012366544e-01,
-                                  7.2157331508612110e-01,2.4856729703118230e-01,
-                                  8.3922217295930712e-01,6.6170206013694632e-01,
-                                  8.2022468338126375e-01},
-                                 {8.6142322026754370e-01,9.5912560346214137e-01,
-                                  3.3568937475427696e-01,4.1190300717950601e-02,
-                                  4.8400889288847804e-01,8.6491586554537170e-01,
-                                  7.4095198366057424e-01},
-                                 {4.6243546812309499e-01,2.5126893723627841e-01,
-                                  9.6017903546965278e-01,9.9508930829403319e-01,
-                                  6.2641631283541022e-01,9.7838500619803448e-01,
-                                  1.0281818186235103e-01},
-                                 {7.5390599110500423e-01,1.8375258585421428e-01,
-                                  1.3619482913856462e-01,1.6830629792884622e-01,
-                                  2.8713319507943835e-01,1.7479578287495967e-01,
-                                  8.0768872671642133e-01}},
-                              
-                                {{4.4844344783282308e-01,6.8225218396591014e-02,
-                                  3.1829212604617596e-01,5.6921239514838307e-01,
-                                  6.0768876638565616e-01,3.8343562372333950e-01,
-                                  3.2580784353657621e-01},
-                                 {7.6871970961916125e-01,4.0431531924185760e-01,
-                                  6.8754329525585722e-01,2.6323860681357913e-01,
-                                  5.2785959174482067e-01,9.5511292181841101e-01,
-                                  2.9485659846591650e-01},
-                                 {3.3931391384216958e-01,7.2957975540833564e-01,
-                                  7.2778070312893384e-01,9.5644705451867962e-01,
-                                  4.5966919044075183e-01,2.9707451635596627e-04,
-                                  1.1101969664703759e-01},
-                                 {6.6255850796173132e-02,3.7653173563698428e-01,
-                                  7.8971835339461549e-01,8.5862126855142751e-01,
-                                  1.8587418326295302e-01,8.4044202255959499e-01,
-                                  1.5459435015146616e-01},
-                                 {1.0398132895738410e-01,8.7724970450074324e-02,
-                                  8.0661718927423909e-01,3.9921544850098312e-01,
-                                  6.2071966930976719e-02,9.6782972189221328e-01,
-                                  2.8507176400031964e-01},
-                                 {7.4364120792789179e-01,1.6227317109806993e-01,
-                                  9.8360097828861071e-01,4.9575824499122678e-01,
-                                  4.1835433715908432e-01,8.4657503434926518e-01,
-                                  2.8749332532184169e-01}}},
-                              
-                              
-                               {{{7.6552023950974291e-01,6.7655959604181060e-01,
-                                  9.0102428456017325e-01,7.7494095532805518e-01,
-                                  7.4310905771424729e-01,7.6076703928784695e-01,
-                                  6.7241624743478601e-01},
-                                 {1.9001462180287831e-01,1.3335663810994036e-01,
-                                  4.4827677475220884e-01,4.2072540328757380e-01,
-                                  1.6728433210071236e-01,6.0871005532544320e-02,
-                                  4.2148697228149601e-01},
-                                 {6.8480112136026861e-01,4.8241445228301860e-01,
-                                  5.5582953410224878e-01,2.2119726415215313e-02,
-                                  7.7333522482561090e-01,8.3058569319376196e-01,
-                                  8.7563289709201786e-01},
-                                 {8.7494335209624796e-02,9.9091692394680730e-01,
-                                  9.2080277227492091e-01,2.1319189298340813e-01,
-                                  3.0273714168670940e-01,7.4870666031763788e-01,
-                                  3.8431548036227781e-01},
-                                 {1.4947204591846142e-01,7.7638331382352910e-01,
-                                  4.2773539808783390e-01,1.6567455088077221e-02,
-                                  5.1902443713582724e-01,4.4013395665516430e-01,
-                                  3.9854723372453549e-01},
-                                 {2.4745215008473442e-01,4.4689097747524253e-01,
-                                  1.6544864014344218e-01,8.8455805763353534e-01,
-                                  5.4171053202870634e-01,4.5064772592825997e-01,
-                                  1.7145452395051319e-01}},
-                              
-                                {{8.0567574866213798e-02,9.6030060383805027e-01,
-                                  2.4227928607109972e-01,3.2307252424132193e-01,
-                                  4.4596474440115219e-01,6.4496579471739079e-01,
-                                  3.0185704148840475e-02},
-                                 {4.4039934310510920e-01,1.5960012907891752e-01,
-                                  7.1508109808895182e-01,2.0636877596040604e-01,
-                                  6.1146575182843999e-01,5.9003207237484234e-01,
-                                  2.5564914851977538e-02},
-                                 {4.8817493620480512e-01,7.7970900366991891e-01,
-                                  4.0025374738329467e-01,9.2103700258069698e-01,
-                                  7.9267300952892827e-01,5.7949689428289630e-01,
-                                  4.0580858429700051e-02},
-                                 {6.6121646148379964e-01,9.9469921050999754e-01,
-                                  8.4429031826060252e-01,3.2338821960428932e-01,
-                                  8.1075426443920184e-01,5.6569925111916486e-01,
-                                  9.1494105875237575e-01},
-                                 {5.7386256068212183e-01,9.0812814517172757e-01,
-                                  6.9111922505845824e-01,3.4699150202637197e-01,
-                                  7.7853509616948802e-01,5.6868823186974393e-01,
-                                  6.4485196581658188e-01},
-                                 {2.9166539949143222e-01,4.5390701690333946e-01,
-                                  3.8108497054621138e-01,9.6399049924119473e-01,
-                                  1.0934012771405266e-03,6.9315634568548457e-01,
-                                  8.9240960224383281e-01}},
-                              
-                                {{2.9054335145827737e-01,1.4209099469505437e-01,
-                                  8.0210359926802000e-01,8.5020044304347708e-01,
-                                  9.0257954574911903e-01,9.6106911948237883e-01,
-                                  7.3419110506653484e-01},
-                                 {3.6060930462780461e-01,3.0232220696187595e-01,
-                                  7.8883253078008830e-01,3.5706026372835575e-01,
-                                  8.8142387449493220e-01,6.1324609592514623e-01,
-                                  9.8949373987758171e-01},
-                                 {3.1724198743242271e-01,5.0651030004720521e-01,
-                                  9.2358131476248961e-01,3.9345510267589634e-01,
-                                  5.3695740475721687e-01,9.9447086782783523e-01,
-                                  4.7403784128705906e-01},
-                                 {1.9328719219469448e-01,9.9942503564512430e-01,
-                                  3.3437068238544421e-02,8.3309610830290748e-01,
-                                  5.3905930892238940e-01,4.6069376031861631e-01,
-                                  5.3154392293829889e-01},
-                                 {2.0707531550228919e-01,5.7601901922931109e-01,
-                                  3.4661332750772655e-02,3.0105498421323273e-01,
-                                  3.8688703636913024e-01,7.2417367430088364e-01,
-                                  2.9624817998857467e-01},
-                                 {7.8322564896349989e-01,2.8772423183220486e-02,
-                                  3.9701143147273565e-01,4.3922395381065582e-01,
-                                  4.4162349869178119e-01,5.8317044748615487e-01,
-                                  5.3710579514059187e-01}},
-                              
-                                {{9.5625518990739411e-01,5.9669175016759568e-01,
-                                  1.5966180422688592e-01,5.3111338755102366e-01,
-                                  4.5287666635748436e-01,9.6704229170526423e-01,
-                                  4.2207766320194429e-01},
-                                 {7.9577555376032949e-02,5.0986552836057797e-02,
-                                  2.3486554485417521e-01,5.1726274116165549e-01,
-                                  5.9514679105866464e-01,9.2993765906599923e-01,
-                                  3.6008507408040247e-01},
-                                 {2.9302511380628227e-01,6.8496659814249017e-01,
-                                  8.6266747119578957e-01,9.2157419356231429e-01,
-                                  7.4258505249154061e-01,2.9342187584177282e-02,
-                                  1.9531649225221814e-01},
-                                 {8.6592070941436616e-02,9.7690043243034774e-01,
-                                  8.6164137679676334e-01,6.6559530088775709e-01,
-                                  6.5177425541495360e-01,6.6610876709551914e-01,
-                                  8.0090091308229328e-01},
-                                 {9.2878259416707543e-01,9.3962531600966104e-01,
-                                  1.9618194589426108e-01,1.6497196448184703e-01,
-                                  5.6844642263396283e-01,9.8819050314232759e-01,
-                                  5.5783497194404308e-01},
-                                 {5.4945951549258631e-02,1.9126225541161046e-01,
-                                  4.8973795718864122e-01,1.7899459505956783e-01,
-                                  2.3415700277283857e-01,9.5650676617494290e-01,
-                                  7.1378282742617138e-01}},
-                              
-                                {{7.8850077909272853e-01,7.3318069799028551e-02,
-                                  1.7298322242239061e-01,5.8686645739143284e-03,
-                                  4.9129184016495764e-01,5.0887781165424106e-01,
-                                  5.4281120468402810e-01},
-                                 {6.3354765676001401e-01,9.5898336572580301e-01,
-                                  3.9541126343986477e-01,6.3294773882538735e-01,
-                                  4.5791959850095632e-01,6.5041422471881072e-01,
-                                  2.1963574516024731e-01},
-                                 {8.3547838836587973e-01,7.1580008801273509e-01,
-                                  7.1965083860940426e-01,5.2204976030897798e-01,
-                                  6.5260655379302146e-02,9.8719920685134133e-03,
-                                  7.2253759805118722e-01},
-                                 {8.1286975366989589e-01,9.8745458579537104e-01,
-                                  6.3657473089934935e-01,7.4000716398592670e-01,
-                                  7.5859226979550820e-01,9.4332048941825675e-01,
-                                  6.2513918102540711e-01},
-                                 {6.3835048767291502e-01,7.6179819232885648e-01,
-                                  3.2901376076578992e-01,8.5745666774295781e-01,
-                                  1.8711499439200774e-01,2.0234116072499708e-01,
-                                  1.2649224049540797e-01},
-                                 {2.7434465795701712e-01,8.3036980091354362e-01,
-                                  1.4584020589157154e-01,9.3579734458618269e-01,
-                                  3.6387432272906084e-01,9.6112661166779867e-01,
-                                  7.6418007111042696e-01}}},
-                              
-                              
-                               {{{6.1076707503273453e-01,3.8359197725176486e-01,
-                                  3.8428316573307886e-01,9.0071759258997330e-01,
-                                  3.0684757187847522e-01,8.3168855948559994e-01,
-                                  4.4433149635084479e-01},
-                                 {3.3421301825831118e-01,5.3973281472898960e-01,
-                                  1.7596545620171766e-02,9.9449057816762010e-01,
-                                  5.8636764940774089e-01,9.4897456162505567e-01,
-                                  3.3911875097475808e-01},
-                                 {9.4839381148459512e-01,4.6566478743057793e-01,
-                                  7.8471843070620484e-01,6.0734529169186857e-01,
-                                  2.2772084269786841e-01,3.1331924481214601e-01,
-                                  9.1709179859214252e-01},
-                                 {9.2492154409504979e-01,2.7423726632763412e-01,
-                                  1.7314270086318961e-01,6.1324407771581502e-01,
-                                  6.0827000401796605e-01,4.6034718666327090e-01,
-                                  3.5320987369510248e-01},
-                                 {3.2766735672915293e-01,5.5867383310786267e-01,
-                                  1.7284783026735762e-01,9.2487264645742540e-01,
-                                  8.4923912842785287e-01,5.2716847732942451e-01,
-                                  2.0901292533154014e-01},
-                                 {6.7263072317031536e-01,7.1262811643549018e-01,
-                                  3.0274373530363785e-01,6.6614421171064386e-01,
-                                  1.7497021976067040e-01,6.4862011664973174e-01,
-                                  4.6725179674120931e-02}},
-                              
-                                {{2.2509660655677810e-01,3.4957694541202455e-02,
-                                  3.5388436908003196e-01,5.1933528688779684e-01,
-                                  4.2793397449854531e-01,8.1118961442508986e-01,
-                                  4.2501230147846147e-01},
-                                 {4.0162069776730280e-01,9.9567743331902969e-01,
-                                  6.6705731709010618e-02,3.9419309644974188e-01,
-                                  8.4941693224358283e-01,5.2288553304657037e-01,
-                                  3.4396153851953160e-01},
-                                 {7.7828928033961386e-01,3.1433331283636079e-01,
-                                  4.2841549918244071e-01,2.6470748092421148e-01,
-                                  5.4804998141769290e-01,5.8687079265459707e-01,
-                                  4.5050690134147231e-01},
-                                 {5.2363866854273744e-02,9.2590960642786868e-01,
-                                  4.3373604632693163e-01,3.2823926723803853e-02,
-                                  9.4285875490627502e-02,4.5862188714304986e-01,
-                                  5.4715167752957716e-01},
-                                 {3.7678171768195456e-01,3.7483005458432017e-01,
-                                  8.8965998077967434e-01,5.2063359998717840e-01,
-                                  5.6836964211035568e-01,5.0896388650979862e-01,
-                                  1.2928786261552339e-01},
-                                 {2.4301064444558185e-01,4.7225055091924484e-01,
-                                  1.1465844482109788e-01,4.9208149802855805e-01,
-                                  4.0251653337110938e-01,7.2408150865885634e-01,
-                                  6.7678861340038388e-01}},
-                              
-                                {{2.5848263200399124e-01,9.6693096377858401e-01,
-                                  4.4304473213371609e-01,3.7581217114303500e-01,
-                                  6.4250814521208643e-01,5.8446930232498173e-01,
-                                  9.4039512336605957e-01},
-                                 {2.3916122864573452e-02,7.3892740508624777e-01,
-                                  7.1016937693251547e-01,5.6167576546078213e-01,
-                                  4.7948438178213593e-01,7.8574235873060239e-01,
-                                  6.4801049015359213e-01},
-                                 {1.5484239533213295e-01,6.1838232882947297e-01,
-                                  7.3422379302052643e-01,9.7905662446131247e-01,
-                                  4.7853571442231224e-01,4.9286256906438708e-01,
-                                  9.3841647347324553e-01},
-                                 {8.9077129006476452e-01,8.1385614168999409e-01,
-                                  4.3143029967144519e-01,5.1179283560400268e-01,
-                                  3.7630079408920825e-02,8.9003496254669678e-01,
-                                  1.1606108149057048e-02},
-                                 {7.8814666382474907e-01,2.6497040251421100e-01,
-                                  6.0326361378055771e-01,2.4429471843697237e-01,
-                                  5.1267958414631798e-01,1.1452173603022886e-01,
-                                  3.9665692203759184e-01},
-                                 {5.5177103756008539e-01,4.4564830112167964e-01,
-                                  3.6711776144940511e-01,7.9671759332279413e-01,
-                                  1.1560051136386040e-01,6.9660056830044625e-01,
-                                  8.2020635428891009e-01}},
-                              
-                                {{3.5359038711726487e-01,1.9739874647981437e-01,
-                                  4.7657487064173520e-01,9.0982739773277033e-01,
-                                  3.8908350116482593e-01,5.9985769370096975e-01,
-                                  1.8404666060638963e-01},
-                                 {4.8501094056397021e-02,6.1011186714166588e-01,
-                                  3.7244641724248151e-01,2.9333566026183899e-01,
-                                  8.3484996637630382e-01,7.7487530880631816e-01,
-                                  2.0460123674902053e-01},
-                                 {6.2392978611820082e-01,7.5775949221267613e-01,
-                                  3.9015615552292726e-01,7.1844485442218753e-01,
-                                  1.0160781161857269e-01,2.5347497091495685e-01,
-                                  7.7631507496229279e-01},
-                                 {7.6291533707972481e-01,4.3358935089462625e-01,
-                                  7.4731737673624210e-01,4.5639270429723711e-03,
-                                  4.7741706902717485e-01,2.8020875138492962e-01,
-                                  5.8432494095673593e-01},
-                                 {5.2932679138212479e-01,9.8406578700095793e-01,
-                                  8.3051281311371505e-01,6.6023364405442508e-01,
-                                  5.4110810641805118e-01,6.0178704155253204e-01,
-                                  8.4672070733387006e-01},
-                                 {7.1238209261923813e-01,7.2015741353630602e-01,
-                                  2.6827416028892936e-01,7.3101350005749444e-01,
-                                  3.2526630589912919e-01,8.8064614673002317e-01,
-                                  8.2859202541759613e-01}},
-                              
-                                {{5.2001103464917720e-01,5.7376390837793667e-01,
-                                  6.3498354162942650e-01,3.2437536013017321e-01,
-                                  8.1501184834491336e-01,5.7869556040096681e-01,
-                                  2.3631892108973318e-02},
-                                 {3.0337411235851519e-01,4.7896875124898353e-01,
-                                  3.2276296576213326e-01,4.3726468867312862e-01,
-                                  4.6550880755896862e-01,4.6536530437137325e-01,
-                                  2.2068971595982090e-03},
-                                 {9.2165310513676380e-02,2.6237617305912353e-01,
-                                  4.0033658680680506e-01,2.3462566238451732e-01,
-                                  9.3318510756862505e-01,1.9900422650355254e-01,
-                                  5.8176947437240756e-01},
-                                 {9.7015698802935779e-01,5.1634346659362651e-01,
-                                  9.4387206899139731e-01,9.8349407776134312e-01,
-                                  5.0048250596864097e-01,7.1186007703868148e-01,
-                                  7.3227970178015600e-01},
-                                 {4.6585299131542801e-01,8.9260854408116586e-01,
-                                  9.4799972246939757e-01,7.2969213196525184e-01,
-                                  1.7167001042168806e-01,9.4215702747094121e-01,
-                                  1.7483271642679588e-01},
-                                 {1.7428280717337596e-01,6.8033871912212152e-01,
-                                  7.2734539869025117e-02,2.4425749675865482e-01,
-                                  5.3032426006986000e-01,2.9217222937621756e-01,
-                                  8.2892418339150042e-01}}},
-                              
-                              
-                               {{{7.9134837978586370e-01,9.2680026223008305e-02,
-                                  6.2459324597824217e-02,4.7406402779839207e-01,
-                                  3.1706503861311741e-01,5.7466757692469250e-01,
-                                  4.6420501260836600e-01},
-                                 {1.3209211080402516e-02,2.3431750532916629e-01,
-                                  5.2380847930408869e-03,2.9202922545220389e-01,
-                                  5.4461114119454668e-01,3.7100778702206960e-02,
-                                  4.4162620449954937e-01},
-                                 {3.2718438184570253e-01,6.9961894995286655e-01,
-                                  8.4624348195615740e-01,6.1248574271804102e-01,
-                                  6.1903280981227626e-01,6.1813385167667523e-01,
-                                  5.0757011042917932e-01},
-                                 {9.5025919843808260e-02,1.1665526825393358e-01,
-                                  5.4992791109625616e-01,2.9930744940541842e-01,
-                                  9.7435548669253425e-01,9.3188881071434015e-01,
-                                  8.4627849575017788e-02},
-                                 {5.2471669799660925e-01,9.5139267057782861e-01,
-                                  7.8934677040332812e-01,2.1744812660182911e-01,
-                                  6.1474263352101344e-01,3.7751175316903929e-01,
-                                  4.5974481611596463e-01},
-                                 {1.6532658753085483e-01,1.2583877762226303e-01,
-                                  7.0588333431798844e-01,8.5969436911387487e-01,
-                                  5.7552889968899046e-01,2.7367653254690039e-02,
-                                  3.4858340602273918e-01}},
-                              
-                                {{9.0369604400155146e-01,7.7490835268540226e-01,
-                                  2.9829148905437752e-02,9.7203340625579404e-01,
-                                  7.4264653467915887e-03,8.2160391391721266e-02,
-                                  7.3521937776065627e-01},
-                                 {7.6344420613513331e-01,8.5399866991240103e-01,
-                                  8.6128470868124252e-02,4.8409796627116175e-01,
-                                  1.2274147353191001e-01,4.4088751982171270e-01,
-                                  7.8035001225611655e-01},
-                                 {7.3877858849829670e-02,5.1385738995801933e-01,
-                                  8.8018033184201649e-02,3.6673858095275902e-02,
-                                  3.8159287336977710e-02,4.1853029259529184e-01,
-                                  6.6254849858771037e-01},
-                                 {7.7937123279492149e-01,9.2834288658544895e-01,
-                                  9.7701326832739643e-01,9.3670579414876864e-01,
-                                  3.1608539976863570e-01,3.5888747121441555e-01,
-                                  5.4798949612533443e-01},
-                                 {2.0934306791754620e-01,2.8807971009398681e-01,
-                                  5.9331622708041432e-01,1.3005894191921263e-01,
-                                  3.9084022598277390e-01,1.9899320452893099e-01,
-                                  4.2745824905590935e-01},
-                                 {8.9569758378493691e-01,5.1583856844257070e-01,
-                                  3.6320737082006194e-01,8.3242451519538629e-01,
-                                  4.4371637969854805e-01,1.9085265578594002e-01,
-                                  4.9163746371916817e-01}},
-                              
-                                {{3.3067427240721792e-01,3.8678834826280029e-01,
-                                  7.2657935903102078e-01,4.9323800313123001e-02,
-                                  3.1867536986316114e-01,1.3536705856092746e-01,
-                                  9.5739893849286528e-01},
-                                 {1.1029936813203201e-01,5.7702918384860258e-01,
-                                  4.6584963136687163e-01,3.0000045565299227e-02,
-                                  6.3141862321779096e-02,8.5624864091189012e-01,
-                                  5.0440925679234105e-01},
-                                 {6.0680292299488581e-01,9.1299725730649484e-01,
-                                  1.5919889681262389e-01,5.4150543488125080e-01,
-                                  1.5765332393265807e-01,9.7973263795856402e-01,
-                                  4.1474534882312053e-01},
-                                 {2.8000699373569993e-01,8.2507382022248743e-01,
-                                  8.8491124095289997e-01,9.6473834332757946e-01,
-                                  3.7076260691040885e-01,9.9296573515404940e-01,
-                                  2.1837912124459069e-02},
-                                 {1.4462802569936273e-01,5.1722094788119555e-01,
-                                  5.0384857415635365e-02,7.3728186934729001e-01,
-                                  7.6448894115903587e-01,7.7450233648206546e-01,
-                                  1.4820165081593273e-01},
-                                 {6.1371861373816683e-01,2.8297197114358374e-01,
-                                  2.3158467654458637e-01,8.4672829072758404e-01,
-                                  9.3517377398751300e-01,4.6522266893640374e-01,
-                                  5.0283407389201229e-01}},
-                              
-                                {{3.1942416952664510e-01,9.1029987121835321e-01,
-                                  8.4198652164617493e-01,6.6427013463253437e-01,
-                                  2.3231279610918398e-01,7.7400531376211024e-01,
-                                  6.5714781216255702e-01},
-                                 {6.7160991761624578e-01,6.8623123803844521e-01,
-                                  4.2431670319029424e-01,2.3141040886644970e-01,
-                                  7.6065062423778007e-01,3.5791662570011751e-01,
-                                  5.7103283767003332e-01},
-                                 {9.9695623861571947e-01,1.2563503118767361e-01,
-                                  4.2547312003072202e-01,5.7055832034933973e-01,
-                                  6.2026983423959192e-01,9.1425658493038520e-01,
-                                  5.3567285476935345e-02},
-                                 {5.7181274520734449e-01,5.5364613294579157e-01,
-                                  5.7989941342154960e-01,8.8497744294844694e-01,
-                                  5.4991755947146526e-01,4.5782337651915017e-01,
-                                  8.6012196367335136e-01},
-                                 {5.7270593881626486e-01,5.9757942116828333e-01,
-                                  6.2889712565831402e-01,9.5777599027256699e-01,
-                                  8.3387234390447840e-01,5.2782657005493550e-01,
-                                  4.5842655195029614e-02},
-                                 {9.8419288078463596e-01,6.4319404588821871e-01,
-                                  3.3250876693616316e-01,1.9355009597729023e-01,
-                                  9.3753547893654565e-01,6.3091111960227320e-03,
-                                  9.0339093520633651e-01}},
-                              
-                                {{2.2570271134057518e-02,1.3809341378787865e-02,
-                                  1.6353607470636988e-01,9.2168506917506776e-01,
-                                  5.5243756065946104e-01,5.5990934460259034e-01,
-                                  8.9501877041906608e-01},
-                                 {8.1927565933168855e-01,9.9548002472297115e-01,
-                                  7.7998798537630287e-01,7.4051027043744355e-01,
-                                  7.4904335819066814e-01,4.6907578486660417e-01,
-                                  5.0715716672601907e-01},
-                                 {8.6807025622770251e-01,6.5969909433020169e-02,
-                                  4.3415479513315258e-01,6.5882917213032566e-01,
-                                  5.2368460750415913e-01,5.2071836381637759e-01,
-                                  3.4435829357973835e-01},
-                                 {2.8513110132856767e-01,4.1484168490156581e-01,
-                                  6.7886151546292628e-02,1.1215332316320870e-01,
-                                  8.7523193345240013e-01,6.4353606884133552e-01,
-                                  9.4243240336089074e-01},
-                                 {2.2911869857308687e-01,1.1302587960272747e-01,
-                                  6.7123164615842856e-01,3.6569464359823201e-01,
-                                  9.6222095252110451e-02,9.0478201520613377e-01,
-                                  6.2193852967380936e-01},
-                                 {6.6069312453931894e-01,4.3692708670672165e-01,
-                                  3.7012169056944022e-01,4.3813515910568512e-01,
-                                  8.6968276533713706e-01,5.3836795614110633e-01,
-                                  7.8706778396924948e-01}}}};
-        // py_w
-        xarray<double> py_w = {{{{9.2709634234865501e-01,2.1261209335148368e-01,
-                                  4.4721318085972706e-01,9.3781897712248130e-01,
-                                  9.4765070761140213e-01,7.4222578639419667e-01,
-                                  5.9988710850679805e-01},
-                                 {4.4123875049244066e-01,5.3892580130014767e-01,
-                                  6.8620355038890402e-01,4.6397614841360513e-01,
-                                  9.4222241559707809e-01,1.2224417235507756e-01,
-                                  1.0971429346848893e-01},
-                                 {6.4896808257077121e-01,7.0805803927290678e-01,
-                                  5.8916202959347630e-02,1.5121926263857732e-01,
-                                  8.5158635979875164e-01,8.6154920378684063e-01,
-                                  9.8546033976265390e-01},
-                                 {4.5487723359866006e-01,8.1728566262661229e-01,
-                                  3.8819034577571454e-01,4.7160502626517731e-01,
-                                  5.5990189873302132e-01,1.1469210228656035e-01,
-                                  9.9986714695256618e-01},
-                                 {5.5162372275237848e-01,6.5722477390139922e-02,
-                                  1.7146489527716013e-01,8.1880482749077110e-02,
-                                  3.3524571219128441e-01,8.4001963155475989e-01,
-                                  1.7180024366045266e-02},
-                                 {2.4140798798458096e-02,9.9422146823023738e-01,
-                                  2.9431481278394256e-01,3.9174517446231483e-01,
-                                  4.5975810007109585e-01,2.1358365255491019e-01,
-                                  7.7498248349804477e-01}},
-                              
-                                {{5.0296896273477110e-01,8.4256258520613725e-01,
-                                  5.5959953857695721e-01,4.2966893696176556e-01,
-                                  7.5981052710108077e-01,3.0905327660529569e-01,
-                                  1.4817806185089277e-01},
-                                 {4.6414890802132214e-01,8.5832827846439064e-01,
-                                  5.9468313344148649e-01,9.1283746858297365e-01,
-                                  8.3982033585186322e-01,7.9936970605199442e-01,
-                                  9.2416898045398632e-01},
-                                 {7.3338404042592598e-01,8.6688689619175674e-01,
-                                  7.5109846553839510e-01,2.9751362303468809e-01,
-                                  6.3394703070655689e-01,9.9834358850061600e-01,
-                                  9.7868835032975643e-01},
-                                 {8.7188591553327521e-01,2.2874407625854265e-01,
-                                  4.9485711218448936e-01,7.4385209858675228e-01,
-                                  7.0710272842818045e-01,3.6744249394488648e-01,
-                                  7.8840852437504472e-01},
-                                 {7.9601128845926850e-01,8.9179826571380660e-01,
-                                  5.5383584855098855e-01,9.7251370599952036e-02,
-                                  4.8131163516272657e-01,2.7722159165950255e-01,
-                                  8.2445829940911763e-01},
-                                 {4.1260935769548213e-01,9.1648788595908759e-01,
-                                  7.5017134763357252e-01,5.3933148294302413e-01,
-                                  1.9502057449889043e-01,3.1438541815694376e-01,
-                                  1.9115812521118247e-01}},
-                              
-                                {{7.0118197557630113e-01,7.5194117970182162e-02,
-                                  5.7544591337911055e-01,8.8184654906108939e-02,
-                                  5.2670309023590034e-01,9.6066856464846939e-01,
-                                  2.3439477021696531e-01},
-                                 {4.4630736039781149e-01,5.1941238734667927e-01,
-                                  6.0480012511285874e-02,2.9591557220152342e-01,
-                                  4.7261662424896378e-02,3.2894274649359212e-01,
-                                  6.5358066732871256e-03},
-                                 {8.7523063970514015e-01,4.4256842393059326e-01,
-                                  6.0144155847013470e-01,8.5049177646441465e-01,
-                                  4.5849976812252768e-01,3.9321812377902554e-01,
-                                  2.2316612301801897e-01},
-                                 {9.2427644037151269e-01,1.9597326721893082e-01,
-                                  9.4508204218260849e-01,8.0407334229980321e-01,
-                                  4.7348070937789810e-02,7.0586866801998183e-01,
-                                  9.4389746428455423e-01},
-                                 {1.8752849370474967e-01,4.6605730187230965e-01,
-                                  2.3145215698483557e-01,5.4886683371829814e-01,
-                                  2.4792507755050042e-02,9.2736538671758439e-01,
-                                  3.1634158576166582e-01},
-                                 {4.9463912672778199e-01,9.5541974059617318e-01,
-                                  2.2000110005395823e-01,1.2095787212947617e-01,
-                                  8.2381411772179480e-01,8.5456857902347483e-01,
-                                  2.3520583706282960e-02}},
-                              
-                                {{9.8547999881483705e-01,3.2026458651874257e-02,
-                                  9.0005122428980888e-01,5.6549883389020783e-02,
-                                  1.1464838763645469e-01,6.0234406054379042e-01,
-                                  3.5679672447706545e-01},
-                                 {8.0783707221108314e-01,1.5559413452177273e-01,
-                                  3.9339059468366544e-01,7.3687283031066853e-01,
-                                  6.1870120070278312e-01,1.5521244003693824e-01,
-                                  9.4353804188545054e-01},
-                                 {6.3028582343208839e-01,1.0928397760940189e-01,
-                                  1.8665553998867956e-01,4.8352934836888661e-01,
-                                  7.7642217567343752e-01,5.3680360529886739e-01,
-                                  2.2441711102886286e-03},
-                                 {7.2478495933728537e-01,9.8510656180924927e-01,
-                                  4.2441261621851767e-01,9.7735661940006180e-01,
-                                  6.7162684445422660e-01,8.7606671307266737e-01,
-                                  6.2605715496061753e-01},
-                                 {9.3038677621475563e-01,1.0415213630371234e-02,
-                                  9.8607989021628617e-01,9.0426477550066087e-01,
-                                  9.9369924164786305e-01,7.3823658638250789e-01,
-                                  6.3441538197773284e-01},
-                                 {6.9087610933122912e-01,3.7729558786935524e-01,
-                                  2.7390937919251357e-01,4.4110267920317692e-01,
-                                  1.8028626409334048e-01,1.9921217565914262e-01,
-                                  4.3738529961020034e-01}},
-                              
-                                {{5.8948346843221489e-01,6.5896456842299345e-01,
-                                  5.2860746623734012e-01,8.0803204369603299e-01,
-                                  9.0986525137070484e-01,5.2173428204699501e-02,
-                                  8.8481553135082647e-01},
-                                 {7.7554723673976977e-02,8.2288772388849607e-01,
-                                  4.7756334186270266e-01,4.0109997713923584e-01,
-                                  7.8077532960858165e-01,5.8034317976406047e-01,
-                                  4.3083539989351283e-01},
-                                 {9.1148907441527749e-01,3.1943282697735964e-01,
-                                  8.3040284180550628e-01,9.4217308283820822e-01,
-                                  8.4999315077701310e-01,2.2173320215966885e-01,
-                                  3.4117075038074329e-01},
-                                 {5.6996520935517636e-01,8.7940548754848680e-01,
-                                  3.1766672871814405e-01,5.9968652868520400e-01,
-                                  8.4059830154591320e-01,6.4337815329506698e-01,
-                                  3.0811068007545261e-01},
-                                 {7.1138532579320113e-01,3.2689673749917159e-02,
-                                  1.8695954475154031e-01,6.4425149471472265e-02,
-                                  3.8484260489616418e-01,7.3903516794727964e-01,
-                                  6.3424342270239631e-03},
-                                 {1.9428720967697011e-01,4.7177351953701818e-01,
-                                  4.0039210030621930e-01,1.3720012771442480e-01,
-                                  6.3443487875481952e-01,9.5658414643161827e-01,
-                                  9.2579780736661910e-01}}},
-                              
-                              
-                               {{{9.7595728434353124e-01,2.3167523023018466e-01,
-                                  6.2005838770920696e-01,6.0882430627431594e-02,
-                                  5.5522117881212174e-01,6.4985644846932944e-01,
-                                  8.8581648867049090e-01},
-                                 {7.7893534266039477e-01,3.4752705817731522e-01,
-                                  1.0371342297961106e-02,6.7356893520407990e-01,
-                                  9.4617301661423125e-01,4.3975357765493206e-01,
-                                  8.9142222050063380e-01},
-                                 {5.4572270310179372e-01,1.2521907670603138e-01,
-                                  9.9084185663515290e-01,3.0645745923792789e-01,
-                                  6.9244226015741717e-01,4.9641540045807531e-01,
-                                  6.5731079829296679e-01},
-                                 {7.1569695194694627e-01,7.3928245257757463e-01,
-                                  4.7680834587882082e-04,1.1312266404293270e-01,
-                                  3.6259907557092030e-01,6.9624206132153754e-01,
-                                  7.1985518647999036e-01},
-                                 {4.3197232208196934e-01,1.9142541294721849e-01,
-                                  1.8532294414159500e-01,4.9773725441397831e-01,
-                                  6.7548639427846346e-01,8.3918725145577677e-01,
-                                  4.8967060051387401e-02},
-                                 {5.7470904775736420e-01,9.7124168516290466e-01,
-                                  4.4491131267657025e-02,6.0459800969097310e-01,
-                                  9.7241443636973934e-01,3.0317997151461251e-01,
-                                  8.1159683045014819e-01}},
-                              
-                                {{5.8329429566265234e-01,7.8119471742941482e-01,
-                                  9.2264152876241001e-01,7.5424316736469621e-01,
-                                  7.6067521293063312e-01,4.2928604364873801e-01,
-                                  2.6451085447220613e-01},
-                                 {6.0558988621958176e-01,7.9279486058793835e-01,
-                                  1.2778100218157284e-01,8.5475218668892672e-01,
-                                  4.6611711552351198e-01,6.7173024948361393e-01,
-                                  5.2483492276194676e-01},
-                                 {1.3954302784432171e-01,8.4015342269880144e-01,
-                                  8.3475205489043491e-01,6.8113378972492755e-01,
-                                  6.8575871020080426e-01,4.3766885667413802e-01,
-                                  1.4670192006686000e-01},
-                                 {3.5554835088896963e-01,6.3483549189821220e-01,
-                                  2.5775295716296709e-01,6.8975160847743000e-01,
-                                  6.2661484744092943e-01,6.7950424214918936e-01,
-                                  6.3537959874600736e-01},
-                                 {3.2490403409584623e-01,7.5315025465155139e-01,
-                                  6.0585496446812337e-01,9.2836052191767426e-01,
-                                  2.0670921093959771e-01,4.9033374287965947e-01,
-                                  3.4181347131004747e-01},
-                                 {7.7738424712191467e-01,8.6637550614363257e-01,
-                                  2.2531930367256758e-02,4.0569690717977225e-01,
-                                  4.1939831203136257e-01,8.2952008662832810e-02,
-                                  2.4246375400732556e-01}},
-                              
-                                {{7.8157304789965942e-01,5.0997189872991400e-02,
-                                  4.4713063941520925e-01,8.8112037542134436e-01,
-                                  2.9543312334580318e-01,8.3587998285407950e-01,
-                                  1.2853479603928253e-01},
-                                 {2.1082419509651851e-01,3.2504208143640900e-01,
-                                  6.0743990849324681e-01,7.9189660916845428e-02,
-                                  6.5552884606794570e-01,6.2129812695691067e-01,
-                                  9.1326035068989797e-01},
-                                 {3.2756630457397518e-01,4.9728328974402236e-01,
-                                  5.3585960576743885e-01,7.2539673871658283e-01,
-                                  3.4630569080239137e-01,4.5462921153926050e-01,
-                                  9.5647447467370783e-01},
-                                 {8.0891419052731228e-02,3.1412152314216113e-01,
-                                  3.8671603956499601e-01,3.9775725042554633e-01,
-                                  1.2112801257968964e-01,4.3388123152090396e-01,
-                                  3.5386795630991785e-01},
-                                 {7.7067271130028658e-01,9.7685208823503722e-01,
-                                  6.0885066664394794e-01,6.0835948833974962e-01,
-                                  9.2707304396993950e-01,4.1322254214600129e-01,
-                                  8.6206944218298509e-01},
-                                 {6.9488126489204793e-01,4.3880085654149370e-01,
-                                  6.4031797976265681e-01,5.1019962070960301e-01,
-                                  7.6509895327320177e-01,2.5614652208447963e-01,
-                                  1.1722241621491614e-01}},
-                              
-                                {{8.2045090065584025e-01,9.6276153715938728e-01,
-                                  3.8590284105406969e-01,6.9053087281509451e-01,
-                                  3.3322342935019322e-01,9.0407659402067519e-01,
-                                  3.4595983039658118e-01},
-                                 {2.1315981466385603e-01,3.7210561381171570e-01,
-                                  3.4790880942180580e-01,4.9357580110291321e-01,
-                                  7.9415232679476877e-01,6.2509446889565179e-01,
-                                  7.1161394926680932e-01},
-                                 {8.0259929614266079e-01,3.2427318581744491e-01,
-                                  8.0580183291006280e-01,3.9098040267797585e-01,
-                                  6.5774666809794036e-01,9.7785409065752360e-01,
-                                  4.4336404918110406e-01},
-                                 {1.0134072418771667e-01,1.2971049735595408e-01,
-                                  5.0308431044517965e-01,9.8076849428519031e-01,
-                                  4.8067167124182808e-01,7.8438927242917234e-02,
-                                  6.3555605790230629e-01},
-                                 {6.9097922344677509e-01,8.4555701338954958e-01,
-                                  6.6002423609676120e-01,8.6665757992187364e-01,
-                                  9.1794983188657364e-01,8.1545031800269319e-01,
-                                  4.0522715115559171e-01},
-                                 {8.7156704062319468e-01,1.5637218604128800e-01,
-                                  5.8203437173468453e-01,1.8517148184481258e-01,
-                                  5.7942725297933617e-01,2.7478565867633298e-01,
-                                  8.8590585092355956e-01}},
-                              
-                                {{5.3021802616397740e-01,9.3615431551676509e-01,
-                                  2.2702187790535888e-01,2.5991826304998378e-01,
-                                  4.2980058840645041e-01,8.8776618884868597e-01,
-                                  3.8408493733573768e-01},
-                                 {9.7806294534524285e-01,9.0394707527710316e-01,
-                                  9.0525948110442356e-01,7.2599956309687130e-01,
-                                  1.2799357714781268e-01,1.9093107747125693e-04,
-                                  5.7051203295404274e-01},
-                                 {8.1946325279459642e-01,5.1708068071833213e-01,
-                                  7.9267313625426761e-01,1.8872954110888751e-01,
-                                  9.5475073979067349e-01,7.9175570168329823e-01,
-                                  8.7229290464085185e-01},
-                                 {4.9989002165852392e-01,1.2209356342341737e-01,
-                                  8.8125749327439706e-01,5.0951107011921737e-03,
-                                  3.2792049782789023e-01,4.8674893944212816e-01,
-                                  3.1060538685352623e-01},
-                                 {1.2680631827271327e-01,4.5854250012201259e-01,
-                                  5.5478239973852994e-01,1.6272107593863561e-01,
-                                  5.1376336216002805e-01,4.2971986186348188e-01,
-                                  2.9699224537375135e-01},
-                                 {9.2274565531776898e-01,4.5984259671416761e-01,
-                                  8.3473669250774518e-01,9.2695125976097226e-01,
-                                  9.7254784547251716e-01,5.0081515232052609e-01,
-                                  8.6763440701315331e-01}}},
-                              
-                              
-                               {{{9.8407096723240484e-01,9.2469312742427057e-01,
-                                  8.7176415973157217e-01,7.4336730336914891e-01,
-                                  3.6036405240802871e-02,2.2932156571374052e-01,
-                                  3.0113957101526778e-01},
-                                 {1.9841082533466503e-01,9.8057391728063059e-01,
-                                  9.7916813468188502e-01,7.7052739984124319e-02,
-                                  1.7396176783547845e-01,3.3257395814647550e-01,
-                                  4.2829942849640312e-01},
-                                 {9.7838182343743052e-01,9.2078392462202185e-01,
-                                  9.6239513098468676e-01,5.6985910872992029e-01,
-                                  6.9596467985504784e-01,4.5058827187659589e-01,
-                                  4.4883593163738367e-01},
-                                 {3.0593080761483593e-02,2.2154789701110567e-01,
-                                  5.2305917728275397e-01,1.7741844011426955e-01,
-                                  1.5942658268895027e-01,8.7867582945564449e-01,
-                                  7.2306635300260724e-01},
-                                 {2.1681410824873282e-01,4.5904707103959674e-01,
-                                  4.4057032065485213e-01,4.8279498829336209e-01,
-                                  3.9224059374776421e-01,8.7275963416175606e-01,
-                                  1.3244049890259080e-01},
-                                 {9.6613111719008171e-01,1.6253061390368195e-01,
-                                  5.7011666128995164e-01,2.0119616594567513e-01,
-                                  9.8200879039370326e-01,1.4888223229354502e-01,
-                                  8.6974549024266867e-01}},
-                              
-                                {{1.6601368802156069e-01,2.9109067702508185e-01,
-                                  6.6268264085829165e-01,3.3282616481992877e-01,
-                                  1.9888915869671131e-01,4.8794577298904251e-01,
-                                  1.3603078920531364e-02},
-                                 {8.5646559843595804e-01,6.6422635625084325e-01,
-                                  2.5361608535119040e-02,5.3202396176117450e-01,
-                                  2.5531778557890306e-01,9.7062817470393092e-01,
-                                  2.2642060293794830e-01},
-                                 {7.8463099510922540e-01,4.2304374535089173e-01,
-                                  9.7016875946731029e-02,5.5697551375994692e-01,
-                                  7.0552495306053187e-01,5.3084156151412165e-01,
-                                  6.4447088105536954e-01},
-                                 {7.2846162758698618e-01,7.6798592473105787e-01,
-                                  7.8477811834957556e-01,3.8482977503570293e-01,
-                                  2.0483657654214937e-01,5.2837588250906853e-01,
-                                  4.0069326964546959e-01},
-                                 {3.2880612620642102e-01,3.7563769277342252e-01,
-                                  9.1122897248281831e-01,9.2699589782363701e-02,
-                                  9.9557220322658213e-01,9.6338513307114626e-01,
-                                  4.6820097308511843e-01},
-                                 {8.8648089895117554e-01,5.7700130930627158e-01,
-                                  9.3476341058766588e-01,1.0248878011327789e-02,
-                                  2.8201473145904410e-01,8.0612074968814096e-01,
-                                  5.5309701727903893e-01}},
-                              
-                                {{8.6756477873593174e-01,1.0461287276261610e-02,
-                                  4.7324335928104888e-01,1.8350092081083047e-01,
-                                  4.5117253793514467e-01,3.4998273955367643e-01,
-                                  4.4804504910024956e-01},
-                                 {6.9786092863074212e-01,5.4631338498634674e-01,
-                                  1.4236082273368367e-01,4.7883705735017157e-01,
-                                  3.1760910046139090e-01,1.0617103470438483e-01,
-                                  7.2831815442082326e-01},
-                                 {6.0920954425582563e-01,8.0336207496309642e-01,
-                                  4.9287647276204505e-01,4.6084997957145801e-01,
-                                  8.5261183174351107e-01,7.6969969046559261e-01,
-                                  6.6172485619347809e-01},
-                                 {8.2871462663671547e-01,7.4709716652730052e-01,
-                                  7.1537903357822852e-01,1.1120474743747344e-01,
-                                  5.4899920142619840e-01,3.8513848274680595e-01,
-                                  9.6872516240964657e-01},
-                                 {7.6791490043635802e-01,4.3827794058508673e-01,
-                                  1.1224074400222006e-01,2.8518644262562654e-01,
-                                  7.4174781796094713e-03,8.1077607435161014e-02,
-                                  3.8596033477989433e-01},
-                                 {1.0654568708733259e-01,4.6122514810019377e-01,
-                                  8.3385256165801325e-01,5.2057334766670738e-01,
-                                  9.1751590135101757e-01,5.8189735442920476e-01,
-                                  5.8087878117740188e-02}},
-                              
-                                {{2.6142677499223277e-01,6.2595137557068725e-01,
-                                  1.6321635765675147e-01,7.9885004844071794e-02,
-                                  2.2406599397863680e-01,1.0037017250988178e-01,
-                                  6.5043850628525535e-01},
-                                 {2.2315507048713867e-01,4.5387462509381304e-02,
-                                  2.4527519178836643e-01,6.1811034502151874e-01,
-                                  2.3247694025662902e-01,5.0732146495764840e-01,
-                                  1.9479310450778287e-01},
-                                 {3.7830336996993330e-01,1.4925610433889480e-01,
-                                  1.4061076912818571e-01,3.5420642285329829e-01,
-                                  7.3151047370276756e-01,7.5269417981981157e-01,
-                                  7.4158595923026804e-01},
-                                 {4.5421609335397461e-01,7.6853916491815966e-01,
-                                  2.3693977837453228e-01,6.2432094402666283e-01,
-                                  9.7861975201830176e-01,8.2578779702388239e-01,
-                                  8.5093373069227352e-01},
-                                 {5.6609882145416113e-01,6.5124482170527143e-01,
-                                  1.4512242396706976e-01,6.5646717257694009e-01,
-                                  6.2171516783916669e-01,9.0697196404977276e-01,
-                                  4.3821208942756795e-01},
-                                 {5.2229384128438716e-01,6.1209403744546464e-01,
-                                  6.0119616032065615e-02,4.3652451361722122e-01,
-                                  4.4999567584937283e-02,8.1097005010564271e-01,
-                                  5.5616947552202134e-01}},
-                              
-                                {{6.8614971338615383e-02,5.7383364351729249e-01,
-                                  4.1376387364634859e-01,6.9171654565490126e-01,
-                                  4.6430763402383479e-01,2.8876416157669049e-01,
-                                  5.7388114339807728e-01},
-                                 {5.7669679484985537e-01,7.3811494955737633e-01,
-                                  3.6653978106114238e-01,6.8366804914383705e-01,
-                                  6.8677887773820112e-02,4.7546285100277164e-01,
-                                  9.0623381058926977e-01},
-                                 {3.4474759800583543e-01,7.3527889332193341e-03,
-                                  5.3506188226077100e-01,9.1756449676739626e-01,
-                                  9.7001306290217093e-01,4.0623680222085312e-01,
-                                  9.3991809600332477e-01},
-                                 {9.3742737453448188e-01,1.8247675091828397e-01,
-                                  6.8346727175951805e-01,9.5638031204920504e-01,
-                                  2.2154232643059346e-01,1.6489115325822179e-01,
-                                  5.4578578766430363e-01},
-                                 {5.2144296526632639e-01,8.6537837524548222e-01,
-                                  3.6271172745923619e-01,4.7618214850250906e-01,
-                                  4.6316081275469556e-01,1.0119370910990744e-01,
-                                  5.0927991252944560e-02},
-                                 {1.7690097108104919e-01,6.6118815401568376e-01,
-                                  6.9145869585866171e-01,8.2164382935401248e-01,
-                                  8.0307420495976833e-02,9.7102302224198855e-01,
-                                  7.1928488956981118e-02}}},
-                              
-                              
-                               {{{4.6589679387075666e-01,4.2421495999504233e-01,
-                                  1.5400746889724137e-01,1.5333879217682034e-02,
-                                  2.2366891822845680e-01,6.9182861245514971e-01,
-                                  1.4474708101076428e-02},
-                                 {5.0534934766883521e-01,3.0216381237133505e-01,
-                                  7.3160552535938894e-02,3.0867665887987406e-01,
-                                  4.3772699175800289e-03,8.4374643568690810e-01,
-                                  2.7989734130572874e-01},
-                                 {8.8736464372488388e-02,6.1089735698067649e-01,
-                                  4.8457284377848131e-02,6.0978870601512214e-01,
-                                  8.8549204792553404e-01,1.4935806286044229e-01,
-                                  9.6784392119713203e-01},
-                                 {3.8546207412540701e-01,6.3136247171359217e-01,
-                                  9.3985547062907682e-01,5.5655921609671533e-01,
-                                  7.1663368756040280e-01,1.8067559279263057e-01,
-                                  4.4965379631269031e-01},
-                                 {7.6692578778969178e-01,7.2319367491936759e-01,
-                                  4.0782712807812138e-01,9.1867032684276406e-01,
-                                  9.2594241129564048e-01,7.2637945673350834e-01,
-                                  2.2351056361449484e-01},
-                                 {4.1107417524022716e-01,7.8633378024207168e-01,
-                                  8.0696199839337512e-02,6.6728478791451440e-01,
-                                  6.9194106825517687e-01,1.6927071416996842e-01,
-                                  4.6682304907698413e-01}},
-                              
-                                {{9.2342438149815997e-01,8.5713068335788734e-01,
-                                  5.1079581046573730e-02,6.3763727127473924e-01,
-                                  7.1147511074108194e-01,5.3046036308483191e-01,
-                                  4.5788035274950745e-01},
-                                 {5.6679622260914986e-01,4.2438315287120165e-01,
-                                  2.5480972774117872e-02,8.7584972635535951e-01,
-                                  8.5415970510497297e-01,6.2153511183834320e-01,
-                                  5.7271448676438597e-01},
-                                 {6.5184523733907884e-01,3.8399276948250960e-02,
-                                  6.6497036617862659e-02,7.5467226610921623e-01,
-                                  6.5953668661732823e-01,4.3928659935104608e-01,
-                                  9.6942070310996276e-01},
-                                 {9.9700257177333185e-01,8.0026405778607101e-01,
-                                  8.2024864252276264e-01,4.3381361500015159e-01,
-                                  8.0651755731361296e-02,4.4618519626411635e-01,
-                                  9.1157163429060828e-01},
-                                 {7.4503772872314278e-01,1.1035186977038269e-01,
-                                  8.5590911071280884e-01,2.2107076451141539e-01,
-                                  9.0903930832990321e-01,4.6157661185830778e-01,
-                                  6.2688828045496348e-01},
-                                 {7.5014811395275305e-01,4.9791586859622028e-01,
-                                  6.5607994439788753e-01,5.1874079927810324e-01,
-                                  8.7720051548225508e-01,7.3963802652148203e-01,
-                                  1.4429800953172855e-01}},
-                              
-                                {{2.5119381870910940e-01,3.3075455565904854e-01,
-                                  8.8893238097432159e-01,1.3977049622169613e-01,
-                                  2.5211457154096961e-01,6.3408129261011281e-01,
-                                  4.3020205062473127e-01},
-                                 {3.4256608712061032e-01,3.6641696508622101e-01,
-                                  7.1932872219691213e-01,7.0107307972429611e-01,
-                                  4.3098759665449959e-01,9.2214638098887647e-01,
-                                  5.8843636008682343e-01},
-                                 {4.9713569621784814e-01,4.2785281080577375e-01,
-                                  3.6058147905827342e-01,4.4692876015458138e-01,
-                                  2.5496744648412184e-01,2.0035623021640769e-01,
-                                  5.2243138466537731e-01},
-                                 {4.5791503675119327e-01,8.5367446688446691e-01,
-                                  4.5852811734789278e-02,9.1485127978572223e-01,
-                                  3.5009701119579228e-01,1.4326691325413754e-02,
-                                  9.2180391083421709e-01},
-                                 {2.7576287506283381e-01,9.3730750057082202e-01,
-                                  6.6137274016458181e-01,7.5552313787706082e-01,
-                                  2.5875262615398587e-01,1.4402749350244148e-01,
-                                  4.3376251191339033e-01},
-                                 {4.1487001773947840e-01,5.9505681506703501e-01,
-                                  9.5041579375246976e-01,2.6340623226034943e-01,
-                                  2.4377994709040085e-01,9.8380280191747471e-01,
-                                  4.1985922662713326e-01}},
-                              
-                                {{6.9473859441832753e-01,3.2185307973019761e-01,
-                                  2.1121080376731549e-02,6.9842070352263941e-01,
-                                  1.2935254684953590e-01,3.0338742453928380e-01,
-                                  5.5348448934810057e-01},
-                                 {4.6774342813406167e-01,9.4630379585128155e-01,
-                                  3.5070686264325768e-01,7.5559742200637103e-03,
-                                  3.7034814406422922e-01,6.8734037363928135e-02,
-                                  4.4614906429986112e-03},
-                                 {6.4037157686123680e-01,1.9890167735574382e-01,
-                                  4.3037194668648027e-01,2.3542951320199179e-01,
-                                  9.7305894001076620e-01,4.4532205907453215e-01,
-                                  3.3559068631397637e-01},
-                                 {1.9813318760750354e-01,6.8163460172651336e-01,
-                                  7.3101522485117043e-01,6.7814568917449614e-01,
-                                  6.7308628141664628e-01,4.6345171669091079e-01,
-                                  6.8281411335488895e-01},
-                                 {8.3265651181859313e-01,8.0358631614797227e-01,
-                                  2.6305853589954531e-01,6.5811251290519568e-01,
-                                  4.1160933544335154e-01,6.8526976058744360e-02,
-                                  8.5389319588920543e-01},
-                                 {6.6993018405068183e-01,1.2146536232864380e-01,
-                                  7.2148717677229868e-01,1.2810609076429624e-01,
-                                  8.1091067134993167e-01,5.5330981814980118e-01,
-                                  3.3135774548078933e-01}},
-                              
-                                {{7.2315080385881858e-01,4.8044968004753541e-01,
-                                  1.3660891483576798e-01,8.2793086377827041e-01,
-                                  9.0124686844422752e-01,9.4336336067364734e-01,
-                                  2.0763541622959458e-01},
-                                 {7.3377518185578905e-01,8.4383524139684085e-01,
-                                  8.7036175082877332e-01,1.9015795928995727e-01,
-                                  5.4637144015102035e-01,9.4147321787558325e-01,
-                                  4.6572321911077741e-01},
-                                 {7.7828425398397294e-01,1.2114648085548352e-01,
-                                  8.2904743466375697e-01,9.9124749225818343e-01,
-                                  6.5950196774898795e-01,3.5146942177979923e-01,
-                                  2.1860739063236423e-01},
-                                 {3.3321865199407485e-01,8.6382827727360412e-01,
-                                  3.4669137946784545e-01,9.1588425878502555e-01,
-                                  2.5534249843555079e-01,9.6229001227263089e-01,
-                                  1.9920905501980268e-01},
-                                 {2.5752920517649625e-01,3.9831414522587127e-01,
-                                  2.5268248944646388e-01,1.9307404483124613e-01,
-                                  1.8945356440864147e-02,9.9479632354426373e-01,
-                                  7.3952284812774594e-01},
-                                 {4.0020653253757366e-01,9.8759229794959846e-01,
-                                  3.5458924688222959e-01,8.3121111795844160e-01,
-                                  4.0190078293173570e-01,8.6735210241975957e-01,
-                                  2.2938587860922532e-01}}}};
-        // py_av
-        xarray<double> py_av = {{0.5921386552334917,0.4321741057229821,0.5309484765528958,
-                                 0.5543468254414977,0.5636262291912509,0.5360889820737298,
-                                 0.513075014658361 },
-                                {0.4281912773927053,0.5500943215388141,0.4777100745332054,
-                                 0.35976893497379  ,0.4315359163057602,0.5410702046010559,
-                                 0.4396169811497922},
-                                {0.5335131548353876,0.5958173241874269,0.606371857251771 ,
-                                 0.573940429409235 ,0.5249093924855825,0.4334083464307479,
-                                 0.5507076307615592},
-                                {0.5112203661461623,0.706455978750368 ,0.5396800431572782,
-                                 0.5201545453946113,0.4937432302106536,0.6073812173873598,
-                                 0.5136156631525846},
-                                {0.4336650740758257,0.677050599068886 ,0.5780661625094548,
-                                 0.5206220708890781,0.504281642612738 ,0.5711968690718279,
-                                 0.34692581600678  },
-                                {0.5280787632835885,0.5194051179184589,0.3020894071512895,
-                                 0.6298433441337232,0.4384433989596566,0.4937091559457326,
-                                 0.5375951169242822}};
-
-        auto av = xt::average(py_a, py_w, {0,1});
-
-        EXPECT_TRUE(xt::allclose(av, py_av));
-    }
-}
-
diff --git a/test/test_extended_xmath_interp.cpp b/test/test_extended_xmath_interp.cpp
index ee136ddf2..88e01a46d 100644
--- a/test/test_extended_xmath_interp.cpp
+++ b/test/test_extended_xmath_interp.cpp
@@ -1,19 +1,22 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
-
+ * 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. *
+ ****************************************************************************/
 // This file is generated from test/files/cppy_source/test_extended_xmath_interp.cppy by preprocess.py!
+// Warning: This file should not be modified directly! Instead, modify the `*.cppy` file.
+
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xmath.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -28,61 +31,93 @@ namespace xt
     TEST(xtest_extended_xmath, interp)
     {
         // py_xp
-        xarray<double> py_xp = {-0.4794155057041976,-0.4419163878318005,-0.3440054796637974,
-                                -0.3439813595575635,-0.3181750327928994,-0.3165954901465662,
-                                -0.2876608893217238,-0.2087708598019581,-0.1957577570404623,
-                                -0.1254598811526375,-0.0680549813578842, 0.0247564316322378,
-                                 0.0986584841970366, 0.1011150117432088, 0.2080725777960455,
-                                 0.2319939418114051, 0.3324426408004217, 0.3661761457749352,
-                                 0.4507143064099162, 0.4699098521619943};
+        xarray<double> py_xp = {-0.4794155057041976, -0.4419163878318005, -0.3440054796637974,
+                                -0.3439813595575635, -0.3181750327928994, -0.3165954901465662,
+                                -0.2876608893217238, -0.2087708598019581, -0.1957577570404623,
+                                -0.1254598811526375, -0.0680549813578842, 0.0247564316322378,
+                                0.0986584841970366,  0.1011150117432088,  0.2080725777960455,
+                                0.2319939418114051,  0.3324426408004217,  0.3661761457749352,
+                                0.4507143064099162,  0.4699098521619943};
         // py_fp
-        xarray<double> py_fp = { 0.1118528947223795,-0.3605061393479582,-0.2078553514647818,
-                                -0.1336381567063083,-0.0439300157829641, 0.2851759613930136,
-                                -0.3003262178416403, 0.0142344384136116, 0.0924145688620425,
-                                -0.4535495872800023, 0.1075448519014384,-0.3294758763127085,
-                                -0.4349484070147205, 0.4488855372533332, 0.4656320330745594,
-                                 0.3083973481164611,-0.1953862308266293,-0.4023278859936161,
-                                 0.1842330265121569,-0.0598475062603987};
+        xarray<double> py_fp = {0.1118528947223795,  -0.3605061393479582, -0.2078553514647818,
+                                -0.1336381567063083, -0.0439300157829641, 0.2851759613930136,
+                                -0.3003262178416403, 0.0142344384136116,  0.0924145688620425,
+                                -0.4535495872800023, 0.1075448519014384,  -0.3294758763127085,
+                                -0.4349484070147205, 0.4488855372533332,  0.4656320330745594,
+                                0.3083973481164611,  -0.1953862308266293, -0.4023278859936161,
+                                0.1842330265121569,  -0.0598475062603987};
         // py_x
-        xarray<double> py_x = {-1.                ,-0.9591836734693877,-0.9183673469387755,
-                               -0.8775510204081632,-0.8367346938775511,-0.7959183673469388,
-                               -0.7551020408163265,-0.7142857142857143,-0.6734693877551021,
-                               -0.6326530612244898,-0.5918367346938775,-0.5510204081632654,
-                               -0.5102040816326531,-0.4693877551020409,-0.4285714285714286,
-                               -0.3877551020408164,-0.3469387755102041,-0.3061224489795918,
-                               -0.2653061224489797,-0.2244897959183674,-0.1836734693877552,
-                               -0.1428571428571429,-0.1020408163265307,-0.0612244897959184,
-                               -0.0204081632653061, 0.0204081632653061, 0.0612244897959182,
-                                0.1020408163265305, 0.1428571428571428, 0.1836734693877551,
-                                0.2244897959183672, 0.2653061224489794, 0.3061224489795917,
-                                0.346938775510204 , 0.3877551020408163, 0.4285714285714284,
-                                0.4693877551020407, 0.510204081632653 , 0.5510204081632653,
-                                0.5918367346938773, 0.6326530612244896, 0.6734693877551019,
-                                0.7142857142857142, 0.7551020408163265, 0.7959183673469385,
-                                0.8367346938775508, 0.8775510204081631, 0.9183673469387754,
-                                0.9591836734693877, 1.                };
+        xarray<double> py_x = {
+            -1.,
+            -0.9591836734693877,
+            -0.9183673469387755,
+            -0.8775510204081632,
+            -0.8367346938775511,
+            -0.7959183673469388,
+            -0.7551020408163265,
+            -0.7142857142857143,
+            -0.6734693877551021,
+            -0.6326530612244898,
+            -0.5918367346938775,
+            -0.5510204081632654,
+            -0.5102040816326531,
+            -0.4693877551020409,
+            -0.4285714285714286,
+            -0.3877551020408164,
+            -0.3469387755102041,
+            -0.3061224489795918,
+            -0.2653061224489797,
+            -0.2244897959183674,
+            -0.1836734693877552,
+            -0.1428571428571429,
+            -0.1020408163265307,
+            -0.0612244897959184,
+            -0.0204081632653061,
+            0.0204081632653061,
+            0.0612244897959182,
+            0.1020408163265305,
+            0.1428571428571428,
+            0.1836734693877551,
+            0.2244897959183672,
+            0.2653061224489794,
+            0.3061224489795917,
+            0.346938775510204,
+            0.3877551020408163,
+            0.4285714285714284,
+            0.4693877551020407,
+            0.510204081632653,
+            0.5510204081632653,
+            0.5918367346938773,
+            0.6326530612244896,
+            0.6734693877551019,
+            0.7142857142857142,
+            0.7551020408163265,
+            0.7959183673469385,
+            0.8367346938775508,
+            0.8775510204081631,
+            0.9183673469387754,
+            0.9591836734693877,
+            1.
+        };
         // py_f
-        xarray<double> py_f = { 0.1118528947223795, 0.1118528947223795, 0.1118528947223795,
-                                0.1118528947223795, 0.1118528947223795, 0.1118528947223795,
-                                0.1118528947223795, 0.1118528947223795, 0.1118528947223795,
-                                0.1118528947223795, 0.1118528947223795, 0.1118528947223795,
-                                0.1118528947223795,-0.0144620389902249,-0.3397003008210678,
-                               -0.276064445327787 ,-0.2124285898345059, 0.0732501614278388,
-                               -0.2111903640369242,-0.0484421620454266,-0.0014373125435324,
-                               -0.3184348176553962,-0.2246439173504261, 0.0753821436708398,
-                               -0.1168095294085587,-0.3090012024879573,-0.3815228526932218,
-                                0.4490304917727565, 0.4554211611466747, 0.4618118305205929,
-                                0.3577219608188899, 0.1413257010677429,-0.063381729350545 ,
-                               -0.2843142598776403,-0.2526041141115967, 0.0305965322604367,
-                               -0.0532087927693443,-0.0598475062603987,-0.0598475062603987,
-                               -0.0598475062603987,-0.0598475062603987,-0.0598475062603987,
-                               -0.0598475062603987,-0.0598475062603987,-0.0598475062603987,
-                               -0.0598475062603987,-0.0598475062603987,-0.0598475062603987,
-                               -0.0598475062603987,-0.0598475062603987};
+        xarray<double> py_f = {
+            0.1118528947223795,  0.1118528947223795,  0.1118528947223795,  0.1118528947223795,
+            0.1118528947223795,  0.1118528947223795,  0.1118528947223795,  0.1118528947223795,
+            0.1118528947223795,  0.1118528947223795,  0.1118528947223795,  0.1118528947223795,
+            0.1118528947223795,  -0.0144620389902249, -0.3397003008210678, -0.276064445327787,
+            -0.2124285898345059, 0.0732501614278388,  -0.2111903640369242, -0.0484421620454266,
+            -0.0014373125435324, -0.3184348176553962, -0.2246439173504261, 0.0753821436708398,
+            -0.1168095294085587, -0.3090012024879573, -0.3815228526932218, 0.4490304917727565,
+            0.4554211611466747,  0.4618118305205929,  0.3577219608188899,  0.1413257010677429,
+            -0.063381729350545,  -0.2843142598776403, -0.2526041141115967, 0.0305965322604367,
+            -0.0532087927693443, -0.0598475062603987, -0.0598475062603987, -0.0598475062603987,
+            -0.0598475062603987, -0.0598475062603987, -0.0598475062603987, -0.0598475062603987,
+            -0.0598475062603987, -0.0598475062603987, -0.0598475062603987, -0.0598475062603987,
+            -0.0598475062603987, -0.0598475062603987
+        };
 
         auto f = xt::interp(py_x, py_xp, py_fp);
 
         EXPECT_TRUE(xt::allclose(f, py_f));
     }
 }
-
diff --git a/test/test_extended_xmath_reducers.cpp b/test/test_extended_xmath_reducers.cpp
index 3dcb118a2..da093446c 100644
--- a/test/test_extended_xmath_reducers.cpp
+++ b/test/test_extended_xmath_reducers.cpp
@@ -1,18 +1,30 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+// This file is generated from test/files/cppy_source/test_extended_xmath_reducers.cppy by preprocess.py!
+// Warning: This file should not be modified directly! Instead, modify the `*.cppy` file.
+
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xmath.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
 
-// This file is generated from test/files/cppy_source/test_extended_xmath_reducers.cppy by preprocess.py!
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     using namespace xt::placeholders;
 
+    // Temporary disabling for TBB and OPENMP due to a potential
+    // race condition that must be identified
+
     /*py
     a  = np.random.random(4*5*6*7).reshape(4,5,6,7)
     w  = np.random.random(4*5*6*7).reshape(4,5,6,7)
@@ -21,793 +33,1782 @@ namespace xt
     TEST(xtest_extended_xmath, average)
     {
         // py_a
-        xarray<double> py_a = {{{{0.3745401188473625,0.9507143064099162,0.7319939418114051,
-                                  0.5986584841970366,0.1560186404424365,0.1559945203362026,
-                                  0.0580836121681995},
-                                 {0.8661761457749352,0.6011150117432088,0.7080725777960455,
-                                  0.0205844942958024,0.9699098521619943,0.8324426408004217,
-                                  0.2123391106782762},
-                                 {0.1818249672071006,0.1834045098534338,0.3042422429595377,
-                                  0.5247564316322378,0.4319450186421158,0.2912291401980419,
-                                  0.6118528947223795},
-                                 {0.1394938606520418,0.2921446485352182,0.3663618432936917,
-                                  0.4560699842170359,0.7851759613930136,0.1996737821583597,
-                                  0.5142344384136116},
-                                 {0.5924145688620425,0.0464504127199977,0.6075448519014384,
-                                  0.1705241236872915,0.0650515929852795,0.9488855372533332,
-                                  0.9656320330745594},
-                                 {0.8083973481164611,0.3046137691733707,0.0976721140063839,
-                                  0.6842330265121569,0.4401524937396013,0.1220382348447788,
-                                  0.4951769101112702}},
-                              
-                                {{0.0343885211152184,0.9093204020787821,0.2587799816000169,
-                                  0.662522284353982 ,0.311711076089411 ,0.5200680211778108,
-                                  0.5467102793432796},
-                                 {0.184854455525527 ,0.9695846277645586,0.7751328233611146,
-                                  0.9394989415641891,0.8948273504276488,0.5978999788110851,
-                                  0.9218742350231168},
-                                 {0.0884925020519195,0.1959828624191452,0.0452272889105381,
-                                  0.3253303307632643,0.388677289689482 ,0.2713490317738959,
-                                  0.8287375091519293},
-                                 {0.3567533266935893,0.2809345096873808,0.5426960831582485,
-                                  0.1409242249747626,0.8021969807540397,0.0745506436797708,
-                                  0.9868869366005173},
-                                 {0.7722447692966574,0.1987156815341724,0.0055221171236024,
-                                  0.8154614284548342,0.7068573438476171,0.7290071680409873,
-                                  0.7712703466859457},
-                                 {0.0740446517340904,0.3584657285442726,0.1158690595251297,
-                                  0.8631034258755935,0.6232981268275579,0.3308980248526492,
-                                  0.0635583502860236}},
-                              
-                                {{0.3109823217156622,0.325183322026747 ,0.7296061783380641,
-                                  0.6375574713552131,0.8872127425763265,0.4722149251619493,
-                                  0.1195942459383017},
-                                 {0.713244787222995 ,0.7607850486168974,0.5612771975694962,
-                                  0.770967179954561 ,0.4937955963643907,0.5227328293819941,
-                                  0.4275410183585496},
-                                 {0.0254191267440952,0.1078914269933045,0.0314291856867343,
-                                  0.6364104112637804,0.3143559810763267,0.5085706911647028,
-                                  0.907566473926093 },
-                                 {0.2492922291488749,0.4103829230356297,0.7555511385430487,
-                                  0.2287981654916225,0.076979909828793 ,0.289751452913768 ,
-                                  0.1612212872540044},
-                                 {0.9296976523425731,0.808120379564417 ,0.6334037565104235,
-                                  0.8714605901877177,0.8036720768991145,0.1865700588860358,
-                                  0.8925589984899778},
-                                 {0.5393422419156507,0.8074401551640625,0.8960912999234932,
-                                  0.3180034749718639,0.1100519245276768,0.2279351625419417,
-                                  0.4271077886262563}},
-                              
-                                {{0.8180147659224931,0.8607305832563434,0.0069521305311907,
-                                  0.5107473025775657,0.417411003148779 ,0.2221078104707302,
-                                  0.1198653673336828},
-                                 {0.337615171403628 ,0.9429097039125192,0.3232029320207552,
-                                  0.5187906217433661,0.7030189588951778,0.363629602379294 ,
-                                  0.9717820827209607},
-                                 {0.9624472949421112,0.2517822958253642,0.4972485058923855,
-                                  0.3008783098167697,0.2848404943774676,0.0368869473545328,
-                                  0.6095643339798968},
-                                 {0.5026790232288615,0.0514787512499894,0.2786464642366114,
-                                  0.9082658859666537,0.2395618906669724,0.1448948720912231,
-                                  0.489452760277563 },
-                                 {0.9856504541106007,0.2420552715115004,0.6721355474058786,
-                                  0.7616196153287176,0.2376375439923997,0.7282163486118596,
-                                  0.3677831327192532},
-                                 {0.6323058305935795,0.6335297107608947,0.5357746840747585,
-                                  0.0902897700544083,0.835302495589238 ,0.3207800649717358,
-                                  0.1865185103998542}},
-                              
-                                {{0.0407751415547639,0.5908929431882418,0.6775643618422824,
-                                  0.0165878289278562,0.512093058299281 ,0.226495775197938 ,
-                                  0.6451727904094499},
-                                 {0.1743664290049914,0.690937738102466 ,0.3867353463005374,
-                                  0.9367299887367345,0.1375209441459933,0.3410663510502585,
-                                  0.1134735212405891},
-                                 {0.9246936182785628,0.877339353380981 ,0.2579416277151556,
-                                  0.659984046034179 ,0.8172222002012158,0.5552008115994623,
-                                  0.5296505783560065},
-                                 {0.2418522909004517,0.0931027678058992,0.8972157579533268,
-                                  0.9004180571633305,0.6331014572732679,0.3390297910487007,
-                                  0.3492095746126609},
-                                 {0.7259556788702394,0.8971102599525771,0.8870864242651173,
-                                  0.7798755458576239,0.6420316461542878,0.0841399649950488,
-                                  0.1616287140946138},
-                                 {0.8985541885270792,0.6064290596595899,0.0091970516166296,
-                                  0.1014715428660321,0.6635017691080558,0.0050615838462187,
-                                  0.1608080514174987}}},
-                              
-                              
-                               {{{0.5487337893665861,0.6918951976926933,0.6519612595026005,
-                                  0.2242693094605598,0.7121792213475359,0.2372490874968001,
-                                  0.3253996981592677},
-                                 {0.7464914051180241,0.6496328990472147,0.8492234104941779,
-                                  0.6576128923003434,0.5683086033354716,0.0936747678280925,
-                                  0.3677158030594335},
-                                 {0.2652023676817254,0.2439896433790836,0.9730105547524456,
-                                  0.3930977246667604,0.8920465551771133,0.6311386259972629,
-                                  0.7948113035416484},
-                                 {0.5026370931051921,0.5769038846263591,0.4925176938188639,
-                                  0.1952429877980445,0.7224521152615053,0.2807723624408558,
-                                  0.0243159664314538},
-                                 {0.6454722959071678,0.1771106794070489,0.9404585843529143,
-                                  0.9539285770025874,0.9148643902204485,0.3701587002554444,
-                                  0.0154566165288674},
-                                 {0.9283185625877254,0.4281841483173143,0.9666548190436696,
-                                  0.9636199770892528,0.8530094554673601,0.2944488920695857,
-                                  0.3850977286019253}},
-                              
-                                {{0.8511366715168569,0.3169220051562777,0.1694927466860925,
-                                  0.5568012624583502,0.936154774160781 ,0.696029796674973 ,
-                                  0.570061170089365 },
-                                 {0.0971764937707685,0.6150072266991697,0.9900538501042633,
-                                  0.140084015236524 ,0.5183296523637367,0.8773730719279554,
-                                  0.7407686177542044},
-                                 {0.697015740995268 ,0.7024840839871093,0.3594911512197552,
-                                  0.2935918442644934,0.8093611554785136,0.8101133946791808,
-                                  0.8670723185801037},
-                                 {0.9132405525564713,0.5113423988609378,0.5015162946871996,
-                                  0.7982951789667752,0.6499639307777652,0.7019668772577033,
-                                  0.795792669436101 },
-                                 {0.8900053418175663,0.3379951568515358,0.375582952639944 ,
-                                  0.093981939840869 ,0.578280140996174 ,0.0359422737967421,
-                                  0.4655980181324602},
-                                 {0.5426446347075766,0.2865412521282844,0.5908332605690108,
-                                  0.0305002499390494,0.0373481887492144,0.8226005606596583,
-                                  0.3601906414112629}},
-                              
-                                {{0.1270605126518848,0.5222432600548044,0.7699935530986108,
-                                  0.2158210274968432,0.6228904758190003,0.085347464993768 ,
-                                  0.0516817211686077},
-                                 {0.531354631568148 ,0.5406351216101065,0.6374299014982066,
-                                  0.7260913337226615,0.9758520794625346,0.5163003483011953,
-                                  0.322956472941246 },
-                                 {0.7951861947687037,0.2708322512620742,0.4389714207056361,
-                                  0.078456381342266 ,0.0253507434154575,0.9626484146779251,
-                                  0.8359801205122058},
-                                 {0.695974206093698 ,0.4089529444142699,0.1732943200708458,
-                                  0.156437042671086 ,0.2502428981645953,0.5492266647061205,
-                                  0.7145959227000623},
-                                 {0.6601973767177313,0.2799338969459428,0.9548652806631941,
-                                  0.7378969166957685,0.5543540525114007,0.6117207462343522,
-                                  0.4196000624277899},
-                                 {0.2477309895011575,0.3559726786512616,0.7578461104643691,
-                                  0.0143934886297559,0.1160726405069162,0.0460026420217527,
-                                  0.0407288023189701}},
-                              
-                                {{0.8554605840110072,0.7036578593800237,0.4741738290873252,
-                                  0.0978341606510015,0.4916158751168324,0.4734717707805657,
-                                  0.1732018699100152},
-                                 {0.433851649237973 ,0.3985047343973734,0.6158500980522165,
-                                  0.6350936508676438,0.0453040097720445,0.3746126146264712,
-                                  0.6258599157142364},
-                                 {0.5031362585800877,0.8564898411883223,0.658693631618945 ,
-                                  0.1629344270814297,0.0705687474004298,0.6424192782063156,
-                                  0.0265113105416218},
-                                 {0.5857755812734633,0.9402302414249576,0.575474177875879 ,
-                                  0.3881699262065219,0.6432882184423532,0.4582528904915166,
-                                  0.5456167893159349},
-                                 {0.9414648087765252,0.3861026378007743,0.9611905638239142,
-                                  0.9053506419560637,0.1957911347892964,0.0693613008751655,
-                                  0.1007780013774267},
-                                 {0.0182218256515497,0.0944429607559284,0.6830067734163568,
-                                  0.071188648460229 ,0.3189756302937613,0.8448753109694546,
-                                  0.0232719357358259}},
-                              
-                                {{0.8144684825889358,0.2818547747733999,0.1181648276216563,
-                                  0.6967371653641506,0.628942846779884 ,0.877472013527053 ,
-                                  0.7350710438038858},
-                                 {0.8034809303848486,0.2820345725713065,0.1774395437797228,
-                                  0.7506147516408583,0.806834739267264 ,0.9905051420006733,
-                                  0.4126176769114265},
-                                 {0.3720180857927832,0.7764129607419968,0.3408035402530178,
-                                  0.9307573256035647,0.8584127518430118,0.4289940273750183,
-                                  0.7508710677914974},
-                                 {0.7545428740846823,0.1031238688359326,0.9025529066795667,
-                                  0.5052523724478571,0.8264574661077416,0.3200496010306118,
-                                  0.8955232284962005},
-                                 {0.3892016787341631,0.0108376514802984,0.9053819764192637,
-                                  0.0912866767861336,0.3193136375904149,0.9500619670508049,
-                                  0.9506071469375561},
-                                 {0.5734378881232861,0.6318372121697993,0.4484455219783198,
-                                  0.2932107716980645,0.328664545369916 ,0.6725184560770384,
-                                  0.75237452943768  }}},
-                              
-                              
-                               {{{0.7915790437258485,0.7896181427945539,0.0912061030486904,
-                                  0.4944203047025815,0.0575587600166443,0.5495288823237355,
-                                  0.441530501373377 },
-                                 {0.8877041827582998,0.3509150125520787,0.1170670164276059,
-                                  0.1429916820528359,0.7615106317174722,0.6182180633162611,
-                                  0.1011226761227902},
-                                 {0.0841068061149974,0.70096913145912  ,0.0727630063641935,
-                                  0.8218600592903562,0.7062422271564962,0.0813487806418998,
-                                  0.0848377140851919},
-                                 {0.9866395785011755,0.3742707957561203,0.3706421470668909,
-                                  0.8127995672575026,0.9472485773838587,0.9860010638228709,
-                                  0.7533781852589416},
-                                 {0.3762595855309158,0.0835007166986688,0.7771469159274368,
-                                  0.558404249735805 ,0.4242220092469763,0.906354385094736 ,
-                                  0.1111974823061513},
-                                 {0.4926251042908592,0.0113536447674191,0.4686606419941263,
-                                  0.0563032756818374,0.1188179162680719,0.1175262467771049,
-                                  0.6492103021160636}},
-                              
-                                {{0.7460448792654233,0.5833687650971596,0.9621725484745419,
-                                  0.3748705795237041,0.2857120862818607,0.8685991281894603,
-                                  0.2235958385194526},
-                                 {0.9632225394406113,0.0121544746898163,0.969878826707639 ,
-                                  0.0431599119505761,0.8911431136980711,0.5277011090862999,
-                                  0.9929647961193003},
-                                 {0.0737965647353989,0.5538542844013208,0.969302535619099 ,
-                                  0.5230978441701488,0.6293986381352625,0.6957486889846172,
-                                  0.4545410647677732},
-                                 {0.6275580800840634,0.5843143119231002,0.901158010490989 ,
-                                  0.0454463803414579,0.2809631895922303,0.9504114840765587,
-                                  0.8902637838909163},
-                                 {0.4556567527857129,0.6201325978015367,0.2773811829811327,
-                                  0.1881211597237613,0.4636984049399822,0.3533522280260528,
-                                  0.5836561118508721},
-                                 {0.0777346369649848,0.9743948076661665,0.9862107444796029,
-                                  0.6981617140197451,0.5360963663441204,0.3095276162863277,
-                                  0.8137950197069487}},
-                              
-                                {{0.6847311725538793,0.1626169393448913,0.9109271844938425,
-                                  0.822537242923169 ,0.949799913291924 ,0.72571950838836  ,
-                                  0.6134151959357899},
-                                 {0.4182430362906189,0.9327284833540133,0.8660638895004084,
-                                  0.0452186701061894,0.026366974497252 ,0.3764633668780496,
-                                  0.8105533307818329},
-                                 {0.9872761293149445,0.1504168911035282,0.5941307153521351,
-                                  0.3808908566310215,0.9699143978146032,0.8421189231357087,
-                                  0.8383287047111379},
-                                 {0.4686931597949703,0.4148195023376652,0.2734070719307062,
-                                  0.0563754966509271,0.8647223762550532,0.8129010091300776,
-                                  0.9997176732861306},
-                                 {0.9966368370739054,0.5554317056026274,0.7689874151805105,
-                                  0.944765729882428 ,0.8496473906774115,0.2473481017431977,
-                                  0.4505441353100935},
-                                 {0.129159415151495 ,0.9540510272587224,0.60617463445088  ,
-                                  0.2286428055034627,0.6717006844058567,0.6181282404578958,
-                                  0.3581627180328405}},
-                              
-                                {{0.113557592199629 ,0.6715731955927996,0.5203077009037933,
-                                  0.7723183917356393,0.5201635011119934,0.8521815003185401,
-                                  0.5519068387744855},
-                                 {0.5609379715353863,0.876653602658345 ,0.403482866212397 ,
-                                  0.1340152284506407,0.028782676313339 ,0.755137255673619 ,
-                                  0.6203095513534647},
-                                 {0.7040797680992236,0.2129641615089107,0.1363714755867698,
-                                  0.0145446656678819,0.350587558806597 ,0.5899176868546331,
-                                  0.3922440450997323},
-                                 {0.4374749220237291,0.9041586944937484,0.3482554670233003,
-                                  0.5139894891598108,0.7836530127411431,0.3965427823212702,
-                                  0.6220867002278735},
-                                 {0.8623637087467452,0.9495206236576421,0.1470734809290379,
-                                  0.9265876251614944,0.4921162930795382,0.2582443882989583,
-                                  0.4591357562382613},
-                                 {0.980032575285477 ,0.4926180939928696,0.3287516102875082,
-                                  0.6334008543167258,0.2401456187781931,0.0758633281086639,
-                                  0.1288797219106492}},
-                              
-                                {{0.1280458389577724,0.1519026935122944,0.1388271726494101,
-                                  0.6408747448032146,0.1818800843991448,0.3456672833238632,
-                                  0.8967884099060118},
-                                 {0.4739616402628724,0.6675577385210272,0.1723198712016298,
-                                  0.1922890188086708,0.0408686162664789,0.1689350630721645,
-                                  0.2785903390319586},
-                                 {0.1770104842767468,0.0887025337570556,0.1206358711006008,
-                                  0.4607787680327258,0.2063337184057925,0.3642698610480755,
-                                  0.5034172708548569},
-                                 {0.6903948286293653,0.0393121398410989,0.7994103989090426,
-                                  0.6279003894909078,0.0817590319488719,0.8735786241067772,
-                                  0.9208724005318132},
-                                 {0.0610779598548638,0.2768776481472037,0.8062012797930613,
-                                  0.7482596903836584,0.1845210193563773,0.2093493233367103,
-                                  0.370472102791382 },
-                                 {0.4845229851910213,0.618254771530296 ,0.3689136395697724,
-                                  0.4625347161331479,0.7474709381337565,0.0366832028905979,
-                                  0.2524369443440208}}},
-                              
-                              
-                               {{{0.7133495858845524,0.8952068376871993,0.5116774421156661,
-                                  0.5321134852653157,0.1071720113397761,0.4474123668234546,
-                                  0.5326172664550232},
-                                 {0.2424705036347297,0.269243230949381 ,0.3772841631046226,
-                                  0.0200711977777264,0.3220791655831783,0.2114480069965446,
-                                  0.3274973521779146},
-                                 {0.1197621318192512,0.890527280739895 ,0.5935924535540487,
-                                  0.6791023191444896,0.7891712386073383,0.4984421989290573,
-                                  0.0869202880874237},
-                                 {0.5371065418185478,0.5868411180208791,0.74543947418433  ,
-                                  0.4316595462296794,0.1275803027955638,0.2837759057987245,
-                                  0.3630822963986351},
-                                 {0.6459172413316012,0.5707783046689119,0.3560967258978462,
-                                  0.9865152487929797,0.6057748193568872,0.2372267917359945,
-                                  0.1017824726204037},
-                                 {0.152859139184332 ,0.2459577283845081,0.1606813732595557,
-                                  0.1865670240513058,0.2850951686938471,0.1733735952947548,
-                                  0.8967654246264252}},
-                              
-                                {{0.0802337456616422,0.5245113895702547,0.4103968269896615,
-                                  0.9823786169086064,0.1120389021680523,0.3978555990457416,
-                                  0.9694704332753689},
-                                 {0.8655071258939803,0.8170720709492799,0.2579028270449398,
-                                  0.1708875873900658,0.668643219924431 ,0.9293759891275858,
-                                  0.5567628930139298},
-                                 {0.5716126894698998,0.2799790936602842,0.7694929331919369,
-                                  0.1870437485575234,0.3236792364042437,0.4254364386164168,
-                                  0.507610378684455 },
-                                 {0.2424097324150802,0.1148368247392035,0.6106200424416326,
-                                  0.2886305532402558,0.5812382214226123,0.1543627152742023,
-                                  0.4811401018548175},
-                                 {0.5325894325515859,0.0518235368224269,0.3366042781939206,
-                                  0.1344146769389742,0.0633749704727677,0.9899602323899452,
-                                  0.322353844974723 },
-                                 {0.8098744458546349,0.2546406547637639,0.6815027222239293,
-                                  0.7602278598896866,0.5956387406078443,0.4715761885501584,
-                                  0.4118409141472685}},
-                              
-                                {{0.3488682665429953,0.9295291442478258,0.8306194077877291,
-                                  0.9650269106665126,0.1242972234855447,0.7308674752036443,
-                                  0.9383404568210378},
-                                 {0.1812330661656602,0.0664962673667775,0.741120649290059 ,
-                                  0.5744731131799119,0.8418287767582721,0.1397723766262895,
-                                  0.7952673118598902},
-                                 {0.2016273200477445,0.1636559428657045,0.1642657979309929,
-                                  0.8145747202313821,0.6651972206962001,0.5230654247691193,
-                                  0.3588304841235025},
-                                 {0.8772005408131083,0.3924451074226354,0.8165994394715771,
-                                  0.4391349085702184,0.3769444294249076,0.4626797856696064,
-                                  0.3013778741641421},
-                                 {0.7476093801762511,0.5027203900924792,0.2322126951468173,
-                                  0.8995745732745685,0.3838912213732114,0.5435528611139886,
-                                  0.9064721109645469},
-                                 {0.6242379959139921,0.1168980407083641,0.9398321236134751,
-                                  0.6277080530714179,0.3349056146570861,0.1392720726633873,
-                                  0.794025189270296 }},
-                              
-                                {{0.6200727559285135,0.5334610919763215,0.8938925830509576,
-                                  0.7885972112245307,0.1516748797327512,0.3117220677955482,
-                                  0.2484891398144657},
-                                 {0.743946292572677 ,0.0335324347357794,0.5698896848713165,
-                                  0.7624586857406905,0.8767656367617495,0.3420817487159075,
-                                  0.8212573046720129},
-                                 {0.1106317369552072,0.8464522917345182,0.1274886623319824,
-                                  0.3972872905603673,0.7972953657795536,0.1499174273487738,
-                                  0.2292513952326415},
-                                 {0.7222525683930663,0.7200365365460744,0.6411476328852973,
-                                  0.6939484444671   ,0.5427244433475962,0.2517990589069528,
-                                  0.3456959935039194},
-                                 {0.1815977168014257,0.9084505613336283,0.5833917947661205,
-                                  0.4008514167636399,0.4620058036441327,0.9472833396118153,
-                                  0.1533514031160802},
-                                 {0.5862298320167972,0.505888678884466 ,0.6114542354346478,
-                                  0.0181101838208405,0.8721239089441515,0.9321182824836124,
-                                  0.5651331835892089}},
-                              
-                                {{0.6966508238768923,0.9224993811772957,0.7072386343133986,
-                                  0.1525390429142613,0.5762883601668132,0.6067150463828559,
-                                  0.424130671302386 },
-                                 {0.7364442356247228,0.9343670147690148,0.9255685129067763,
-                                  0.4508393714041321,0.1132380458407553,0.9848411989623346,
-                                  0.8388980864459341},
-                                 {0.1246626812032668,0.9208418826173723,0.8698963620621283,
-                                  0.5188380571260721,0.5912754357449292,0.3990027038701303,
-                                  0.0547616388220313},
-                                 {0.3351972416459009,0.8028534485980114,0.0046320230046029,
-                                  0.3334991716911442,0.3981686935909433,0.5373956029379229,
-                                  0.9198556164127605},
-                                 {0.3463459943659613,0.3469532018962277,0.7375012481097484,
-                                  0.4522179408898072,0.224604822939982 ,0.4524395161326934,
-                                  0.1408570203797999},
-                                 {0.1763869865062233,0.4983677727394797,0.4189254495045479,
-                                  0.9148459010681   ,0.3623938991166331,0.5805883502780435,
-                                  0.6322642879195304}}}};
+        xarray<double> py_a = {
+            {{{0.3745401188473625,
+               0.9507143064099162,
+               0.7319939418114051,
+               0.5986584841970366,
+               0.1560186404424365,
+               0.1559945203362026,
+               0.0580836121681995},
+              {0.8661761457749352,
+               0.6011150117432088,
+               0.7080725777960455,
+               0.0205844942958024,
+               0.9699098521619943,
+               0.8324426408004217,
+               0.2123391106782762},
+              {0.1818249672071006,
+               0.1834045098534338,
+               0.3042422429595377,
+               0.5247564316322378,
+               0.4319450186421158,
+               0.2912291401980419,
+               0.6118528947223795},
+              {0.1394938606520418,
+               0.2921446485352182,
+               0.3663618432936917,
+               0.4560699842170359,
+               0.7851759613930136,
+               0.1996737821583597,
+               0.5142344384136116},
+              {0.5924145688620425,
+               0.0464504127199977,
+               0.6075448519014384,
+               0.1705241236872915,
+               0.0650515929852795,
+               0.9488855372533332,
+               0.9656320330745594},
+              {0.8083973481164611,
+               0.3046137691733707,
+               0.0976721140063839,
+               0.6842330265121569,
+               0.4401524937396013,
+               0.1220382348447788,
+               0.4951769101112702}},
+
+             {{0.0343885211152184,
+               0.9093204020787821,
+               0.2587799816000169,
+               0.662522284353982,
+               0.311711076089411,
+               0.5200680211778108,
+               0.5467102793432796},
+              {0.184854455525527,
+               0.9695846277645586,
+               0.7751328233611146,
+               0.9394989415641891,
+               0.8948273504276488,
+               0.5978999788110851,
+               0.9218742350231168},
+              {0.0884925020519195,
+               0.1959828624191452,
+               0.0452272889105381,
+               0.3253303307632643,
+               0.388677289689482,
+               0.2713490317738959,
+               0.8287375091519293},
+              {0.3567533266935893,
+               0.2809345096873808,
+               0.5426960831582485,
+               0.1409242249747626,
+               0.8021969807540397,
+               0.0745506436797708,
+               0.9868869366005173},
+              {0.7722447692966574,
+               0.1987156815341724,
+               0.0055221171236024,
+               0.8154614284548342,
+               0.7068573438476171,
+               0.7290071680409873,
+               0.7712703466859457},
+              {0.0740446517340904,
+               0.3584657285442726,
+               0.1158690595251297,
+               0.8631034258755935,
+               0.6232981268275579,
+               0.3308980248526492,
+               0.0635583502860236}},
+
+             {{0.3109823217156622,
+               0.325183322026747,
+               0.7296061783380641,
+               0.6375574713552131,
+               0.8872127425763265,
+               0.4722149251619493,
+               0.1195942459383017},
+              {0.713244787222995,
+               0.7607850486168974,
+               0.5612771975694962,
+               0.770967179954561,
+               0.4937955963643907,
+               0.5227328293819941,
+               0.4275410183585496},
+              {0.0254191267440952,
+               0.1078914269933045,
+               0.0314291856867343,
+               0.6364104112637804,
+               0.3143559810763267,
+               0.5085706911647028,
+               0.907566473926093},
+              {0.2492922291488749,
+               0.4103829230356297,
+               0.7555511385430487,
+               0.2287981654916225,
+               0.076979909828793,
+               0.289751452913768,
+               0.1612212872540044},
+              {0.9296976523425731,
+               0.808120379564417,
+               0.6334037565104235,
+               0.8714605901877177,
+               0.8036720768991145,
+               0.1865700588860358,
+               0.8925589984899778},
+              {0.5393422419156507,
+               0.8074401551640625,
+               0.8960912999234932,
+               0.3180034749718639,
+               0.1100519245276768,
+               0.2279351625419417,
+               0.4271077886262563}},
+
+             {{0.8180147659224931,
+               0.8607305832563434,
+               0.0069521305311907,
+               0.5107473025775657,
+               0.417411003148779,
+               0.2221078104707302,
+               0.1198653673336828},
+              {0.337615171403628,
+               0.9429097039125192,
+               0.3232029320207552,
+               0.5187906217433661,
+               0.7030189588951778,
+               0.363629602379294,
+               0.9717820827209607},
+              {0.9624472949421112,
+               0.2517822958253642,
+               0.4972485058923855,
+               0.3008783098167697,
+               0.2848404943774676,
+               0.0368869473545328,
+               0.6095643339798968},
+              {0.5026790232288615,
+               0.0514787512499894,
+               0.2786464642366114,
+               0.9082658859666537,
+               0.2395618906669724,
+               0.1448948720912231,
+               0.489452760277563},
+              {0.9856504541106007,
+               0.2420552715115004,
+               0.6721355474058786,
+               0.7616196153287176,
+               0.2376375439923997,
+               0.7282163486118596,
+               0.3677831327192532},
+              {0.6323058305935795,
+               0.6335297107608947,
+               0.5357746840747585,
+               0.0902897700544083,
+               0.835302495589238,
+               0.3207800649717358,
+               0.1865185103998542}},
+
+             {{0.0407751415547639,
+               0.5908929431882418,
+               0.6775643618422824,
+               0.0165878289278562,
+               0.512093058299281,
+               0.226495775197938,
+               0.6451727904094499},
+              {0.1743664290049914,
+               0.690937738102466,
+               0.3867353463005374,
+               0.9367299887367345,
+               0.1375209441459933,
+               0.3410663510502585,
+               0.1134735212405891},
+              {0.9246936182785628,
+               0.877339353380981,
+               0.2579416277151556,
+               0.659984046034179,
+               0.8172222002012158,
+               0.5552008115994623,
+               0.5296505783560065},
+              {0.2418522909004517,
+               0.0931027678058992,
+               0.8972157579533268,
+               0.9004180571633305,
+               0.6331014572732679,
+               0.3390297910487007,
+               0.3492095746126609},
+              {0.7259556788702394,
+               0.8971102599525771,
+               0.8870864242651173,
+               0.7798755458576239,
+               0.6420316461542878,
+               0.0841399649950488,
+               0.1616287140946138},
+              {0.8985541885270792,
+               0.6064290596595899,
+               0.0091970516166296,
+               0.1014715428660321,
+               0.6635017691080558,
+               0.0050615838462187,
+               0.1608080514174987}}},
+
+
+            {{{0.5487337893665861,
+               0.6918951976926933,
+               0.6519612595026005,
+               0.2242693094605598,
+               0.7121792213475359,
+               0.2372490874968001,
+               0.3253996981592677},
+              {0.7464914051180241,
+               0.6496328990472147,
+               0.8492234104941779,
+               0.6576128923003434,
+               0.5683086033354716,
+               0.0936747678280925,
+               0.3677158030594335},
+              {0.2652023676817254,
+               0.2439896433790836,
+               0.9730105547524456,
+               0.3930977246667604,
+               0.8920465551771133,
+               0.6311386259972629,
+               0.7948113035416484},
+              {0.5026370931051921,
+               0.5769038846263591,
+               0.4925176938188639,
+               0.1952429877980445,
+               0.7224521152615053,
+               0.2807723624408558,
+               0.0243159664314538},
+              {0.6454722959071678,
+               0.1771106794070489,
+               0.9404585843529143,
+               0.9539285770025874,
+               0.9148643902204485,
+               0.3701587002554444,
+               0.0154566165288674},
+              {0.9283185625877254,
+               0.4281841483173143,
+               0.9666548190436696,
+               0.9636199770892528,
+               0.8530094554673601,
+               0.2944488920695857,
+               0.3850977286019253}},
+
+             {{0.8511366715168569,
+               0.3169220051562777,
+               0.1694927466860925,
+               0.5568012624583502,
+               0.936154774160781,
+               0.696029796674973,
+               0.570061170089365},
+              {0.0971764937707685,
+               0.6150072266991697,
+               0.9900538501042633,
+               0.140084015236524,
+               0.5183296523637367,
+               0.8773730719279554,
+               0.7407686177542044},
+              {0.697015740995268,
+               0.7024840839871093,
+               0.3594911512197552,
+               0.2935918442644934,
+               0.8093611554785136,
+               0.8101133946791808,
+               0.8670723185801037},
+              {0.9132405525564713,
+               0.5113423988609378,
+               0.5015162946871996,
+               0.7982951789667752,
+               0.6499639307777652,
+               0.7019668772577033,
+               0.795792669436101},
+              {0.8900053418175663,
+               0.3379951568515358,
+               0.375582952639944,
+               0.093981939840869,
+               0.578280140996174,
+               0.0359422737967421,
+               0.4655980181324602},
+              {0.5426446347075766,
+               0.2865412521282844,
+               0.5908332605690108,
+               0.0305002499390494,
+               0.0373481887492144,
+               0.8226005606596583,
+               0.3601906414112629}},
+
+             {{0.1270605126518848,
+               0.5222432600548044,
+               0.7699935530986108,
+               0.2158210274968432,
+               0.6228904758190003,
+               0.085347464993768,
+               0.0516817211686077},
+              {0.531354631568148,
+               0.5406351216101065,
+               0.6374299014982066,
+               0.7260913337226615,
+               0.9758520794625346,
+               0.5163003483011953,
+               0.322956472941246},
+              {0.7951861947687037,
+               0.2708322512620742,
+               0.4389714207056361,
+               0.078456381342266,
+               0.0253507434154575,
+               0.9626484146779251,
+               0.8359801205122058},
+              {0.695974206093698,
+               0.4089529444142699,
+               0.1732943200708458,
+               0.156437042671086,
+               0.2502428981645953,
+               0.5492266647061205,
+               0.7145959227000623},
+              {0.6601973767177313,
+               0.2799338969459428,
+               0.9548652806631941,
+               0.7378969166957685,
+               0.5543540525114007,
+               0.6117207462343522,
+               0.4196000624277899},
+              {0.2477309895011575,
+               0.3559726786512616,
+               0.7578461104643691,
+               0.0143934886297559,
+               0.1160726405069162,
+               0.0460026420217527,
+               0.0407288023189701}},
+
+             {{0.8554605840110072,
+               0.7036578593800237,
+               0.4741738290873252,
+               0.0978341606510015,
+               0.4916158751168324,
+               0.4734717707805657,
+               0.1732018699100152},
+              {0.433851649237973,
+               0.3985047343973734,
+               0.6158500980522165,
+               0.6350936508676438,
+               0.0453040097720445,
+               0.3746126146264712,
+               0.6258599157142364},
+              {0.5031362585800877,
+               0.8564898411883223,
+               0.658693631618945,
+               0.1629344270814297,
+               0.0705687474004298,
+               0.6424192782063156,
+               0.0265113105416218},
+              {0.5857755812734633,
+               0.9402302414249576,
+               0.575474177875879,
+               0.3881699262065219,
+               0.6432882184423532,
+               0.4582528904915166,
+               0.5456167893159349},
+              {0.9414648087765252,
+               0.3861026378007743,
+               0.9611905638239142,
+               0.9053506419560637,
+               0.1957911347892964,
+               0.0693613008751655,
+               0.1007780013774267},
+              {0.0182218256515497,
+               0.0944429607559284,
+               0.6830067734163568,
+               0.071188648460229,
+               0.3189756302937613,
+               0.8448753109694546,
+               0.0232719357358259}},
+
+             {{0.8144684825889358,
+               0.2818547747733999,
+               0.1181648276216563,
+               0.6967371653641506,
+               0.628942846779884,
+               0.877472013527053,
+               0.7350710438038858},
+              {0.8034809303848486,
+               0.2820345725713065,
+               0.1774395437797228,
+               0.7506147516408583,
+               0.806834739267264,
+               0.9905051420006733,
+               0.4126176769114265},
+              {0.3720180857927832,
+               0.7764129607419968,
+               0.3408035402530178,
+               0.9307573256035647,
+               0.8584127518430118,
+               0.4289940273750183,
+               0.7508710677914974},
+              {0.7545428740846823,
+               0.1031238688359326,
+               0.9025529066795667,
+               0.5052523724478571,
+               0.8264574661077416,
+               0.3200496010306118,
+               0.8955232284962005},
+              {0.3892016787341631,
+               0.0108376514802984,
+               0.9053819764192637,
+               0.0912866767861336,
+               0.3193136375904149,
+               0.9500619670508049,
+               0.9506071469375561},
+              {0.5734378881232861,
+               0.6318372121697993,
+               0.4484455219783198,
+               0.2932107716980645,
+               0.328664545369916,
+               0.6725184560770384,
+               0.75237452943768}}},
+
+
+            {{{0.7915790437258485,
+               0.7896181427945539,
+               0.0912061030486904,
+               0.4944203047025815,
+               0.0575587600166443,
+               0.5495288823237355,
+               0.441530501373377},
+              {0.8877041827582998,
+               0.3509150125520787,
+               0.1170670164276059,
+               0.1429916820528359,
+               0.7615106317174722,
+               0.6182180633162611,
+               0.1011226761227902},
+              {0.0841068061149974,
+               0.70096913145912,
+               0.0727630063641935,
+               0.8218600592903562,
+               0.7062422271564962,
+               0.0813487806418998,
+               0.0848377140851919},
+              {0.9866395785011755,
+               0.3742707957561203,
+               0.3706421470668909,
+               0.8127995672575026,
+               0.9472485773838587,
+               0.9860010638228709,
+               0.7533781852589416},
+              {0.3762595855309158,
+               0.0835007166986688,
+               0.7771469159274368,
+               0.558404249735805,
+               0.4242220092469763,
+               0.906354385094736,
+               0.1111974823061513},
+              {0.4926251042908592,
+               0.0113536447674191,
+               0.4686606419941263,
+               0.0563032756818374,
+               0.1188179162680719,
+               0.1175262467771049,
+               0.6492103021160636}},
+
+             {{0.7460448792654233,
+               0.5833687650971596,
+               0.9621725484745419,
+               0.3748705795237041,
+               0.2857120862818607,
+               0.8685991281894603,
+               0.2235958385194526},
+              {0.9632225394406113,
+               0.0121544746898163,
+               0.969878826707639,
+               0.0431599119505761,
+               0.8911431136980711,
+               0.5277011090862999,
+               0.9929647961193003},
+              {0.0737965647353989,
+               0.5538542844013208,
+               0.969302535619099,
+               0.5230978441701488,
+               0.6293986381352625,
+               0.6957486889846172,
+               0.4545410647677732},
+              {0.6275580800840634,
+               0.5843143119231002,
+               0.901158010490989,
+               0.0454463803414579,
+               0.2809631895922303,
+               0.9504114840765587,
+               0.8902637838909163},
+              {0.4556567527857129,
+               0.6201325978015367,
+               0.2773811829811327,
+               0.1881211597237613,
+               0.4636984049399822,
+               0.3533522280260528,
+               0.5836561118508721},
+              {0.0777346369649848,
+               0.9743948076661665,
+               0.9862107444796029,
+               0.6981617140197451,
+               0.5360963663441204,
+               0.3095276162863277,
+               0.8137950197069487}},
+
+             {{0.6847311725538793,
+               0.1626169393448913,
+               0.9109271844938425,
+               0.822537242923169,
+               0.949799913291924,
+               0.72571950838836,
+               0.6134151959357899},
+              {0.4182430362906189,
+               0.9327284833540133,
+               0.8660638895004084,
+               0.0452186701061894,
+               0.026366974497252,
+               0.3764633668780496,
+               0.8105533307818329},
+              {0.9872761293149445,
+               0.1504168911035282,
+               0.5941307153521351,
+               0.3808908566310215,
+               0.9699143978146032,
+               0.8421189231357087,
+               0.8383287047111379},
+              {0.4686931597949703,
+               0.4148195023376652,
+               0.2734070719307062,
+               0.0563754966509271,
+               0.8647223762550532,
+               0.8129010091300776,
+               0.9997176732861306},
+              {0.9966368370739054,
+               0.5554317056026274,
+               0.7689874151805105,
+               0.944765729882428,
+               0.8496473906774115,
+               0.2473481017431977,
+               0.4505441353100935},
+              {0.129159415151495,
+               0.9540510272587224,
+               0.60617463445088,
+               0.2286428055034627,
+               0.6717006844058567,
+               0.6181282404578958,
+               0.3581627180328405}},
+
+             {{0.113557592199629,
+               0.6715731955927996,
+               0.5203077009037933,
+               0.7723183917356393,
+               0.5201635011119934,
+               0.8521815003185401,
+               0.5519068387744855},
+              {0.5609379715353863,
+               0.876653602658345,
+               0.403482866212397,
+               0.1340152284506407,
+               0.028782676313339,
+               0.755137255673619,
+               0.6203095513534647},
+              {0.7040797680992236,
+               0.2129641615089107,
+               0.1363714755867698,
+               0.0145446656678819,
+               0.350587558806597,
+               0.5899176868546331,
+               0.3922440450997323},
+              {0.4374749220237291,
+               0.9041586944937484,
+               0.3482554670233003,
+               0.5139894891598108,
+               0.7836530127411431,
+               0.3965427823212702,
+               0.6220867002278735},
+              {0.8623637087467452,
+               0.9495206236576421,
+               0.1470734809290379,
+               0.9265876251614944,
+               0.4921162930795382,
+               0.2582443882989583,
+               0.4591357562382613},
+              {0.980032575285477,
+               0.4926180939928696,
+               0.3287516102875082,
+               0.6334008543167258,
+               0.2401456187781931,
+               0.0758633281086639,
+               0.1288797219106492}},
+
+             {{0.1280458389577724,
+               0.1519026935122944,
+               0.1388271726494101,
+               0.6408747448032146,
+               0.1818800843991448,
+               0.3456672833238632,
+               0.8967884099060118},
+              {0.4739616402628724,
+               0.6675577385210272,
+               0.1723198712016298,
+               0.1922890188086708,
+               0.0408686162664789,
+               0.1689350630721645,
+               0.2785903390319586},
+              {0.1770104842767468,
+               0.0887025337570556,
+               0.1206358711006008,
+               0.4607787680327258,
+               0.2063337184057925,
+               0.3642698610480755,
+               0.5034172708548569},
+              {0.6903948286293653,
+               0.0393121398410989,
+               0.7994103989090426,
+               0.6279003894909078,
+               0.0817590319488719,
+               0.8735786241067772,
+               0.9208724005318132},
+              {0.0610779598548638,
+               0.2768776481472037,
+               0.8062012797930613,
+               0.7482596903836584,
+               0.1845210193563773,
+               0.2093493233367103,
+               0.370472102791382},
+              {0.4845229851910213,
+               0.618254771530296,
+               0.3689136395697724,
+               0.4625347161331479,
+               0.7474709381337565,
+               0.0366832028905979,
+               0.2524369443440208}}},
+
+
+            {{{0.7133495858845524,
+               0.8952068376871993,
+               0.5116774421156661,
+               0.5321134852653157,
+               0.1071720113397761,
+               0.4474123668234546,
+               0.5326172664550232},
+              {0.2424705036347297,
+               0.269243230949381,
+               0.3772841631046226,
+               0.0200711977777264,
+               0.3220791655831783,
+               0.2114480069965446,
+               0.3274973521779146},
+              {0.1197621318192512,
+               0.890527280739895,
+               0.5935924535540487,
+               0.6791023191444896,
+               0.7891712386073383,
+               0.4984421989290573,
+               0.0869202880874237},
+              {0.5371065418185478,
+               0.5868411180208791,
+               0.74543947418433,
+               0.4316595462296794,
+               0.1275803027955638,
+               0.2837759057987245,
+               0.3630822963986351},
+              {0.6459172413316012,
+               0.5707783046689119,
+               0.3560967258978462,
+               0.9865152487929797,
+               0.6057748193568872,
+               0.2372267917359945,
+               0.1017824726204037},
+              {0.152859139184332,
+               0.2459577283845081,
+               0.1606813732595557,
+               0.1865670240513058,
+               0.2850951686938471,
+               0.1733735952947548,
+               0.8967654246264252}},
+
+             {{0.0802337456616422,
+               0.5245113895702547,
+               0.4103968269896615,
+               0.9823786169086064,
+               0.1120389021680523,
+               0.3978555990457416,
+               0.9694704332753689},
+              {0.8655071258939803,
+               0.8170720709492799,
+               0.2579028270449398,
+               0.1708875873900658,
+               0.668643219924431,
+               0.9293759891275858,
+               0.5567628930139298},
+              {0.5716126894698998,
+               0.2799790936602842,
+               0.7694929331919369,
+               0.1870437485575234,
+               0.3236792364042437,
+               0.4254364386164168,
+               0.507610378684455},
+              {0.2424097324150802,
+               0.1148368247392035,
+               0.6106200424416326,
+               0.2886305532402558,
+               0.5812382214226123,
+               0.1543627152742023,
+               0.4811401018548175},
+              {0.5325894325515859,
+               0.0518235368224269,
+               0.3366042781939206,
+               0.1344146769389742,
+               0.0633749704727677,
+               0.9899602323899452,
+               0.322353844974723},
+              {0.8098744458546349,
+               0.2546406547637639,
+               0.6815027222239293,
+               0.7602278598896866,
+               0.5956387406078443,
+               0.4715761885501584,
+               0.4118409141472685}},
+
+             {{0.3488682665429953,
+               0.9295291442478258,
+               0.8306194077877291,
+               0.9650269106665126,
+               0.1242972234855447,
+               0.7308674752036443,
+               0.9383404568210378},
+              {0.1812330661656602,
+               0.0664962673667775,
+               0.741120649290059,
+               0.5744731131799119,
+               0.8418287767582721,
+               0.1397723766262895,
+               0.7952673118598902},
+              {0.2016273200477445,
+               0.1636559428657045,
+               0.1642657979309929,
+               0.8145747202313821,
+               0.6651972206962001,
+               0.5230654247691193,
+               0.3588304841235025},
+              {0.8772005408131083,
+               0.3924451074226354,
+               0.8165994394715771,
+               0.4391349085702184,
+               0.3769444294249076,
+               0.4626797856696064,
+               0.3013778741641421},
+              {0.7476093801762511,
+               0.5027203900924792,
+               0.2322126951468173,
+               0.8995745732745685,
+               0.3838912213732114,
+               0.5435528611139886,
+               0.9064721109645469},
+              {0.6242379959139921,
+               0.1168980407083641,
+               0.9398321236134751,
+               0.6277080530714179,
+               0.3349056146570861,
+               0.1392720726633873,
+               0.794025189270296}},
+
+             {{0.6200727559285135,
+               0.5334610919763215,
+               0.8938925830509576,
+               0.7885972112245307,
+               0.1516748797327512,
+               0.3117220677955482,
+               0.2484891398144657},
+              {0.743946292572677,
+               0.0335324347357794,
+               0.5698896848713165,
+               0.7624586857406905,
+               0.8767656367617495,
+               0.3420817487159075,
+               0.8212573046720129},
+              {0.1106317369552072,
+               0.8464522917345182,
+               0.1274886623319824,
+               0.3972872905603673,
+               0.7972953657795536,
+               0.1499174273487738,
+               0.2292513952326415},
+              {0.7222525683930663,
+               0.7200365365460744,
+               0.6411476328852973,
+               0.6939484444671,
+               0.5427244433475962,
+               0.2517990589069528,
+               0.3456959935039194},
+              {0.1815977168014257,
+               0.9084505613336283,
+               0.5833917947661205,
+               0.4008514167636399,
+               0.4620058036441327,
+               0.9472833396118153,
+               0.1533514031160802},
+              {0.5862298320167972,
+               0.505888678884466,
+               0.6114542354346478,
+               0.0181101838208405,
+               0.8721239089441515,
+               0.9321182824836124,
+               0.5651331835892089}},
+
+             {{0.6966508238768923,
+               0.9224993811772957,
+               0.7072386343133986,
+               0.1525390429142613,
+               0.5762883601668132,
+               0.6067150463828559,
+               0.424130671302386},
+              {0.7364442356247228,
+               0.9343670147690148,
+               0.9255685129067763,
+               0.4508393714041321,
+               0.1132380458407553,
+               0.9848411989623346,
+               0.8388980864459341},
+              {0.1246626812032668,
+               0.9208418826173723,
+               0.8698963620621283,
+               0.5188380571260721,
+               0.5912754357449292,
+               0.3990027038701303,
+               0.0547616388220313},
+              {0.3351972416459009,
+               0.8028534485980114,
+               0.0046320230046029,
+               0.3334991716911442,
+               0.3981686935909433,
+               0.5373956029379229,
+               0.9198556164127605},
+              {0.3463459943659613,
+               0.3469532018962277,
+               0.7375012481097484,
+               0.4522179408898072,
+               0.224604822939982,
+               0.4524395161326934,
+               0.1408570203797999},
+              {0.1763869865062233,
+               0.4983677727394797,
+               0.4189254495045479,
+               0.9148459010681,
+               0.3623938991166331,
+               0.5805883502780435,
+               0.6322642879195304}}}
+        };
         // py_w
-        xarray<double> py_w = {{{{0.0130944565883336,0.6635373720167106,0.1780359668697514,
-                                  0.9610703174694551,0.148662727753113 ,0.4146241237270237,
-                                  0.0853496680786439},
-                                 {0.9968742518459474,0.5021950103312426,0.5953850173200438,
-                                  0.0670764773884275,0.7499604703991778,0.2099055930955858,
-                                  0.8980542894407137},
-                                 {0.2051396404820072,0.1906877206636666,0.0365496678480949,
-                                  0.4720669451099992,0.5648411332626164,0.0657086394283524,
-                                  0.7755276166950106},
-                                 {0.4532888347480276,0.52439026932758  ,0.4407627469382281,
-                                  0.400763060875326 ,0.5596403313082179,0.1552402459307125,
-                                  0.1819281304952711},
-                                 {0.8617856210135173,0.9461154621336327,0.3733093162797529,
-                                  0.2707446731435538,0.6439995432390158,0.4087341710980964,
-                                  0.0253863556603449},
-                                 {0.1561525973661904,0.7159722288473975,0.6589239419101514,
-                                  0.0270959925034835,0.2219721619329494,0.2310747965880714,
-                                  0.6718927435987284}},
-                              
-                                {{0.0197105377543642,0.1041085819845738,0.7999160853731894,
-                                  0.1785446620543336,0.6527461078518747,0.2381827810467265,
-                                  0.0994413927593452},
-                                 {0.2431721909994541,0.7222669318556592,0.8556964681062857,
-                                  0.8302198645669916,0.3971835296184548,0.6680851365706462,
-                                  0.204984295415821 },
-                                 {0.2931477302610133,0.8963358185211198,0.013001923510736 ,
-                                  0.0855085308544681,0.2078862551460273,0.0265322038738197,
-                                  0.1814354350897973},
-                                 {0.5830415609696922,0.4214245505924979,0.8926717110769748,
-                                  0.8174435617384409,0.341817351697876 ,0.2594234334312925,
-                                  0.3796924081672669},
-                                 {0.5902949425148077,0.2680636408228763,0.624148907849134 ,
-                                  0.4094116521912404,0.5520471808519802,0.4361265291353167,
-                                  0.2944657595419177},
-                                 {0.9484533069621567,0.7636057941597608,0.1401131757664525,
-                                  0.8684679758979128,0.4874311982495136,0.8945522268940914,
-                                  0.7998552559473152}},
-                              
-                                {{0.4252135044692334,0.0224693083201174,0.2686773593849461,
-                                  0.5416342146608669,0.6334782198261473,0.2578876854332023,
-                                  0.1393560740728241},
-                                 {0.8349302367992991,0.9844021807035521,0.5256901823026858,
-                                  0.1716792858483035,0.272307326519369 ,0.0183906765474667,
-                                  0.914298806560499 },
-                                 {0.1177510828901411,0.5765164755142536,0.274055220687206 ,
-                                  0.5541780025157934,0.6514203883518642,0.8297418037072016,
-                                  0.2064212717606032},
-                                 {0.0109958286584805,0.1368856300688073,0.9000186418481051,
-                                  0.8738900775625152,0.5974131021703083,0.6005168604336534,
-                                  0.6650366745462555},
-                                 {0.1753712786234496,0.9144119459249598,0.4187705248920731,
-                                  0.3831385282494975,0.5189177052828375,0.046965966775055 ,
-                                  0.1662833687560794},
-                                 {0.7380336164263704,0.0827986679251265,0.6031521094663882,
-                                  0.245349109681321 ,0.3892956140419765,0.2886937367706999,
-                                  0.3556727164649491}},
-                              
-                                {{0.7190459051842455,0.297121715623175 ,0.5664046402968972,
-                                  0.4760504021990997,0.6636711653626481,0.936829739324758 ,
-                                  0.7325720972102503},
-                                 {0.2149403785907568,0.0311831350612847,0.2622640442998251,
-                                  0.5950779307002548,0.0514258134842503,0.4963662472012363,
-                                  0.5968428489168892},
-                                 {0.3342438908169608,0.7709122037458219,0.1065982531337718,
-                                  0.0751377817358088,0.7281887562036033,0.4954913162061985,
-                                  0.688402396427736 },
-                                 {0.4348273386037462,0.2464020332391068,0.8191023176741997,
-                                  0.7994158789689793,0.6946964708544268,0.2721451372299627,
-                                  0.5902306668690871},
-                                 {0.3609738969400268,0.0915820733266342,0.9173135754622428,
-                                  0.1368186309189614,0.9502373538208024,0.4460057729579557,
-                                  0.1851329288386196},
-                                 {0.5419009473783581,0.8729458358764083,0.7322248864095612,
-                                  0.8065611478614497,0.6587833667107174,0.6922765645178525,
-                                  0.8491956515653193}},
-                              
-                                {{0.2496680088591859,0.4894249636431405,0.2212094418196022,
-                                  0.987668007996647 ,0.9440593396866133,0.0394268113685059,
-                                  0.7055751725156885},
-                                 {0.9252483174156658,0.1805753451273335,0.5679452305526295,
-                                  0.9154882975880418,0.0339459785857988,0.6974202672468399,
-                                  0.2973490073725508},
-                                 {0.9243961953765304,0.9710582451653678,0.9442664891134339,
-                                  0.4742142166574638,0.8620426509893134,0.8445493985350704,
-                                  0.3191004732432556},
-                                 {0.8289154741506773,0.0370076347154926,0.596269878482053 ,
-                                  0.230008837287703 ,0.1205668857772788,0.0769532016292092,
-                                  0.6962887758781398},
-                                 {0.3398749637680661,0.7247667715287615,0.0653563407989424,
-                                  0.3152903378306103,0.5394912923753372,0.7907231648389635,
-                                  0.3187525029320699},
-                                 {0.6258913764370091,0.8859777482361871,0.6158631881823046,
-                                  0.2329594747536338,0.024400781556538 ,0.8700988739009299,
-                                  0.0212694108503871}}},
-                              
-                              
-                               {{{0.8747016726841994,0.528937134027212 ,0.9390676985128962,
-                                  0.7987832357736654,0.9979341105333375,0.3507118154517102,
-                                  0.7671882889311269},
-                                 {0.4019309136092422,0.4798756203039088,0.6275054632183701,
-                                  0.8736771141863388,0.9840834691992951,0.7682734138645182,
-                                  0.4177667821673338},
-                                 {0.4213570022770702,0.7375823015888915,0.2387771457683023,
-                                  0.1104741131313947,0.3546221576407765,0.2872389916540817,
-                                  0.2963081204559901},
-                                 {0.2336077510499099,0.0420931896363619,0.0178739347334138,
-                                  0.9877223897360315,0.4277731337358623,0.3843266471596817,
-                                  0.6796472826930698},
-                                 {0.2182538878650642,0.9499611839502253,0.786345014415552 ,
-                                  0.0894110023122595,0.4175807757849284,0.8791183075621647,
-                                  0.9447320222914103},
-                                 {0.4674015112498697,0.6134113892107077,0.1670339460920752,
-                                  0.9911686261369765,0.2316717013834434,0.9427317741351257,
-                                  0.6496466489923685}},
-                              
-                                {{0.6077367948788591,0.5126885110165086,0.2306698117177587,
-                                  0.1765280320055083,0.2204862090701754,0.1864382621442545,
-                                  0.7795844735667533},
-                                 {0.3501252591667301,0.0578426765633964,0.9691026301408113,
-                                  0.8837858849634257,0.927752283195213 ,0.9949078226464353,
-                                  0.1738952492194873},
-                                 {0.3962420189026588,0.7582384757040913,0.6960206180537922,
-                                  0.1538959063398551,0.8158331249906178,0.2244405718366607,
-                                  0.2238176148226231},
-                                 {0.5369744228934136,0.5929399348417032,0.5800862078378112,
-                                  0.0914868373977549,0.8774608626303804,0.2656000425887061,
-                                  0.1295149212828042},
-                                 {0.8887480798689772,0.9556514982297534,0.8621276172654506,
-                                  0.8095160747248781,0.6552419806390217,0.5508573706091393,
-                                  0.0869867599114101},
-                                 {0.4084532130706987,0.372688517012314 ,0.2597537837603262,
-                                  0.7234201136885849,0.4958757350787708,0.0810462159076479,
-                                  0.2201832019498113}},
-                              
-                                {{0.6832587636595959,0.0761308594903002,0.8512069140487687,
-                                  0.4951465270139743,0.480586577326648 ,0.5924077846595176,
-                                  0.8246809659251492},
-                                 {0.3478092079021931,0.6780161525590636,0.5657319639957911,
-                                  0.2670282701694213,0.878629986355158 ,0.7974260216069281,
-                                  0.6584518346584255},
-                                 {0.8505817290942419,0.8672942009598024,0.7083629767150348,
-                                  0.837013328363672 ,0.6974714616692836,0.6801407717603004,
-                                  0.6186113782151843},
-                                 {0.7527166395576412,0.1586051052930737,0.8808707591989284,
-                                  0.871843527745232 ,0.0292472830345591,0.8258167505647627,
-                                  0.1288698674734452},
-                                 {0.3351188542591419,0.7435082562916078,0.1607598960483082,
-                                  0.8179670241190622,0.8321341779577419,0.5074677337608362,
-                                  0.0063858717168336},
-                                 {0.2870381331749128,0.6169269183757422,0.9811861780274235,
-                                  0.6318135270166684,0.2598035810641598,0.6340057030996114,
-                                  0.5399853797158555}},
-                              
-                                {{0.7798453951511436,0.1069806388269584,0.761027902502028 ,
-                                  0.5412665786761103,0.9629920038589946,0.3418721660386861,
-                                  0.6326218931339481},
-                                 {0.9320281055100175,0.1025097279906793,0.9372284872364511,
-                                  0.6878857223008134,0.0678370591051719,0.3009635669468163,
-                                  0.7081720886452816},
-                                 {0.0673506014687717,0.5821704601762733,0.3458830569529567,
-                                  0.6209155177674771,0.0457420338125129,0.8715368061523763,
-                                  0.9734889691773969},
-                                 {0.9688778552856915,0.7496518317429247,0.130086240130632 ,
-                                  0.7582631959290226,0.0245869164588015,0.0221235515289973,
-                                  0.3236102191495412},
-                                 {0.4886431904046658,0.7704074178077932,0.6832953766065052,
-                                  0.4459027063767483,0.2736266662816659,0.9971245001577111,
-                                  0.4261813022359729},
-                                 {0.4513870243296755,0.1636238211916692,0.7948095487499294,
-                                  0.6936822257814886,0.2207696127887604,0.0823810456158427,
-                                  0.6804993020747131}},
-                              
-                                {{0.6545112142811352,0.2732595269982093,0.9508635622504104,
-                                  0.1510578917809002,0.4323348010426019,0.9436159201675989,
-                                  0.4197273169261223},
-                                 {0.6385259476640855,0.3975943979627943,0.27421520234867  ,
-                                  0.9839776479598282,0.409334006315043 ,0.8940992036791344,
-                                  0.2299546058910862},
-                                 {0.2131047040250833,0.0311340828845114,0.651666825375885 ,
-                                  0.3685263437237611,0.864358249839637 ,0.4732099066915572,
-                                  0.9681934279147217},
-                                 {0.1855255157031211,0.8686231679556108,0.7765968527917417,
-                                  0.770921844644052 ,0.8447832281168877,0.7610239909429989,
-                                  0.6262203216314154},
-                                 {0.1312448776823876,0.0325261794912519,0.9208478478156868,
-                                  0.616650314520738 ,0.7965372909761763,0.4815223515125501,
-                                  0.1173081889623945},
-                                 {0.1251857922025504,0.6855652872289714,0.4303058948994627,
-                                  0.2005247267003367,0.4915945467414369,0.0642089370751341,
-                                  0.5819714019143988}}},
-                              
-                              
-                               {{{0.2689934044350977,0.7975591006371882,0.3103619589235738,
-                                  0.4552201490818012,0.0116205399081006,0.0724468877945589,
-                                  0.3924935564066848},
-                                 {0.4799388347171235,0.6000205481193037,0.2916625787093032,
-                                  0.6949818861265425,0.8601223971892046,0.7798509888933498,
-                                  0.0396188253483571},
-                                 {0.4805069472578289,0.1049301784181749,0.2420450158625275,
-                                  0.9866625932671464,0.1424955429015132,0.4988881534513561,
-                                  0.6181557343181191},
-                                 {0.702464970544104 ,0.5596486834869141,0.0097708474191837,
-                                  0.3264613082439919,0.5177116433847114,0.0878664991448334,
-                                  0.3506269312091808},
-                                 {0.0332031087913666,0.0785784971550207,0.3969232762015961,
-                                  0.1327157540430604,0.5675408482615582,0.6894649691372657,
-                                  0.8005866991090829},
-                                 {0.2001502442448101,0.1674825822590698,0.1045678403344003,
-                                  0.6364302495436367,0.7064757264869012,0.031586144825642 ,
-                                  0.9362122462436898}},
-                              
-                                {{0.0519712836514724,0.5412963353010705,0.7090605194509164,
-                                  0.8709691237460856,0.7140869321324278,0.8017280830697918,
-                                  0.3394501925428061},
-                                 {0.8148251137465122,0.0801148463846751,0.8948166560605276,
-                                  0.5475923761537362,0.8172977699624937,0.4523182845183001,
-                                  0.643577695196525 },
-                                 {0.5264026609361132,0.7315895217553319,0.0816299820305896,
-                                  0.0603520839905638,0.2471032340101464,0.1595446801131883,
-                                  0.8717835665922017},
-                                 {0.2192139873580443,0.9758652558191313,0.3368957917711068,
-                                  0.1821179156886993,0.7896985071424791,0.6587077755008761,
-                                  0.498195716453139 },
-                                 {0.5553635509376312,0.7192017782722638,0.2284547413312987,
-                                  0.9963339160567419,0.9747931621467831,0.6503256863469369,
-                                  0.1995424509291451},
-                                 {0.6802282424312913,0.0721984089791758,0.0306525022058061,
-                                  0.2576828885112137,0.4626229567393163,0.8682725054083805,
-                                  0.727169069766308 }},
-                              
-                                {{0.742706521199981 ,0.4254933344480754,0.3459349925469629,
-                                  0.3710387629846027,0.9876495637360578,0.0401091914124825,
-                                  0.8670314961224486},
-                                 {0.5786754085723934,0.4386154191895905,0.7252576604151365,
-                                  0.4866689414247029,0.8734232380816606,0.9007018640112585,
-                                  0.4217209268734554},
-                                 {0.2768277972350516,0.5923503285933622,0.912363345616691 ,
-                                  0.2106621890056666,0.6229665835634828,0.6315602200925206,
-                                  0.733113022415281 },
-                                 {0.1315676851272598,0.7158249646820886,0.909032520665641 ,
-                                  0.179683108870242 ,0.2375433249238776,0.9713950940416396,
-                                  0.1809769527094898},
-                                 {0.8543850933695791,0.4922778564480348,0.247231074403177 ,
-                                  0.8707499012725114,0.4453052550026655,0.5148173539296902,
-                                  0.3592333693997657},
-                                 {0.5929508514349274,0.1635238725850228,0.3910815366517607,
-                                  0.9694123223352875,0.2581334327011275,0.6567366645412922,
-                                  0.3251900642246949}},
-                              
-                                {{0.7734731256866006,0.1308736607183498,0.9698210450785447,
-                                  0.4537895413836392,0.236050463346464 ,0.0734967473300127,
-                                  0.1697579050875407},
-                                 {0.5197739485560177,0.3370031764312863,0.8288833658826095,
-                                  0.4308875236618059,0.2487142725876299,0.61714498660403  ,
-                                  0.7067772168854458},
-                                 {0.1670419079009499,0.1676192162883177,0.036671426933543 ,
-                                  0.7364020150656405,0.6638045276218051,0.4746308757498139,
-                                  0.8441704489691971},
-                                 {0.8056701529500532,0.5853543643967521,0.8682712805132586,
-                                  0.2058412100367683,0.1119196193977279,0.2697496115169896,
-                                  0.0570868560893149},
-                                 {0.531169528001032 ,0.9366056922949615,0.0393435406685096,
-                                  0.1221099140100268,0.4521990282834353,0.9338750175279049,
-                                  0.3161561049767505},
-                                 {0.5072348086883924,0.0415728590503921,0.1483432009620889,
-                                  0.9866301229588469,0.9651186964360455,0.0049399809344096,
-                                  0.951811785423239 }},
-                              
-                                {{0.6391199378155004,0.8679182945200221,0.4547398556338591,
-                                  0.5155960285792502,0.4888465802569202,0.6668642575461043,
-                                  0.1396512547563129},
-                                 {0.029973589872678 ,0.3079299415911909,0.7046807627366467,
-                                  0.2018534521229484,0.6734324333249173,0.9699120461072704,
-                                  0.0939007157894184},
-                                 {0.6726021182251263,0.4437502193045711,0.8681422543775054,
-                                  0.1771497894473859,0.6926259522261645,0.8381152896481102,
-                                  0.9446142194740232},
-                                 {0.6832480282896458,0.4971747640084273,0.6178472402012138,
-                                  0.8689049844787182,0.5706097466388297,0.0303870596968369,
-                                  0.9309486955069778},
-                                 {0.6895267510315611,0.6765133857772465,0.2156751523977172,
-                                  0.6588854702326572,0.3938644056541585,0.6512329770414921,
-                                  0.1065930303079907},
-                                 {0.657845304603036 ,0.9994137257706666,0.048212038860556 ,
-                                  0.9771741842213173,0.4069079607228706,0.8707534503372591,
-                                  0.7823854840582735}}},
-                              
-                              
-                               {{{0.5670162609866678,0.7384492092513265,0.8785155613013479,
-                                  0.404140321651033 ,0.3270331615632387,0.6675933855635847,
-                                  0.8078459419412586},
-                                 {0.7622851347766157,0.7978136488586345,0.435583314812933 ,
-                                  0.8178342161750216,0.1202090553706084,0.5444890979608495,
-                                  0.0057586604981216},
-                                 {0.3245858299002703,0.3664615348713979,0.3961726916092554,
-                                  0.6954672066898622,0.3885581012703457,0.4486936226225307,
-                                  0.2375441308743275},
-                                 {0.3732517916293401,0.2272696272631515,0.0731959237684436,
-                                  0.6034485933813779,0.6682127985550163,0.6194903460096145,
-                                  0.4634940438005724},
-                                 {0.3797857801792298,0.8633336495718252,0.519081785136218 ,
-                                  0.479181877629731 ,0.0256420658064357,0.3412478276261564,
-                                  0.3801956187858571},
-                                 {0.3988227808969005,0.5801723692273323,0.5336025467268785,
-                                  0.6079050927934446,0.7648832615421283,0.8129857387160935,
-                                  0.7181230762264944}},
-                              
-                                {{0.9555236959549347,0.0182325826763616,0.1957779856835461,
-                                  0.0075628749781421,0.647474714154603 ,0.8980305489499869,
-                                  0.2434822965762993},
-                                 {0.9270345447963066,0.0602673902895609,0.9344360268055143,
-                                  0.3516226872396344,0.1014208284492165,0.4858717591863256,
-                                  0.2567765677205079},
-                                 {0.2848729019619228,0.3072899649262866,0.8030258978326634,
-                                  0.5391612766752545,0.3113076991560036,0.6103337833109184,
-                                  0.7161506742231936},
-                                 {0.2726240007335338,0.4135491015253515,0.1218860933369476,
-                                  0.1811493495346803,0.6811178539649828,0.1814383476956269,
-                                  0.5251633836670602},
-                                 {0.7090462617224327,0.1068769230947438,0.5673122196289035,
-                                  0.2565627837013638,0.9629268752375798,0.4835456467199247,
-                                  0.8059925497751581},
-                                 {0.5502265421562618,0.0434125328548192,0.6331513755940223,
-                                  0.951403342206657 ,0.6016118201463312,0.8191888594267902,
-                                  0.8842064633484078}},
-                              
-                                {{0.2280797719489325,0.2120448399082266,0.6109809888509917,
-                                  0.4110284698067047,0.8398613028667203,0.9000231233980112,
-                                  0.3534213793027181},
-                                 {0.2368705589744821,0.7805255152438618,0.2748060355481361,
-                                  0.8226143185136784,0.4237382536487628,0.6675498992914705,
-                                  0.0955353138346682},
-                                 {0.623859324676573 ,0.4517676787372291,0.5866084631754741,
-                                  0.1680142077448634,0.7368737449441821,0.8627970775432285,
-                                  0.2167398000907756},
-                                 {0.0957145555201617,0.0236385860463364,0.641971500443266 ,
-                                  0.6070940360887808,0.54669741271407  ,0.2319470961159754,
-                                  0.3909059959055147},
-                                 {0.594476335186173 ,0.4967668588591694,0.9877855202148873,
-                                  0.1364397525567331,0.6951445540475938,0.4043187681042921,
-                                  0.4281996149256148},
-                                 {0.7175977656581762,0.6924361513243696,0.9912559937021883,
-                                  0.1283942894541252,0.1041096493841663,0.7243388171287412,
-                                  0.5783869170064091}},
-                              
-                                {{0.2741606665598059,0.0794193689889866,0.0856582495964305,
-                                  0.8941908746641183,0.1918673247187429,0.3233715621155208,
-                                  0.226656402226988 },
-                                 {0.3549963058319373,0.0694238427460934,0.5190597909082704,
-                                  0.0676125635922149,0.8003565078223616,0.233712081910433 ,
-                                  0.5400119146045106},
-                                 {0.8800790875614583,0.6508773690471942,0.5329577865513353,
-                                  0.3243337531153756,0.3330019130581979,0.6694869551981901,
-                                  0.9941393612211675},
-                                 {0.6618391898493786,0.5577834173700249,0.7306505102392461,
-                                  0.4652056122837182,0.0601423426007852,0.5622968158779098,
-                                  0.9576252845053802},
-                                 {0.1753029423576596,0.6900048908206657,0.2009336886590565,
-                                  0.5358276844730813,0.0966764496467196,0.4503709362581851,
-                                  0.7561633288952461},
-                                 {0.3475715242389821,0.664911724487218 ,0.7954499607897292,
-                                  0.9271778194794527,0.2346420818554535,0.3993159158093081,
-                                  0.1524160133304174}},
-                              
-                                {{0.9924835021583752,0.9270009679242953,0.5399571302805596,
-                                  0.8420332943764213,0.5209579772720422,0.6235856880027597,
-                                  0.0891244321160166},
-                                 {0.7552704204968079,0.1277134836352348,0.8260676302525284,
-                                  0.7820280876703859,0.7087446977429764,0.0361603805247621,
-                                  0.3031283559453286},
-                                 {0.2631125699108429,0.3601364074715191,0.0876427467638385,
-                                  0.9369578230310628,0.5538022407123763,0.3055243106580235,
-                                  0.3969815170742834},
-                                 {0.4472025405048357,0.6005943333606173,0.5156794276964978,
-                                  0.9193919732144173,0.4969634829058303,0.9921580148233127,
-                                  0.8514249577450957},
-                                 {0.2085105143573358,0.9305952146439163,0.1163663978854761,
-                                  0.8174497084911916,0.3806232934765801,0.8779743204450695,
-                                  0.8680566901074503},
-                                 {0.8059254001176211,0.7900304363070614,0.3046791390980408,
-                                  0.0809192830512522,0.4029801787651615,0.1735245149865087,
-                                  0.6949510889024617}}}};
+        xarray<double> py_w = {
+            {{{0.0130944565883336,
+               0.6635373720167106,
+               0.1780359668697514,
+               0.9610703174694551,
+               0.148662727753113,
+               0.4146241237270237,
+               0.0853496680786439},
+              {0.9968742518459474,
+               0.5021950103312426,
+               0.5953850173200438,
+               0.0670764773884275,
+               0.7499604703991778,
+               0.2099055930955858,
+               0.8980542894407137},
+              {0.2051396404820072,
+               0.1906877206636666,
+               0.0365496678480949,
+               0.4720669451099992,
+               0.5648411332626164,
+               0.0657086394283524,
+               0.7755276166950106},
+              {0.4532888347480276,
+               0.52439026932758,
+               0.4407627469382281,
+               0.400763060875326,
+               0.5596403313082179,
+               0.1552402459307125,
+               0.1819281304952711},
+              {0.8617856210135173,
+               0.9461154621336327,
+               0.3733093162797529,
+               0.2707446731435538,
+               0.6439995432390158,
+               0.4087341710980964,
+               0.0253863556603449},
+              {0.1561525973661904,
+               0.7159722288473975,
+               0.6589239419101514,
+               0.0270959925034835,
+               0.2219721619329494,
+               0.2310747965880714,
+               0.6718927435987284}},
+
+             {{0.0197105377543642,
+               0.1041085819845738,
+               0.7999160853731894,
+               0.1785446620543336,
+               0.6527461078518747,
+               0.2381827810467265,
+               0.0994413927593452},
+              {0.2431721909994541,
+               0.7222669318556592,
+               0.8556964681062857,
+               0.8302198645669916,
+               0.3971835296184548,
+               0.6680851365706462,
+               0.204984295415821},
+              {0.2931477302610133,
+               0.8963358185211198,
+               0.013001923510736,
+               0.0855085308544681,
+               0.2078862551460273,
+               0.0265322038738197,
+               0.1814354350897973},
+              {0.5830415609696922,
+               0.4214245505924979,
+               0.8926717110769748,
+               0.8174435617384409,
+               0.341817351697876,
+               0.2594234334312925,
+               0.3796924081672669},
+              {0.5902949425148077,
+               0.2680636408228763,
+               0.624148907849134,
+               0.4094116521912404,
+               0.5520471808519802,
+               0.4361265291353167,
+               0.2944657595419177},
+              {0.9484533069621567,
+               0.7636057941597608,
+               0.1401131757664525,
+               0.8684679758979128,
+               0.4874311982495136,
+               0.8945522268940914,
+               0.7998552559473152}},
+
+             {{0.4252135044692334,
+               0.0224693083201174,
+               0.2686773593849461,
+               0.5416342146608669,
+               0.6334782198261473,
+               0.2578876854332023,
+               0.1393560740728241},
+              {0.8349302367992991,
+               0.9844021807035521,
+               0.5256901823026858,
+               0.1716792858483035,
+               0.272307326519369,
+               0.0183906765474667,
+               0.914298806560499},
+              {0.1177510828901411,
+               0.5765164755142536,
+               0.274055220687206,
+               0.5541780025157934,
+               0.6514203883518642,
+               0.8297418037072016,
+               0.2064212717606032},
+              {0.0109958286584805,
+               0.1368856300688073,
+               0.9000186418481051,
+               0.8738900775625152,
+               0.5974131021703083,
+               0.6005168604336534,
+               0.6650366745462555},
+              {0.1753712786234496,
+               0.9144119459249598,
+               0.4187705248920731,
+               0.3831385282494975,
+               0.5189177052828375,
+               0.046965966775055,
+               0.1662833687560794},
+              {0.7380336164263704,
+               0.0827986679251265,
+               0.6031521094663882,
+               0.245349109681321,
+               0.3892956140419765,
+               0.2886937367706999,
+               0.3556727164649491}},
+
+             {{0.7190459051842455,
+               0.297121715623175,
+               0.5664046402968972,
+               0.4760504021990997,
+               0.6636711653626481,
+               0.936829739324758,
+               0.7325720972102503},
+              {0.2149403785907568,
+               0.0311831350612847,
+               0.2622640442998251,
+               0.5950779307002548,
+               0.0514258134842503,
+               0.4963662472012363,
+               0.5968428489168892},
+              {0.3342438908169608,
+               0.7709122037458219,
+               0.1065982531337718,
+               0.0751377817358088,
+               0.7281887562036033,
+               0.4954913162061985,
+               0.688402396427736},
+              {0.4348273386037462,
+               0.2464020332391068,
+               0.8191023176741997,
+               0.7994158789689793,
+               0.6946964708544268,
+               0.2721451372299627,
+               0.5902306668690871},
+              {0.3609738969400268,
+               0.0915820733266342,
+               0.9173135754622428,
+               0.1368186309189614,
+               0.9502373538208024,
+               0.4460057729579557,
+               0.1851329288386196},
+              {0.5419009473783581,
+               0.8729458358764083,
+               0.7322248864095612,
+               0.8065611478614497,
+               0.6587833667107174,
+               0.6922765645178525,
+               0.8491956515653193}},
+
+             {{0.2496680088591859,
+               0.4894249636431405,
+               0.2212094418196022,
+               0.987668007996647,
+               0.9440593396866133,
+               0.0394268113685059,
+               0.7055751725156885},
+              {0.9252483174156658,
+               0.1805753451273335,
+               0.5679452305526295,
+               0.9154882975880418,
+               0.0339459785857988,
+               0.6974202672468399,
+               0.2973490073725508},
+              {0.9243961953765304,
+               0.9710582451653678,
+               0.9442664891134339,
+               0.4742142166574638,
+               0.8620426509893134,
+               0.8445493985350704,
+               0.3191004732432556},
+              {0.8289154741506773,
+               0.0370076347154926,
+               0.596269878482053,
+               0.230008837287703,
+               0.1205668857772788,
+               0.0769532016292092,
+               0.6962887758781398},
+              {0.3398749637680661,
+               0.7247667715287615,
+               0.0653563407989424,
+               0.3152903378306103,
+               0.5394912923753372,
+               0.7907231648389635,
+               0.3187525029320699},
+              {0.6258913764370091,
+               0.8859777482361871,
+               0.6158631881823046,
+               0.2329594747536338,
+               0.024400781556538,
+               0.8700988739009299,
+               0.0212694108503871}}},
+
+
+            {{{0.8747016726841994,
+               0.528937134027212,
+               0.9390676985128962,
+               0.7987832357736654,
+               0.9979341105333375,
+               0.3507118154517102,
+               0.7671882889311269},
+              {0.4019309136092422,
+               0.4798756203039088,
+               0.6275054632183701,
+               0.8736771141863388,
+               0.9840834691992951,
+               0.7682734138645182,
+               0.4177667821673338},
+              {0.4213570022770702,
+               0.7375823015888915,
+               0.2387771457683023,
+               0.1104741131313947,
+               0.3546221576407765,
+               0.2872389916540817,
+               0.2963081204559901},
+              {0.2336077510499099,
+               0.0420931896363619,
+               0.0178739347334138,
+               0.9877223897360315,
+               0.4277731337358623,
+               0.3843266471596817,
+               0.6796472826930698},
+              {0.2182538878650642,
+               0.9499611839502253,
+               0.786345014415552,
+               0.0894110023122595,
+               0.4175807757849284,
+               0.8791183075621647,
+               0.9447320222914103},
+              {0.4674015112498697,
+               0.6134113892107077,
+               0.1670339460920752,
+               0.9911686261369765,
+               0.2316717013834434,
+               0.9427317741351257,
+               0.6496466489923685}},
+
+             {{0.6077367948788591,
+               0.5126885110165086,
+               0.2306698117177587,
+               0.1765280320055083,
+               0.2204862090701754,
+               0.1864382621442545,
+               0.7795844735667533},
+              {0.3501252591667301,
+               0.0578426765633964,
+               0.9691026301408113,
+               0.8837858849634257,
+               0.927752283195213,
+               0.9949078226464353,
+               0.1738952492194873},
+              {0.3962420189026588,
+               0.7582384757040913,
+               0.6960206180537922,
+               0.1538959063398551,
+               0.8158331249906178,
+               0.2244405718366607,
+               0.2238176148226231},
+              {0.5369744228934136,
+               0.5929399348417032,
+               0.5800862078378112,
+               0.0914868373977549,
+               0.8774608626303804,
+               0.2656000425887061,
+               0.1295149212828042},
+              {0.8887480798689772,
+               0.9556514982297534,
+               0.8621276172654506,
+               0.8095160747248781,
+               0.6552419806390217,
+               0.5508573706091393,
+               0.0869867599114101},
+              {0.4084532130706987,
+               0.372688517012314,
+               0.2597537837603262,
+               0.7234201136885849,
+               0.4958757350787708,
+               0.0810462159076479,
+               0.2201832019498113}},
+
+             {{0.6832587636595959,
+               0.0761308594903002,
+               0.8512069140487687,
+               0.4951465270139743,
+               0.480586577326648,
+               0.5924077846595176,
+               0.8246809659251492},
+              {0.3478092079021931,
+               0.6780161525590636,
+               0.5657319639957911,
+               0.2670282701694213,
+               0.878629986355158,
+               0.7974260216069281,
+               0.6584518346584255},
+              {0.8505817290942419,
+               0.8672942009598024,
+               0.7083629767150348,
+               0.837013328363672,
+               0.6974714616692836,
+               0.6801407717603004,
+               0.6186113782151843},
+              {0.7527166395576412,
+               0.1586051052930737,
+               0.8808707591989284,
+               0.871843527745232,
+               0.0292472830345591,
+               0.8258167505647627,
+               0.1288698674734452},
+              {0.3351188542591419,
+               0.7435082562916078,
+               0.1607598960483082,
+               0.8179670241190622,
+               0.8321341779577419,
+               0.5074677337608362,
+               0.0063858717168336},
+              {0.2870381331749128,
+               0.6169269183757422,
+               0.9811861780274235,
+               0.6318135270166684,
+               0.2598035810641598,
+               0.6340057030996114,
+               0.5399853797158555}},
+
+             {{0.7798453951511436,
+               0.1069806388269584,
+               0.761027902502028,
+               0.5412665786761103,
+               0.9629920038589946,
+               0.3418721660386861,
+               0.6326218931339481},
+              {0.9320281055100175,
+               0.1025097279906793,
+               0.9372284872364511,
+               0.6878857223008134,
+               0.0678370591051719,
+               0.3009635669468163,
+               0.7081720886452816},
+              {0.0673506014687717,
+               0.5821704601762733,
+               0.3458830569529567,
+               0.6209155177674771,
+               0.0457420338125129,
+               0.8715368061523763,
+               0.9734889691773969},
+              {0.9688778552856915,
+               0.7496518317429247,
+               0.130086240130632,
+               0.7582631959290226,
+               0.0245869164588015,
+               0.0221235515289973,
+               0.3236102191495412},
+              {0.4886431904046658,
+               0.7704074178077932,
+               0.6832953766065052,
+               0.4459027063767483,
+               0.2736266662816659,
+               0.9971245001577111,
+               0.4261813022359729},
+              {0.4513870243296755,
+               0.1636238211916692,
+               0.7948095487499294,
+               0.6936822257814886,
+               0.2207696127887604,
+               0.0823810456158427,
+               0.6804993020747131}},
+
+             {{0.6545112142811352,
+               0.2732595269982093,
+               0.9508635622504104,
+               0.1510578917809002,
+               0.4323348010426019,
+               0.9436159201675989,
+               0.4197273169261223},
+              {0.6385259476640855,
+               0.3975943979627943,
+               0.27421520234867,
+               0.9839776479598282,
+               0.409334006315043,
+               0.8940992036791344,
+               0.2299546058910862},
+              {0.2131047040250833,
+               0.0311340828845114,
+               0.651666825375885,
+               0.3685263437237611,
+               0.864358249839637,
+               0.4732099066915572,
+               0.9681934279147217},
+              {0.1855255157031211,
+               0.8686231679556108,
+               0.7765968527917417,
+               0.770921844644052,
+               0.8447832281168877,
+               0.7610239909429989,
+               0.6262203216314154},
+              {0.1312448776823876,
+               0.0325261794912519,
+               0.9208478478156868,
+               0.616650314520738,
+               0.7965372909761763,
+               0.4815223515125501,
+               0.1173081889623945},
+              {0.1251857922025504,
+               0.6855652872289714,
+               0.4303058948994627,
+               0.2005247267003367,
+               0.4915945467414369,
+               0.0642089370751341,
+               0.5819714019143988}}},
+
+
+            {{{0.2689934044350977,
+               0.7975591006371882,
+               0.3103619589235738,
+               0.4552201490818012,
+               0.0116205399081006,
+               0.0724468877945589,
+               0.3924935564066848},
+              {0.4799388347171235,
+               0.6000205481193037,
+               0.2916625787093032,
+               0.6949818861265425,
+               0.8601223971892046,
+               0.7798509888933498,
+               0.0396188253483571},
+              {0.4805069472578289,
+               0.1049301784181749,
+               0.2420450158625275,
+               0.9866625932671464,
+               0.1424955429015132,
+               0.4988881534513561,
+               0.6181557343181191},
+              {0.702464970544104,
+               0.5596486834869141,
+               0.0097708474191837,
+               0.3264613082439919,
+               0.5177116433847114,
+               0.0878664991448334,
+               0.3506269312091808},
+              {0.0332031087913666,
+               0.0785784971550207,
+               0.3969232762015961,
+               0.1327157540430604,
+               0.5675408482615582,
+               0.6894649691372657,
+               0.8005866991090829},
+              {0.2001502442448101,
+               0.1674825822590698,
+               0.1045678403344003,
+               0.6364302495436367,
+               0.7064757264869012,
+               0.031586144825642,
+               0.9362122462436898}},
+
+             {{0.0519712836514724,
+               0.5412963353010705,
+               0.7090605194509164,
+               0.8709691237460856,
+               0.7140869321324278,
+               0.8017280830697918,
+               0.3394501925428061},
+              {0.8148251137465122,
+               0.0801148463846751,
+               0.8948166560605276,
+               0.5475923761537362,
+               0.8172977699624937,
+               0.4523182845183001,
+               0.643577695196525},
+              {0.5264026609361132,
+               0.7315895217553319,
+               0.0816299820305896,
+               0.0603520839905638,
+               0.2471032340101464,
+               0.1595446801131883,
+               0.8717835665922017},
+              {0.2192139873580443,
+               0.9758652558191313,
+               0.3368957917711068,
+               0.1821179156886993,
+               0.7896985071424791,
+               0.6587077755008761,
+               0.498195716453139},
+              {0.5553635509376312,
+               0.7192017782722638,
+               0.2284547413312987,
+               0.9963339160567419,
+               0.9747931621467831,
+               0.6503256863469369,
+               0.1995424509291451},
+              {0.6802282424312913,
+               0.0721984089791758,
+               0.0306525022058061,
+               0.2576828885112137,
+               0.4626229567393163,
+               0.8682725054083805,
+               0.727169069766308}},
+
+             {{0.742706521199981,
+               0.4254933344480754,
+               0.3459349925469629,
+               0.3710387629846027,
+               0.9876495637360578,
+               0.0401091914124825,
+               0.8670314961224486},
+              {0.5786754085723934,
+               0.4386154191895905,
+               0.7252576604151365,
+               0.4866689414247029,
+               0.8734232380816606,
+               0.9007018640112585,
+               0.4217209268734554},
+              {0.2768277972350516,
+               0.5923503285933622,
+               0.912363345616691,
+               0.2106621890056666,
+               0.6229665835634828,
+               0.6315602200925206,
+               0.733113022415281},
+              {0.1315676851272598,
+               0.7158249646820886,
+               0.909032520665641,
+               0.179683108870242,
+               0.2375433249238776,
+               0.9713950940416396,
+               0.1809769527094898},
+              {0.8543850933695791,
+               0.4922778564480348,
+               0.247231074403177,
+               0.8707499012725114,
+               0.4453052550026655,
+               0.5148173539296902,
+               0.3592333693997657},
+              {0.5929508514349274,
+               0.1635238725850228,
+               0.3910815366517607,
+               0.9694123223352875,
+               0.2581334327011275,
+               0.6567366645412922,
+               0.3251900642246949}},
+
+             {{0.7734731256866006,
+               0.1308736607183498,
+               0.9698210450785447,
+               0.4537895413836392,
+               0.236050463346464,
+               0.0734967473300127,
+               0.1697579050875407},
+              {0.5197739485560177,
+               0.3370031764312863,
+               0.8288833658826095,
+               0.4308875236618059,
+               0.2487142725876299,
+               0.61714498660403,
+               0.7067772168854458},
+              {0.1670419079009499,
+               0.1676192162883177,
+               0.036671426933543,
+               0.7364020150656405,
+               0.6638045276218051,
+               0.4746308757498139,
+               0.8441704489691971},
+              {0.8056701529500532,
+               0.5853543643967521,
+               0.8682712805132586,
+               0.2058412100367683,
+               0.1119196193977279,
+               0.2697496115169896,
+               0.0570868560893149},
+              {0.531169528001032,
+               0.9366056922949615,
+               0.0393435406685096,
+               0.1221099140100268,
+               0.4521990282834353,
+               0.9338750175279049,
+               0.3161561049767505},
+              {0.5072348086883924,
+               0.0415728590503921,
+               0.1483432009620889,
+               0.9866301229588469,
+               0.9651186964360455,
+               0.0049399809344096,
+               0.951811785423239}},
+
+             {{0.6391199378155004,
+               0.8679182945200221,
+               0.4547398556338591,
+               0.5155960285792502,
+               0.4888465802569202,
+               0.6668642575461043,
+               0.1396512547563129},
+              {0.029973589872678,
+               0.3079299415911909,
+               0.7046807627366467,
+               0.2018534521229484,
+               0.6734324333249173,
+               0.9699120461072704,
+               0.0939007157894184},
+              {0.6726021182251263,
+               0.4437502193045711,
+               0.8681422543775054,
+               0.1771497894473859,
+               0.6926259522261645,
+               0.8381152896481102,
+               0.9446142194740232},
+              {0.6832480282896458,
+               0.4971747640084273,
+               0.6178472402012138,
+               0.8689049844787182,
+               0.5706097466388297,
+               0.0303870596968369,
+               0.9309486955069778},
+              {0.6895267510315611,
+               0.6765133857772465,
+               0.2156751523977172,
+               0.6588854702326572,
+               0.3938644056541585,
+               0.6512329770414921,
+               0.1065930303079907},
+              {0.657845304603036,
+               0.9994137257706666,
+               0.048212038860556,
+               0.9771741842213173,
+               0.4069079607228706,
+               0.8707534503372591,
+               0.7823854840582735}}},
+
+
+            {{{0.5670162609866678,
+               0.7384492092513265,
+               0.8785155613013479,
+               0.404140321651033,
+               0.3270331615632387,
+               0.6675933855635847,
+               0.8078459419412586},
+              {0.7622851347766157,
+               0.7978136488586345,
+               0.435583314812933,
+               0.8178342161750216,
+               0.1202090553706084,
+               0.5444890979608495,
+               0.0057586604981216},
+              {0.3245858299002703,
+               0.3664615348713979,
+               0.3961726916092554,
+               0.6954672066898622,
+               0.3885581012703457,
+               0.4486936226225307,
+               0.2375441308743275},
+              {0.3732517916293401,
+               0.2272696272631515,
+               0.0731959237684436,
+               0.6034485933813779,
+               0.6682127985550163,
+               0.6194903460096145,
+               0.4634940438005724},
+              {0.3797857801792298,
+               0.8633336495718252,
+               0.519081785136218,
+               0.479181877629731,
+               0.0256420658064357,
+               0.3412478276261564,
+               0.3801956187858571},
+              {0.3988227808969005,
+               0.5801723692273323,
+               0.5336025467268785,
+               0.6079050927934446,
+               0.7648832615421283,
+               0.8129857387160935,
+               0.7181230762264944}},
+
+             {{0.9555236959549347,
+               0.0182325826763616,
+               0.1957779856835461,
+               0.0075628749781421,
+               0.647474714154603,
+               0.8980305489499869,
+               0.2434822965762993},
+              {0.9270345447963066,
+               0.0602673902895609,
+               0.9344360268055143,
+               0.3516226872396344,
+               0.1014208284492165,
+               0.4858717591863256,
+               0.2567765677205079},
+              {0.2848729019619228,
+               0.3072899649262866,
+               0.8030258978326634,
+               0.5391612766752545,
+               0.3113076991560036,
+               0.6103337833109184,
+               0.7161506742231936},
+              {0.2726240007335338,
+               0.4135491015253515,
+               0.1218860933369476,
+               0.1811493495346803,
+               0.6811178539649828,
+               0.1814383476956269,
+               0.5251633836670602},
+              {0.7090462617224327,
+               0.1068769230947438,
+               0.5673122196289035,
+               0.2565627837013638,
+               0.9629268752375798,
+               0.4835456467199247,
+               0.8059925497751581},
+              {0.5502265421562618,
+               0.0434125328548192,
+               0.6331513755940223,
+               0.951403342206657,
+               0.6016118201463312,
+               0.8191888594267902,
+               0.8842064633484078}},
+
+             {{0.2280797719489325,
+               0.2120448399082266,
+               0.6109809888509917,
+               0.4110284698067047,
+               0.8398613028667203,
+               0.9000231233980112,
+               0.3534213793027181},
+              {0.2368705589744821,
+               0.7805255152438618,
+               0.2748060355481361,
+               0.8226143185136784,
+               0.4237382536487628,
+               0.6675498992914705,
+               0.0955353138346682},
+              {0.623859324676573,
+               0.4517676787372291,
+               0.5866084631754741,
+               0.1680142077448634,
+               0.7368737449441821,
+               0.8627970775432285,
+               0.2167398000907756},
+              {0.0957145555201617,
+               0.0236385860463364,
+               0.641971500443266,
+               0.6070940360887808,
+               0.54669741271407,
+               0.2319470961159754,
+               0.3909059959055147},
+              {0.594476335186173,
+               0.4967668588591694,
+               0.9877855202148873,
+               0.1364397525567331,
+               0.6951445540475938,
+               0.4043187681042921,
+               0.4281996149256148},
+              {0.7175977656581762,
+               0.6924361513243696,
+               0.9912559937021883,
+               0.1283942894541252,
+               0.1041096493841663,
+               0.7243388171287412,
+               0.5783869170064091}},
+
+             {{0.2741606665598059,
+               0.0794193689889866,
+               0.0856582495964305,
+               0.8941908746641183,
+               0.1918673247187429,
+               0.3233715621155208,
+               0.226656402226988},
+              {0.3549963058319373,
+               0.0694238427460934,
+               0.5190597909082704,
+               0.0676125635922149,
+               0.8003565078223616,
+               0.233712081910433,
+               0.5400119146045106},
+              {0.8800790875614583,
+               0.6508773690471942,
+               0.5329577865513353,
+               0.3243337531153756,
+               0.3330019130581979,
+               0.6694869551981901,
+               0.9941393612211675},
+              {0.6618391898493786,
+               0.5577834173700249,
+               0.7306505102392461,
+               0.4652056122837182,
+               0.0601423426007852,
+               0.5622968158779098,
+               0.9576252845053802},
+              {0.1753029423576596,
+               0.6900048908206657,
+               0.2009336886590565,
+               0.5358276844730813,
+               0.0966764496467196,
+               0.4503709362581851,
+               0.7561633288952461},
+              {0.3475715242389821,
+               0.664911724487218,
+               0.7954499607897292,
+               0.9271778194794527,
+               0.2346420818554535,
+               0.3993159158093081,
+               0.1524160133304174}},
+
+             {{0.9924835021583752,
+               0.9270009679242953,
+               0.5399571302805596,
+               0.8420332943764213,
+               0.5209579772720422,
+               0.6235856880027597,
+               0.0891244321160166},
+              {0.7552704204968079,
+               0.1277134836352348,
+               0.8260676302525284,
+               0.7820280876703859,
+               0.7087446977429764,
+               0.0361603805247621,
+               0.3031283559453286},
+              {0.2631125699108429,
+               0.3601364074715191,
+               0.0876427467638385,
+               0.9369578230310628,
+               0.5538022407123763,
+               0.3055243106580235,
+               0.3969815170742834},
+              {0.4472025405048357,
+               0.6005943333606173,
+               0.5156794276964978,
+               0.9193919732144173,
+               0.4969634829058303,
+               0.9921580148233127,
+               0.8514249577450957},
+              {0.2085105143573358,
+               0.9305952146439163,
+               0.1163663978854761,
+               0.8174497084911916,
+               0.3806232934765801,
+               0.8779743204450695,
+               0.8680566901074503},
+              {0.8059254001176211,
+               0.7900304363070614,
+               0.3046791390980408,
+               0.0809192830512522,
+               0.4029801787651615,
+               0.1735245149865087,
+               0.6949510889024617}}}
+        };
         // py_av
-        xarray<double> py_av = {{0.5106795969797712,0.6397044109091891,0.5112635235731234,
-                                 0.4586765467957137,0.4869877873873078,0.4943932998356453,
-                                 0.4385520508602098},
-                                {0.5978927985524186,0.559905994727937 ,0.619729942105118 ,
-                                 0.4653893064895739,0.5937783013353551,0.5048245639269587,
-                                 0.5831376677923145},
-                                {0.4165551320778472,0.4546935552796757,0.3973719402163453,
-                                 0.4544365450264588,0.5634293281574402,0.4992966676969995,
-                                 0.4805121186481612},
-                                {0.5571737102656098,0.4734357748888989,0.5334877219467363,
-                                 0.4183775498265881,0.4971210216796947,0.475560939392655 ,
-                                 0.5715317612540888},
-                                {0.6780835926478442,0.4848427790974752,0.5816075391773083,
-                                 0.5583959492918773,0.4287789529418257,0.4549499764850471,
-                                 0.2909222329544836},
-                                {0.455560911393571 ,0.4523219422883247,0.5616099216331595,
-                                 0.3817307280172807,0.4162942894756477,0.2873504573593249,
-                                 0.423361164166236 }};
-
-        auto av = xt::average(py_a, py_w, {0,1});
+        xarray<double> py_av = {
+            {0.5106795969797712,
+             0.6397044109091891,
+             0.5112635235731234,
+             0.4586765467957137,
+             0.4869877873873078,
+             0.4943932998356453,
+             0.4385520508602098},
+            {0.5978927985524186,
+             0.559905994727937,
+             0.619729942105118,
+             0.4653893064895739,
+             0.5937783013353551,
+             0.5048245639269587,
+             0.5831376677923145},
+            {0.4165551320778472,
+             0.4546935552796757,
+             0.3973719402163453,
+             0.4544365450264588,
+             0.5634293281574402,
+             0.4992966676969995,
+             0.4805121186481612},
+            {0.5571737102656098,
+             0.4734357748888989,
+             0.5334877219467363,
+             0.4183775498265881,
+             0.4971210216796947,
+             0.475560939392655,
+             0.5715317612540888},
+            {0.6780835926478442,
+             0.4848427790974752,
+             0.5816075391773083,
+             0.5583959492918773,
+             0.4287789529418257,
+             0.4549499764850471,
+             0.2909222329544836},
+            {0.455560911393571,
+             0.4523219422883247,
+             0.5616099216331595,
+             0.3817307280172807,
+             0.4162942894756477,
+             0.2873504573593249,
+             0.423361164166236}
+        };
 
+        auto av = xt::average(py_a, py_w, {0, 1});
         EXPECT_TRUE(xt::allclose(av, py_av));
     }
 
@@ -815,443 +1816,1020 @@ namespace xt
     a  = np.random.random(4*5*6*7).reshape(4,5,6,7)
     vr_all = np.var(a)
     st_all = np.std(a)
+    vr_all_ddof = np.var(a, ddof=1)
     vr = np.var(a, axis=(0,2))
     st = np.std(a, axis=(0,2))
+    vr_ddof = np.var(a, axis=(0,2), ddof=1)
     */
     TEST(xtest_extended_xmath, var_std)
     {
         // py_a
-        xarray<double> py_a = {{{{0.3460997265377855,0.9756102008599149,0.640972077345332 ,
-                                  0.822480563634361 ,0.1325246727418484,0.8620144822726226,
-                                  0.9227571905133943},
-                                 {0.4870619188189359,0.6062529377509774,0.7648098009029954,
-                                  0.1748386272604125,0.5025660764634424,0.3986630277723131,
-                                  0.1463739921622491},
-                                 {0.3675344222915314,0.0681723093854936,0.025811906949487 ,
-                                  0.1351662891548228,0.9631151115891738,0.549529535895017 ,
-                                  0.96582216115322  },
-                                 {0.432497878330132 ,0.3118161330852596,0.5061418628402441,
-                                  0.4395116886329101,0.1056646842617439,0.6408263146902062,
-                                  0.2160381825095996},
-                                 {0.6195879548978296,0.6502010923981534,0.1520248531286481,
-                                  0.0613496271106682,0.7807615860684398,0.4598004237693202,
-                                  0.0581637955054758},
-                                 {0.9948663171697671,0.0577805609963666,0.6950352288585532,
-                                  0.9836789252634136,0.2391801042159256,0.1422493686871962,
-                                  0.1213849394224289}},
-                              
-                                {{0.3032751475675955,0.1010458110106467,0.6921613416941319,
-                                  0.0622917981300627,0.5094221281497897,0.9966968538529768,
-                                  0.8139702695060188},
-                                 {0.6152194382310109,0.3062536207866117,0.6238958362916385,
-                                  0.5270414639116516,0.4260833838903715,0.1307103767401995,
-                                  0.8866042152404667},
-                                 {0.4497846488213225,0.1946225118207651,0.3677593508772896,
-                                  0.414129752528927 ,0.8275378955668743,0.733614380561402 ,
-                                  0.7693048936413398},
-                                 {0.0110312644286472,0.4161539981797615,0.4813441516353236,
-                                  0.0191922768230567,0.2598132087450342,0.760289823122135 ,
-                                  0.1371097057289991},
-                                 {0.5353101314525917,0.2152018720172375,0.0121207746438933,
-                                  0.2412014575995415,0.9758737549100538,0.8015371118829896,
-                                  0.9595766443210334},
-                                 {0.4878540439263624,0.1097361986775035,0.547959488973693 ,
-                                  0.4543773345599609,0.844357082739616 ,0.0980825807842446,
-                                  0.4882411370217782}},
-                              
-                                {{0.1500486646939843,0.32467592689006  ,0.7373570773877997,
-                                  0.4760181293687665,0.3758882851457693,0.3944762785700353,
-                                  0.4594467684059866},
-                                 {0.7850165438370569,0.8920846889402344,0.9553346865039283,
-                                  0.7869033862552951,0.3154068957480127,0.6881347060865421,
-                                  0.4376031240553919},
-                                 {0.2546706220460512,0.8408715794259226,0.038426348962325 ,
-                                  0.9017619921354235,0.4614774646247342,0.6372014768082804,
-                                  0.6593539222057827},
-                                 {0.8951177407065364,0.6366696821672073,0.6139335847600618,
-                                  0.06665204056069  ,0.5184080219452041,0.1501690008170417,
-                                  0.7374337687214856},
-                                 {0.5122219208126745,0.6802277792083533,0.0416729006023843,
-                                  0.0847920160458032,0.7163233880626823,0.0720843359986734,
-                                  0.0712567277652586},
-                                 {0.0121084752348875,0.9565013982994801,0.737508359459007 ,
-                                  0.3532514085020642,0.2965355812876552,0.3497032297458496,
-                                  0.7746535311811819}},
-                              
-                                {{0.6613706110704144,0.1851955678674679,0.1741093353340843,
-                                  0.0983956497133973,0.6603027197013381,0.7643726622217359,
-                                  0.265046428325004 },
-                                 {0.0209449610309128,0.0821716674764273,0.9678600348450305,
-                                  0.2954447774774203,0.7692231478381336,0.6246635688542638,
-                                  0.3819396396528959},
-                                 {0.2056872621955551,0.1213864181594064,0.6150129680388666,
-                                  0.774633780637788 ,0.6439042535411307,0.5303021332491583,
-                                  0.0419512234316363},
-                                 {0.9684887775943838,0.7987141916545746,0.2928220367009647,
-                                  0.9799703293588506,0.6018815896363221,0.5824226582072465,
-                                  0.7480731794295321},
-                                 {0.8117697880901376,0.6564786073315027,0.1280957463662   ,
-                                  0.3382675059944984,0.9280836403260497,0.2246156118438519,
-                                  0.3721670238375133},
-                                 {0.432076882944196 ,0.4394049896944522,0.6129395824945255,
-                                  0.9430758377447076,0.240692711832505 ,0.1215013763009181,
-                                  0.1974704898599373}},
-                              
-                                {{0.8869249002092695,0.645810812655206 ,0.2859067892391601,
-                                  0.8159469389686173,0.861369996363436 ,0.846514338690278 ,
-                                  0.9189265336395545},
-                                 {0.2522410201733616,0.7550419287462783,0.46053949727414  ,
-                                  0.8419985528900615,0.7284906771616132,0.7764474464997246,
-                                  0.6561618376810715},
-                                 {0.1774287694697069,0.5450269188969383,0.9846697395245082,
-                                  0.9373880664971189,0.0431737357970117,0.1648148157294371,
-                                  0.1317287734545619},
-                                 {0.7259799099852955,0.8177853298569451,0.2135113663106719,
-                                  0.505852692951829 ,0.8407030280112   ,0.7328015447662506,
-                                  0.5422372054918483},
-                                 {0.5903476904587729,0.50836054691628  ,0.2975484513188206,
-                                  0.5650219928590161,0.6888853020500907,0.8733229158608077,
-                                  0.6362913539792481},
-                                 {0.761121537043158 ,0.160071634954573 ,0.4615574744197899,
-                                  0.0093316198270933,0.246678864521623 ,0.7264617151130048,
-                                  0.9918099513493635}}},
-                              
-                              
-                               {{{0.0991780995872159,0.4014943158612883,0.8000709686991595,
-                                  0.2040356346288988,0.5550849493022862,0.7330712960296748,
-                                  0.615985450260179 },
-                                 {0.1880247346154161,0.3553845686857394,0.7837917844853972,
-                                  0.5542265141320166,0.0052296135429127,0.7609907600280938,
-                                  0.0353113549402391},
-                                 {0.7457337827312321,0.2024805601652374,0.9580734801193802,
-                                  0.3679407513020845,0.3269316163380791,0.1488880503324447,
-                                  0.3056042154902149},
-                                 {0.8766507618282006,0.9963343376272473,0.3683095305068483,
-                                  0.4486106309545426,0.722070938202737 ,0.8861957804650745,
-                                  0.5930443341867842},
-                                 {0.3915256981778293,0.4126218408486237,0.6956181464968069,
-                                  0.0032182636042787,0.6195893374598407,0.3554930104413574,
-                                  0.7941973312770843},
-                                 {0.0929906398231322,0.5882022669483905,0.4809728898861237,
-                                  0.6423255259052274,0.0648535944829683,0.5799837874281313,
-                                  0.5614845879595237}},
-                              
-                                {{0.5606600944161709,0.6034876665964548,0.6764679372263622,
-                                  0.8049889996807698,0.2698207201282143,0.8250494101800621,
-                                  0.4982556822634536},
-                                 {0.0770582791343312,0.0585509292439792,0.3342383186960608,
-                                  0.7848969771114676,0.7076809347409158,0.7886149646724064,
-                                  0.5172690564416094},
-                                 {0.4401989979554906,0.1474525267062839,0.3281927536093115,
-                                  0.4340193661738753,0.0886004296796172,0.2206119527112113,
-                                  0.5982252940637388},
-                                 {0.7356631142391898,0.9983475113929496,0.9331133313435577,
-                                  0.6425651995351915,0.421248053294072 ,0.6361773647082327,
-                                  0.785651618080232 },
-                                 {0.1183361909233873,0.4099048896962882,0.8398022856356172,
-                                  0.383832951933044 ,0.5718722712271865,0.5877693608621982,
-                                  0.1844762531336394},
-                                 {0.3622354416522884,0.3345112887419321,0.0261967085320648,
-                                  0.0241917638913552,0.8316970436757735,0.2730708099728124,
-                                  0.5180787662388154}},
-                              
-                                {{0.2987255735887731,0.9406792451153405,0.2592967588657737,
-                                  0.4296568127389351,0.8727302504846018,0.8419335667918086,
-                                  0.1861014178462773},
-                                 {0.8026433097957104,0.4581868867378927,0.4829688720853552,
-                                  0.1334799724159438,0.0806015137571247,0.7279393069737652,
-                                  0.4964611523552998},
-                                 {0.4368507026151796,0.7295082286523967,0.7655128989911097,
-                                  0.1589081676693536,0.6102251494776413,0.1353540822776855,
-                                  0.7513750860290457},
-                                 {0.6569551562671395,0.956614621083458 ,0.0689580163564212,
-                                  0.0570547211512543,0.2821870746932001,0.261705683735906 ,
-                                  0.2469787990719998},
-                                 {0.9062545805210367,0.2495461998495061,0.271949726128631 ,
-                                  0.7593982624179637,0.44973984245054  ,0.7767105569551812,
-                                  0.0653661575643852},
-                                 {0.4875711936733843,0.0336136001832826,0.0626532034553545,
-                                  0.906437453344411 ,0.1392453711175952,0.5324206822752171,
-                                  0.4110956026007065}},
-                              
-                                {{0.3473433262588427,0.8998333456872725,0.0218233967754895,
-                                  0.6637896861755891,0.9633944342135504,0.5601681834618419,
-                                  0.9368224620330918},
-                                 {0.0522578792860238,0.4187933190741614,0.2601577909620512,
-                                  0.7308209649807298,0.9812970904972467,0.2565300624442478,
-                                  0.6541746014740745},
-                                 {0.1980976327597401,0.5653302545716099,0.4639324866883362,
-                                  0.9720053296315371,0.6085272726964666,0.3495063720868188,
-                                  0.1140957848879334},
-                                 {0.1512468287349346,0.2253169299512351,0.250966661340298 ,
-                                  0.8506160578411378,0.5612227882825249,0.5233909113743664,
-                                  0.1147688718692175},
-                                 {0.860139693349435 ,0.7228143032084837,0.0676683619000016,
-                                  0.7078350972297687,0.5435382173426461,0.0817253457467783,
-                                  0.4583006415286565},
-                                 {0.484696287130047 ,0.1657745401632758,0.9456981470002823,
-                                  0.8499753714806619,0.6690223373291083,0.4622955610006072,
-                                  0.4117655415845085}},
-                              
-                                {{0.6509734671509542,0.5454318694069055,0.0622731058818856,
-                                  0.5125026487703317,0.8064036172328395,0.4592398775969581,
-                                  0.0519565775542684},
-                                 {0.7862781993840331,0.2013637821359744,0.2586208348880388,
-                                  0.1647063534322959,0.3302150648714975,0.756751505688635 ,
-                                  0.5193858595039373},
-                                 {0.2048812741507126,0.8778300781520408,0.8795818549515292,
-                                  0.8705784250460069,0.2387962113815393,0.4512393441809881,
-                                  0.9849896561408751},
-                                 {0.7720124763099904,0.0271674212255598,0.0652045912604921,
-                                  0.4639313768123328,0.9092202058615602,0.5387017979527142,
-                                  0.4978125080342902},
-                                 {0.1054736999566306,0.656780104724294 ,0.8221031606002255,
-                                  0.3804200075075623,0.7756118509253275,0.9644766539008116,
-                                  0.2037664591276891},
-                                 {0.5233296311947413,0.2871379580845755,0.7928544190338394,
-                                  0.5775933658811575,0.6345824175503038,0.7979141596158941,
-                                  0.3959704726624549}}},
-                              
-                              
-                               {{{0.9150900684070432,0.53302886724614  ,0.157954822835348 ,
-                                  0.6958991181688025,0.7932613504382544,0.3167616770675267,
-                                  0.857179256998753 },
-                                 {0.9061432547657664,0.2769044873778089,0.9835214727152221,
-                                  0.1407115280487584,0.20201566840249  ,0.1842248392380261,
-                                  0.8939897100078704},
-                                 {0.6542925523249619,0.1521042832222729,0.440323418368349 ,
-                                  0.615298025069802 ,0.0834640849893833,0.8824163684073387,
-                                  0.8036035354415352},
-                                 {0.5052067735766382,0.9671266152591704,0.4177609792750997,
-                                  0.9841103190364978,0.6679199988036271,0.6346712732539415,
-                                  0.165954895295785 },
-                                 {0.881927758304644 ,0.4274896879206151,0.1622334057824794,
-                                  0.012607519975759 ,0.5597556836383826,0.5273996221226763,
-                                  0.7193536223691586},
-                                 {0.8902580530178021,0.0794065846430295,0.7314964903403623,
-                                  0.1874119440975822,0.858177053157164 ,0.8190635138616561,
-                                  0.5407937549855444}},
-                              
-                                {{0.7102427986233115,0.3143501131837484,0.4711678989328146,
-                                  0.8216368977104717,0.4592651971732139,0.3577982653254418,
-                                  0.4942124472502999},
-                                 {0.8282492524372184,0.3352080473708727,0.1737615931357438,
-                                  0.7120140203307808,0.8259782127080818,0.1006374785235333,
-                                  0.2398741127559447},
-                                 {0.1419719897609939,0.3479414115821666,0.4503509789054126,
-                                  0.7488263369633065,0.6511475848816741,0.6209285674784312,
-                                  0.3523749466096544},
-                                 {0.8414475530847599,0.4712871673981646,0.9791049380151545,
-                                  0.6341421382957368,0.1262647415645027,0.676177562075434 ,
-                                  0.325104015431699 },
-                                 {0.6863271966860974,0.0696411481624057,0.1748814371759594,
-                                  0.8557372589057863,0.2271795570235149,0.83704112524294  ,
-                                  0.2792760884544104},
-                                 {0.6428819100587077,0.694150573509831 ,0.5126547531450529,
-                                  0.3053106766967313,0.2126443763710961,0.0331893545624262,
-                                  0.3039464012407238}},
-                              
-                                {{0.653162790531283 ,0.9383048184484827,0.871204482263052 ,
-                                  0.7660647765353026,0.7884473432532987,0.6649849034759953,
-                                  0.260286857566003 },
-                                 {0.9071950307058299,0.670732311905834 ,0.56044063098044  ,
-                                  0.1109894692134811,0.4470555438064254,0.4603582712019263,
-                                  0.86456360952267  },
-                                 {0.5466482201877885,0.3804005489704096,0.9768003285106593,
-                                  0.1107205933263157,0.4225484283119446,0.0420246751714053,
-                                  0.7399041207669304},
-                                 {0.9180765521991506,0.2800373295504894,0.8583416767991209,
-                                  0.2922182304618978,0.9107701616439152,0.7539619035967839,
-                                  0.8049067768414386},
-                                 {0.0180065556004545,0.962810357074026 ,0.7266709920703233,
-                                  0.3047510953861333,0.8293946648588469,0.28152119841493  ,
-                                  0.872753839566128 },
-                                 {0.112580390411937 ,0.7036859774607958,0.5406984766449103,
-                                  0.0965344701954408,0.241893828258839 ,0.0124040362773148,
-                                  0.4687679654645058}},
-                              
-                                {{0.3012652607600004,0.5983574842977588,0.2972378077086172,
-                                  0.2999191115069847,0.7431931987316034,0.0481428359783534,
-                                  0.9028949951919872},
-                                 {0.8522638743911815,0.6678046832264065,0.5932215701073843,
-                                  0.8923024981396522,0.1853301795287144,0.0789691621908286,
-                                  0.2395101699095381},
-                                 {0.7945782787001903,0.0346702667264833,0.5828068350834896,
-                                  0.9954375161913099,0.8556960938375394,0.5214456890435895,
-                                  0.0636409092866423},
-                                 {0.8313735143857098,0.5989785081772105,0.1149329970595668,
-                                  0.0938572848233562,0.9096268194365924,0.6692002629380784,
-                                  0.8292867993167555},
-                                 {0.8789789002822673,0.5717723520483222,0.5174463517550413,
-                                  0.4304274103209902,0.3169465877911193,0.4345959608587118,
-                                  0.7738796557301564},
-                                 {0.6019234310151316,0.8925232899548461,0.4433800143791877,
-                                  0.607089578718754 ,0.6313075530919887,0.5916971623063255,
-                                  0.7026337730855163}},
-                              
-                                {{0.2374334683748063,0.5123637775457907,0.1042248028083477,
-                                  0.3845113276448126,0.4876670686212644,0.6522242595454725,
-                                  0.9505310525862035},
-                                 {0.6006510665483559,0.7435939161765598,0.5062660594952028,
-                                  0.6341040313763313,0.0709322161337734,0.254391580841847 ,
-                                  0.3618530932051387},
-                                 {0.4724933550065136,0.0456487455023837,0.1400240975533177,
-                                  0.2768143077913058,0.9715326909010507,0.3313470071030508,
-                                  0.4820410581120825},
-                                 {0.1960977127383929,0.6107800710757683,0.2806832155159743,
-                                  0.2069925784384268,0.5165726284459791,0.0055057991604208,
-                                  0.0076640326492253},
-                                 {0.2190688091018578,0.0367213625008211,0.1080257541306914,
-                                  0.3388606493387516,0.8025856795798129,0.5720486433693008,
-                                  0.5126677259564164},
-                                 {0.2934888232081216,0.9317537194328164,0.3970150412371917,
-                                  0.0870927667957715,0.6170665161178013,0.1138383934766014,
-                                  0.3452231428016921}}},
-                              
-                              
-                               {{{0.5074119387178089,0.8742225246851758,0.4935465803401187,
-                                  0.7022587660316643,0.9928168389990704,0.1314891198979816,
-                                  0.2747315255195195},
-                                 {0.3945760755976464,0.4218281785388314,0.4110210752655458,
-                                  0.9076110025565549,0.7140326444668564,0.6079052140907037,
-                                  0.3093727178627821},
-                                 {0.8237903842212947,0.9550605114849889,0.8211982825502265,
-                                  0.0015651051914729,0.636401370183407 ,0.0511353814421007,
-                                  0.2576072203337219},
-                                 {0.0595247003477717,0.6037954529493877,0.6865899134926068,
-                                  0.1144876380659051,0.3838388830449795,0.456236508955542 ,
-                                  0.3690530217609166},
-                                 {0.121025000485193 ,0.4189477901874754,0.7511780478084181,
-                                  0.0710076645332555,0.0801800140819035,0.3547712918359842,
-                                  0.941725711618925 },
-                                 {0.668572646722914 ,0.6786699566725648,0.361919990837865 ,
-                                  0.5936607912085384,0.0101311840277434,0.6360960464095422,
-                                  0.9132869475762367}},
-                              
-                                {{0.6125734683448192,0.873698593466345 ,0.7239730554660938,
-                                  0.1205584164036902,0.9024533072858417,0.0664438443557749,
-                                  0.5339674725477638},
-                                 {0.1421371237934577,0.0117066107309041,0.422034260127639 ,
-                                  0.2950407076541562,0.486000493797603 ,0.5771998867345508,
-                                  0.0437390723089474},
-                                 {0.1230032951237456,0.5586423964504253,0.3431673531726582,
-                                  0.729173487549448 ,0.6522916485919397,0.8456043629899068,
-                                  0.6924928266692253},
-                                 {0.4299310773901481,0.6729666223944324,0.2753811742554185,
-                                  0.3063134987782127,0.7889851599207933,0.4464195164015822,
-                                  0.7983803405183525},
-                                 {0.8224223736682784,0.8575623376612838,0.9166352358412073,
-                                  0.4309852205132962,0.3188668183211388,0.5821987465941139,
-                                  0.3711724234376276},
-                                 {0.601074166800233 ,0.7055858626438246,0.6884050184921369,
-                                  0.3745528870201214,0.1668602016987528,0.4305293384622075,
-                                  0.1425941440819087}},
-                              
-                                {{0.8900970351838083,0.3458774607378574,0.1544597472233238,
-                                  0.0254477599057509,0.6458223862864843,0.6369023174547432,
-                                  0.3406041665812917},
-                                 {0.071711888847651 ,0.409628894895232 ,0.3112174950633936,
-                                  0.6771206397350094,0.6057792494526903,0.36459372819754  ,
-                                  0.2178925542549901},
-                                 {0.9880359661555919,0.4540016211961149,0.688274235780237 ,
-                                  0.1405529675783608,0.4855896996593978,0.0275367198694655,
-                                  0.50545511791045  },
-                                 {0.9640174071177023,0.3842067129858002,0.0389960125749116,
-                                  0.0309557909193435,0.3879867599468695,0.160024936463194 ,
-                                  0.0233520963281859},
-                                 {0.7562136139501768,0.4585230088818907,0.2892447719726545,
-                                  0.9000831830164807,0.1161389602005256,0.9559188289553192,
-                                  0.3139667173773528},
-                                 {0.8884036723086812,0.6029428764794615,0.8267073597414875,
-                                  0.9840131632104643,0.2884054378187457,0.961135485407593 ,
-                                  0.3894818949024204}},
-                              
-                                {{0.3855119047369223,0.3403871042545057,0.5414076073475852,
-                                  0.1541450431784871,0.5537114853580112,0.541704812410004 ,
-                                  0.76190181260487  },
-                                 {0.8336499619375856,0.440441350312424 ,0.3023332493514937,
-                                  0.2593348973170945,0.1946238367048719,0.0576475821990249,
-                                  0.3424479788347133},
-                                 {0.2702476921307833,0.9664173858664074,0.5577088262500439,
-                                  0.3472770390305076,0.580467600993696 ,0.1391967013456955,
-                                  0.4440437492022029},
-                                 {0.6262343214210638,0.4888978317924514,0.4017788006543243,
-                                  0.9938483888996982,0.880314762148927 ,0.6234059581594401,
-                                  0.5693773611822828},
-                                 {0.620660479824584 ,0.2013121078224333,0.3951377432643186,
-                                  0.0394595328908993,0.4755460374868267,0.5430245839576632,
-                                  0.2277497361032096},
-                                 {0.9640288471655137,0.909454610937242 ,0.7221432354559059,
-                                  0.5333866287653626,0.869969159647685 ,0.1306523438234629,
-                                  0.790509794274885 }},
-                              
-                                {{0.1248208139668483,0.7942106625494054,0.275767568251357 ,
-                                  0.8770905810181889,0.9440420938253978,0.1487959694051156,
-                                  0.4626756050653935},
-                                 {0.9809873781626851,0.4834074359731466,0.8635475225145451,
-                                  0.5887315221313199,0.3753299079196019,0.2857835555258702,
-                                  0.2032230910860873},
-                                 {0.7617981913776972,0.3865405068230279,0.5112754622007512,
-                                  0.4923254800011819,0.5772790292331312,0.8655771456245522,
-                                  0.9807393435834294},
-                                 {0.4075842085738169,0.8275189221063031,0.7645277946547177,
-                                  0.5735289514555733,0.9560471436119331,0.2004745155284028,
-                                  0.1092642103096214},
-                                 {0.8539619669554221,0.4391498166337483,0.8469688542070605,
-                                  0.8930902051954149,0.0624575936190714,0.8834647629860607,
-                                  0.4483190553694222},
-                                 {0.5104324890042322,0.6265925110932102,0.9263826067300868,
-                                  0.019116094429764 ,0.4768434683178171,0.6877220424305607,
-                                  0.7227069576982285}}}};
+        xarray<double> py_a = {
+            {{{0.3460997265377855,
+               0.9756102008599149,
+               0.640972077345332,
+               0.822480563634361,
+               0.1325246727418484,
+               0.8620144822726226,
+               0.9227571905133943},
+              {0.4870619188189359,
+               0.6062529377509774,
+               0.7648098009029954,
+               0.1748386272604125,
+               0.5025660764634424,
+               0.3986630277723131,
+               0.1463739921622491},
+              {0.3675344222915314,
+               0.0681723093854936,
+               0.025811906949487,
+               0.1351662891548228,
+               0.9631151115891738,
+               0.549529535895017,
+               0.96582216115322},
+              {0.432497878330132,
+               0.3118161330852596,
+               0.5061418628402441,
+               0.4395116886329101,
+               0.1056646842617439,
+               0.6408263146902062,
+               0.2160381825095996},
+              {0.6195879548978296,
+               0.6502010923981534,
+               0.1520248531286481,
+               0.0613496271106682,
+               0.7807615860684398,
+               0.4598004237693202,
+               0.0581637955054758},
+              {0.9948663171697671,
+               0.0577805609963666,
+               0.6950352288585532,
+               0.9836789252634136,
+               0.2391801042159256,
+               0.1422493686871962,
+               0.1213849394224289}},
+
+             {{0.3032751475675955,
+               0.1010458110106467,
+               0.6921613416941319,
+               0.0622917981300627,
+               0.5094221281497897,
+               0.9966968538529768,
+               0.8139702695060188},
+              {0.6152194382310109,
+               0.3062536207866117,
+               0.6238958362916385,
+               0.5270414639116516,
+               0.4260833838903715,
+               0.1307103767401995,
+               0.8866042152404667},
+              {0.4497846488213225,
+               0.1946225118207651,
+               0.3677593508772896,
+               0.414129752528927,
+               0.8275378955668743,
+               0.733614380561402,
+               0.7693048936413398},
+              {0.0110312644286472,
+               0.4161539981797615,
+               0.4813441516353236,
+               0.0191922768230567,
+               0.2598132087450342,
+               0.760289823122135,
+               0.1371097057289991},
+              {0.5353101314525917,
+               0.2152018720172375,
+               0.0121207746438933,
+               0.2412014575995415,
+               0.9758737549100538,
+               0.8015371118829896,
+               0.9595766443210334},
+              {0.4878540439263624,
+               0.1097361986775035,
+               0.547959488973693,
+               0.4543773345599609,
+               0.844357082739616,
+               0.0980825807842446,
+               0.4882411370217782}},
+
+             {{0.1500486646939843,
+               0.32467592689006,
+               0.7373570773877997,
+               0.4760181293687665,
+               0.3758882851457693,
+               0.3944762785700353,
+               0.4594467684059866},
+              {0.7850165438370569,
+               0.8920846889402344,
+               0.9553346865039283,
+               0.7869033862552951,
+               0.3154068957480127,
+               0.6881347060865421,
+               0.4376031240553919},
+              {0.2546706220460512,
+               0.8408715794259226,
+               0.038426348962325,
+               0.9017619921354235,
+               0.4614774646247342,
+               0.6372014768082804,
+               0.6593539222057827},
+              {0.8951177407065364,
+               0.6366696821672073,
+               0.6139335847600618,
+               0.06665204056069,
+               0.5184080219452041,
+               0.1501690008170417,
+               0.7374337687214856},
+              {0.5122219208126745,
+               0.6802277792083533,
+               0.0416729006023843,
+               0.0847920160458032,
+               0.7163233880626823,
+               0.0720843359986734,
+               0.0712567277652586},
+              {0.0121084752348875,
+               0.9565013982994801,
+               0.737508359459007,
+               0.3532514085020642,
+               0.2965355812876552,
+               0.3497032297458496,
+               0.7746535311811819}},
+
+             {{0.6613706110704144,
+               0.1851955678674679,
+               0.1741093353340843,
+               0.0983956497133973,
+               0.6603027197013381,
+               0.7643726622217359,
+               0.265046428325004},
+              {0.0209449610309128,
+               0.0821716674764273,
+               0.9678600348450305,
+               0.2954447774774203,
+               0.7692231478381336,
+               0.6246635688542638,
+               0.3819396396528959},
+              {0.2056872621955551,
+               0.1213864181594064,
+               0.6150129680388666,
+               0.774633780637788,
+               0.6439042535411307,
+               0.5303021332491583,
+               0.0419512234316363},
+              {0.9684887775943838,
+               0.7987141916545746,
+               0.2928220367009647,
+               0.9799703293588506,
+               0.6018815896363221,
+               0.5824226582072465,
+               0.7480731794295321},
+              {0.8117697880901376,
+               0.6564786073315027,
+               0.1280957463662,
+               0.3382675059944984,
+               0.9280836403260497,
+               0.2246156118438519,
+               0.3721670238375133},
+              {0.432076882944196,
+               0.4394049896944522,
+               0.6129395824945255,
+               0.9430758377447076,
+               0.240692711832505,
+               0.1215013763009181,
+               0.1974704898599373}},
+
+             {{0.8869249002092695,
+               0.645810812655206,
+               0.2859067892391601,
+               0.8159469389686173,
+               0.861369996363436,
+               0.846514338690278,
+               0.9189265336395545},
+              {0.2522410201733616,
+               0.7550419287462783,
+               0.46053949727414,
+               0.8419985528900615,
+               0.7284906771616132,
+               0.7764474464997246,
+               0.6561618376810715},
+              {0.1774287694697069,
+               0.5450269188969383,
+               0.9846697395245082,
+               0.9373880664971189,
+               0.0431737357970117,
+               0.1648148157294371,
+               0.1317287734545619},
+              {0.7259799099852955,
+               0.8177853298569451,
+               0.2135113663106719,
+               0.505852692951829,
+               0.8407030280112,
+               0.7328015447662506,
+               0.5422372054918483},
+              {0.5903476904587729,
+               0.50836054691628,
+               0.2975484513188206,
+               0.5650219928590161,
+               0.6888853020500907,
+               0.8733229158608077,
+               0.6362913539792481},
+              {0.761121537043158,
+               0.160071634954573,
+               0.4615574744197899,
+               0.0093316198270933,
+               0.246678864521623,
+               0.7264617151130048,
+               0.9918099513493635}}},
+
+
+            {{{0.0991780995872159,
+               0.4014943158612883,
+               0.8000709686991595,
+               0.2040356346288988,
+               0.5550849493022862,
+               0.7330712960296748,
+               0.615985450260179},
+              {0.1880247346154161,
+               0.3553845686857394,
+               0.7837917844853972,
+               0.5542265141320166,
+               0.0052296135429127,
+               0.7609907600280938,
+               0.0353113549402391},
+              {0.7457337827312321,
+               0.2024805601652374,
+               0.9580734801193802,
+               0.3679407513020845,
+               0.3269316163380791,
+               0.1488880503324447,
+               0.3056042154902149},
+              {0.8766507618282006,
+               0.9963343376272473,
+               0.3683095305068483,
+               0.4486106309545426,
+               0.722070938202737,
+               0.8861957804650745,
+               0.5930443341867842},
+              {0.3915256981778293,
+               0.4126218408486237,
+               0.6956181464968069,
+               0.0032182636042787,
+               0.6195893374598407,
+               0.3554930104413574,
+               0.7941973312770843},
+              {0.0929906398231322,
+               0.5882022669483905,
+               0.4809728898861237,
+               0.6423255259052274,
+               0.0648535944829683,
+               0.5799837874281313,
+               0.5614845879595237}},
+
+             {{0.5606600944161709,
+               0.6034876665964548,
+               0.6764679372263622,
+               0.8049889996807698,
+               0.2698207201282143,
+               0.8250494101800621,
+               0.4982556822634536},
+              {0.0770582791343312,
+               0.0585509292439792,
+               0.3342383186960608,
+               0.7848969771114676,
+               0.7076809347409158,
+               0.7886149646724064,
+               0.5172690564416094},
+              {0.4401989979554906,
+               0.1474525267062839,
+               0.3281927536093115,
+               0.4340193661738753,
+               0.0886004296796172,
+               0.2206119527112113,
+               0.5982252940637388},
+              {0.7356631142391898,
+               0.9983475113929496,
+               0.9331133313435577,
+               0.6425651995351915,
+               0.421248053294072,
+               0.6361773647082327,
+               0.785651618080232},
+              {0.1183361909233873,
+               0.4099048896962882,
+               0.8398022856356172,
+               0.383832951933044,
+               0.5718722712271865,
+               0.5877693608621982,
+               0.1844762531336394},
+              {0.3622354416522884,
+               0.3345112887419321,
+               0.0261967085320648,
+               0.0241917638913552,
+               0.8316970436757735,
+               0.2730708099728124,
+               0.5180787662388154}},
+
+             {{0.2987255735887731,
+               0.9406792451153405,
+               0.2592967588657737,
+               0.4296568127389351,
+               0.8727302504846018,
+               0.8419335667918086,
+               0.1861014178462773},
+              {0.8026433097957104,
+               0.4581868867378927,
+               0.4829688720853552,
+               0.1334799724159438,
+               0.0806015137571247,
+               0.7279393069737652,
+               0.4964611523552998},
+              {0.4368507026151796,
+               0.7295082286523967,
+               0.7655128989911097,
+               0.1589081676693536,
+               0.6102251494776413,
+               0.1353540822776855,
+               0.7513750860290457},
+              {0.6569551562671395,
+               0.956614621083458,
+               0.0689580163564212,
+               0.0570547211512543,
+               0.2821870746932001,
+               0.261705683735906,
+               0.2469787990719998},
+              {0.9062545805210367,
+               0.2495461998495061,
+               0.271949726128631,
+               0.7593982624179637,
+               0.44973984245054,
+               0.7767105569551812,
+               0.0653661575643852},
+              {0.4875711936733843,
+               0.0336136001832826,
+               0.0626532034553545,
+               0.906437453344411,
+               0.1392453711175952,
+               0.5324206822752171,
+               0.4110956026007065}},
+
+             {{0.3473433262588427,
+               0.8998333456872725,
+               0.0218233967754895,
+               0.6637896861755891,
+               0.9633944342135504,
+               0.5601681834618419,
+               0.9368224620330918},
+              {0.0522578792860238,
+               0.4187933190741614,
+               0.2601577909620512,
+               0.7308209649807298,
+               0.9812970904972467,
+               0.2565300624442478,
+               0.6541746014740745},
+              {0.1980976327597401,
+               0.5653302545716099,
+               0.4639324866883362,
+               0.9720053296315371,
+               0.6085272726964666,
+               0.3495063720868188,
+               0.1140957848879334},
+              {0.1512468287349346,
+               0.2253169299512351,
+               0.250966661340298,
+               0.8506160578411378,
+               0.5612227882825249,
+               0.5233909113743664,
+               0.1147688718692175},
+              {0.860139693349435,
+               0.7228143032084837,
+               0.0676683619000016,
+               0.7078350972297687,
+               0.5435382173426461,
+               0.0817253457467783,
+               0.4583006415286565},
+              {0.484696287130047,
+               0.1657745401632758,
+               0.9456981470002823,
+               0.8499753714806619,
+               0.6690223373291083,
+               0.4622955610006072,
+               0.4117655415845085}},
+
+             {{0.6509734671509542,
+               0.5454318694069055,
+               0.0622731058818856,
+               0.5125026487703317,
+               0.8064036172328395,
+               0.4592398775969581,
+               0.0519565775542684},
+              {0.7862781993840331,
+               0.2013637821359744,
+               0.2586208348880388,
+               0.1647063534322959,
+               0.3302150648714975,
+               0.756751505688635,
+               0.5193858595039373},
+              {0.2048812741507126,
+               0.8778300781520408,
+               0.8795818549515292,
+               0.8705784250460069,
+               0.2387962113815393,
+               0.4512393441809881,
+               0.9849896561408751},
+              {0.7720124763099904,
+               0.0271674212255598,
+               0.0652045912604921,
+               0.4639313768123328,
+               0.9092202058615602,
+               0.5387017979527142,
+               0.4978125080342902},
+              {0.1054736999566306,
+               0.656780104724294,
+               0.8221031606002255,
+               0.3804200075075623,
+               0.7756118509253275,
+               0.9644766539008116,
+               0.2037664591276891},
+              {0.5233296311947413,
+               0.2871379580845755,
+               0.7928544190338394,
+               0.5775933658811575,
+               0.6345824175503038,
+               0.7979141596158941,
+               0.3959704726624549}}},
+
+
+            {{{0.9150900684070432,
+               0.53302886724614,
+               0.157954822835348,
+               0.6958991181688025,
+               0.7932613504382544,
+               0.3167616770675267,
+               0.857179256998753},
+              {0.9061432547657664,
+               0.2769044873778089,
+               0.9835214727152221,
+               0.1407115280487584,
+               0.20201566840249,
+               0.1842248392380261,
+               0.8939897100078704},
+              {0.6542925523249619,
+               0.1521042832222729,
+               0.440323418368349,
+               0.615298025069802,
+               0.0834640849893833,
+               0.8824163684073387,
+               0.8036035354415352},
+              {0.5052067735766382,
+               0.9671266152591704,
+               0.4177609792750997,
+               0.9841103190364978,
+               0.6679199988036271,
+               0.6346712732539415,
+               0.165954895295785},
+              {0.881927758304644,
+               0.4274896879206151,
+               0.1622334057824794,
+               0.012607519975759,
+               0.5597556836383826,
+               0.5273996221226763,
+               0.7193536223691586},
+              {0.8902580530178021,
+               0.0794065846430295,
+               0.7314964903403623,
+               0.1874119440975822,
+               0.858177053157164,
+               0.8190635138616561,
+               0.5407937549855444}},
+
+             {{0.7102427986233115,
+               0.3143501131837484,
+               0.4711678989328146,
+               0.8216368977104717,
+               0.4592651971732139,
+               0.3577982653254418,
+               0.4942124472502999},
+              {0.8282492524372184,
+               0.3352080473708727,
+               0.1737615931357438,
+               0.7120140203307808,
+               0.8259782127080818,
+               0.1006374785235333,
+               0.2398741127559447},
+              {0.1419719897609939,
+               0.3479414115821666,
+               0.4503509789054126,
+               0.7488263369633065,
+               0.6511475848816741,
+               0.6209285674784312,
+               0.3523749466096544},
+              {0.8414475530847599,
+               0.4712871673981646,
+               0.9791049380151545,
+               0.6341421382957368,
+               0.1262647415645027,
+               0.676177562075434,
+               0.325104015431699},
+              {0.6863271966860974,
+               0.0696411481624057,
+               0.1748814371759594,
+               0.8557372589057863,
+               0.2271795570235149,
+               0.83704112524294,
+               0.2792760884544104},
+              {0.6428819100587077,
+               0.694150573509831,
+               0.5126547531450529,
+               0.3053106766967313,
+               0.2126443763710961,
+               0.0331893545624262,
+               0.3039464012407238}},
+
+             {{0.653162790531283,
+               0.9383048184484827,
+               0.871204482263052,
+               0.7660647765353026,
+               0.7884473432532987,
+               0.6649849034759953,
+               0.260286857566003},
+              {0.9071950307058299,
+               0.670732311905834,
+               0.56044063098044,
+               0.1109894692134811,
+               0.4470555438064254,
+               0.4603582712019263,
+               0.86456360952267},
+              {0.5466482201877885,
+               0.3804005489704096,
+               0.9768003285106593,
+               0.1107205933263157,
+               0.4225484283119446,
+               0.0420246751714053,
+               0.7399041207669304},
+              {0.9180765521991506,
+               0.2800373295504894,
+               0.8583416767991209,
+               0.2922182304618978,
+               0.9107701616439152,
+               0.7539619035967839,
+               0.8049067768414386},
+              {0.0180065556004545,
+               0.962810357074026,
+               0.7266709920703233,
+               0.3047510953861333,
+               0.8293946648588469,
+               0.28152119841493,
+               0.872753839566128},
+              {0.112580390411937,
+               0.7036859774607958,
+               0.5406984766449103,
+               0.0965344701954408,
+               0.241893828258839,
+               0.0124040362773148,
+               0.4687679654645058}},
+
+             {{0.3012652607600004,
+               0.5983574842977588,
+               0.2972378077086172,
+               0.2999191115069847,
+               0.7431931987316034,
+               0.0481428359783534,
+               0.9028949951919872},
+              {0.8522638743911815,
+               0.6678046832264065,
+               0.5932215701073843,
+               0.8923024981396522,
+               0.1853301795287144,
+               0.0789691621908286,
+               0.2395101699095381},
+              {0.7945782787001903,
+               0.0346702667264833,
+               0.5828068350834896,
+               0.9954375161913099,
+               0.8556960938375394,
+               0.5214456890435895,
+               0.0636409092866423},
+              {0.8313735143857098,
+               0.5989785081772105,
+               0.1149329970595668,
+               0.0938572848233562,
+               0.9096268194365924,
+               0.6692002629380784,
+               0.8292867993167555},
+              {0.8789789002822673,
+               0.5717723520483222,
+               0.5174463517550413,
+               0.4304274103209902,
+               0.3169465877911193,
+               0.4345959608587118,
+               0.7738796557301564},
+              {0.6019234310151316,
+               0.8925232899548461,
+               0.4433800143791877,
+               0.607089578718754,
+               0.6313075530919887,
+               0.5916971623063255,
+               0.7026337730855163}},
+
+             {{0.2374334683748063,
+               0.5123637775457907,
+               0.1042248028083477,
+               0.3845113276448126,
+               0.4876670686212644,
+               0.6522242595454725,
+               0.9505310525862035},
+              {0.6006510665483559,
+               0.7435939161765598,
+               0.5062660594952028,
+               0.6341040313763313,
+               0.0709322161337734,
+               0.254391580841847,
+               0.3618530932051387},
+              {0.4724933550065136,
+               0.0456487455023837,
+               0.1400240975533177,
+               0.2768143077913058,
+               0.9715326909010507,
+               0.3313470071030508,
+               0.4820410581120825},
+              {0.1960977127383929,
+               0.6107800710757683,
+               0.2806832155159743,
+               0.2069925784384268,
+               0.5165726284459791,
+               0.0055057991604208,
+               0.0076640326492253},
+              {0.2190688091018578,
+               0.0367213625008211,
+               0.1080257541306914,
+               0.3388606493387516,
+               0.8025856795798129,
+               0.5720486433693008,
+               0.5126677259564164},
+              {0.2934888232081216,
+               0.9317537194328164,
+               0.3970150412371917,
+               0.0870927667957715,
+               0.6170665161178013,
+               0.1138383934766014,
+               0.3452231428016921}}},
+
+
+            {{{0.5074119387178089,
+               0.8742225246851758,
+               0.4935465803401187,
+               0.7022587660316643,
+               0.9928168389990704,
+               0.1314891198979816,
+               0.2747315255195195},
+              {0.3945760755976464,
+               0.4218281785388314,
+               0.4110210752655458,
+               0.9076110025565549,
+               0.7140326444668564,
+               0.6079052140907037,
+               0.3093727178627821},
+              {0.8237903842212947,
+               0.9550605114849889,
+               0.8211982825502265,
+               0.0015651051914729,
+               0.636401370183407,
+               0.0511353814421007,
+               0.2576072203337219},
+              {0.0595247003477717,
+               0.6037954529493877,
+               0.6865899134926068,
+               0.1144876380659051,
+               0.3838388830449795,
+               0.456236508955542,
+               0.3690530217609166},
+              {0.121025000485193,
+               0.4189477901874754,
+               0.7511780478084181,
+               0.0710076645332555,
+               0.0801800140819035,
+               0.3547712918359842,
+               0.941725711618925},
+              {0.668572646722914,
+               0.6786699566725648,
+               0.361919990837865,
+               0.5936607912085384,
+               0.0101311840277434,
+               0.6360960464095422,
+               0.9132869475762367}},
+
+             {{0.6125734683448192,
+               0.873698593466345,
+               0.7239730554660938,
+               0.1205584164036902,
+               0.9024533072858417,
+               0.0664438443557749,
+               0.5339674725477638},
+              {0.1421371237934577,
+               0.0117066107309041,
+               0.422034260127639,
+               0.2950407076541562,
+               0.486000493797603,
+               0.5771998867345508,
+               0.0437390723089474},
+              {0.1230032951237456,
+               0.5586423964504253,
+               0.3431673531726582,
+               0.729173487549448,
+               0.6522916485919397,
+               0.8456043629899068,
+               0.6924928266692253},
+              {0.4299310773901481,
+               0.6729666223944324,
+               0.2753811742554185,
+               0.3063134987782127,
+               0.7889851599207933,
+               0.4464195164015822,
+               0.7983803405183525},
+              {0.8224223736682784,
+               0.8575623376612838,
+               0.9166352358412073,
+               0.4309852205132962,
+               0.3188668183211388,
+               0.5821987465941139,
+               0.3711724234376276},
+              {0.601074166800233,
+               0.7055858626438246,
+               0.6884050184921369,
+               0.3745528870201214,
+               0.1668602016987528,
+               0.4305293384622075,
+               0.1425941440819087}},
+
+             {{0.8900970351838083,
+               0.3458774607378574,
+               0.1544597472233238,
+               0.0254477599057509,
+               0.6458223862864843,
+               0.6369023174547432,
+               0.3406041665812917},
+              {0.071711888847651,
+               0.409628894895232,
+               0.3112174950633936,
+               0.6771206397350094,
+               0.6057792494526903,
+               0.36459372819754,
+               0.2178925542549901},
+              {0.9880359661555919,
+               0.4540016211961149,
+               0.688274235780237,
+               0.1405529675783608,
+               0.4855896996593978,
+               0.0275367198694655,
+               0.50545511791045},
+              {0.9640174071177023,
+               0.3842067129858002,
+               0.0389960125749116,
+               0.0309557909193435,
+               0.3879867599468695,
+               0.160024936463194,
+               0.0233520963281859},
+              {0.7562136139501768,
+               0.4585230088818907,
+               0.2892447719726545,
+               0.9000831830164807,
+               0.1161389602005256,
+               0.9559188289553192,
+               0.3139667173773528},
+              {0.8884036723086812,
+               0.6029428764794615,
+               0.8267073597414875,
+               0.9840131632104643,
+               0.2884054378187457,
+               0.961135485407593,
+               0.3894818949024204}},
+
+             {{0.3855119047369223,
+               0.3403871042545057,
+               0.5414076073475852,
+               0.1541450431784871,
+               0.5537114853580112,
+               0.541704812410004,
+               0.76190181260487},
+              {0.8336499619375856,
+               0.440441350312424,
+               0.3023332493514937,
+               0.2593348973170945,
+               0.1946238367048719,
+               0.0576475821990249,
+               0.3424479788347133},
+              {0.2702476921307833,
+               0.9664173858664074,
+               0.5577088262500439,
+               0.3472770390305076,
+               0.580467600993696,
+               0.1391967013456955,
+               0.4440437492022029},
+              {0.6262343214210638,
+               0.4888978317924514,
+               0.4017788006543243,
+               0.9938483888996982,
+               0.880314762148927,
+               0.6234059581594401,
+               0.5693773611822828},
+              {0.620660479824584,
+               0.2013121078224333,
+               0.3951377432643186,
+               0.0394595328908993,
+               0.4755460374868267,
+               0.5430245839576632,
+               0.2277497361032096},
+              {0.9640288471655137,
+               0.909454610937242,
+               0.7221432354559059,
+               0.5333866287653626,
+               0.869969159647685,
+               0.1306523438234629,
+               0.790509794274885}},
+
+             {{0.1248208139668483,
+               0.7942106625494054,
+               0.275767568251357,
+               0.8770905810181889,
+               0.9440420938253978,
+               0.1487959694051156,
+               0.4626756050653935},
+              {0.9809873781626851,
+               0.4834074359731466,
+               0.8635475225145451,
+               0.5887315221313199,
+               0.3753299079196019,
+               0.2857835555258702,
+               0.2032230910860873},
+              {0.7617981913776972,
+               0.3865405068230279,
+               0.5112754622007512,
+               0.4923254800011819,
+               0.5772790292331312,
+               0.8655771456245522,
+               0.9807393435834294},
+              {0.4075842085738169,
+               0.8275189221063031,
+               0.7645277946547177,
+               0.5735289514555733,
+               0.9560471436119331,
+               0.2004745155284028,
+               0.1092642103096214},
+              {0.8539619669554221,
+               0.4391498166337483,
+               0.8469688542070605,
+               0.8930902051954149,
+               0.0624575936190714,
+               0.8834647629860607,
+               0.4483190553694222},
+              {0.5104324890042322,
+               0.6265925110932102,
+               0.9263826067300868,
+               0.019116094429764,
+               0.4768434683178171,
+               0.6877220424305607,
+               0.7227069576982285}}}
+        };
 
         // py_vr_all
         double py_vr_all = 0.08257307738009954;
+        // py_vr_all_ddof
+        double py_vr_all_ddof = 0.08267149582751325;
         // py_st_all
         double py_st_all = 0.2873553155591515;
         // py_vr
-        xarray<double> py_vr = {{0.0852068309126688,0.0847144350000448,0.0665795115515863,
-                                 0.1044879757008207,0.0994283910451301,0.0627262352216086,
-                                 0.0985537283997266},
-                                {0.0638931201038309,0.0764149454368496,0.0713175183081865,
-                                 0.066508578076682 ,0.0720721452105284,0.0824901481262121,
-                                 0.0641277495703859},
-                                {0.1077493245420096,0.0699334071648802,0.1007397644226236,
-                                 0.1116186015428858,0.0541115754698437,0.0901322000940208,
-                                 0.0664647998988194},
-                                {0.087982633168223 ,0.0778706200930632,0.0610545739371242,
-                                 0.1024460567243694,0.0536455858542131,0.0504355367736437,
-                                 0.0773686386350671},
-                                {0.072189495809687 ,0.0720540674148998,0.0922003312160627,
-                                 0.0762240153024691,0.0845913536241975,0.0819087439628765,
-                                 0.0894375580083343}};
+        xarray<double> py_vr = {
+            {0.0852068309126688,
+             0.0847144350000448,
+             0.0665795115515863,
+             0.1044879757008207,
+             0.0994283910451301,
+             0.0627262352216086,
+             0.0985537283997266},
+            {0.0638931201038309,
+             0.0764149454368496,
+             0.0713175183081865,
+             0.066508578076682,
+             0.0720721452105284,
+             0.0824901481262121,
+             0.0641277495703859},
+            {0.1077493245420096,
+             0.0699334071648802,
+             0.1007397644226236,
+             0.1116186015428858,
+             0.0541115754698437,
+             0.0901322000940208,
+             0.0664647998988194},
+            {0.087982633168223,
+             0.0778706200930632,
+             0.0610545739371242,
+             0.1024460567243694,
+             0.0536455858542131,
+             0.0504355367736437,
+             0.0773686386350671},
+            {0.072189495809687,
+             0.0720540674148998,
+             0.0922003312160627,
+             0.0762240153024691,
+             0.0845913536241975,
+             0.0819087439628765,
+             0.0894375580083343}
+        };
+        // py_vr_ddof
+        xarray<double> py_vr_ddof = {
+            {0.0889114757349588,
+             0.0883976713043945,
+             0.0694742729233944,
+             0.1090309311660738,
+             0.1037513645688315,
+             0.0654534628399395,
+             0.1028386731127582},
+            {0.0666710818474757,
+             0.0797373343688865,
+             0.0744182799737598,
+             0.0694002553843638,
+             0.0752057167414209,
+             0.0860766763056127,
+             0.0669159125951853},
+            {0.1124340777829665,
+             0.0729739900850924,
+             0.1051197541801289,
+             0.1164715842186635,
+             0.0564642526641848,
+             0.0940509914024565,
+             0.0693545738074637},
+            {0.0918079650451022,
+             0.0812562992275442,
+             0.0637091206300426,
+             0.1069002331036898,
+             0.0559780026304832,
+             0.0526283861985847,
+             0.0807324924887657},
+            {0.0753281695405429,
+             0.0751868529546781,
+             0.096209041268935,
+             0.0795381029243156,
+             0.08826923856438,
+             0.0854699937003928,
+             0.0933261474869576}
+        };
         // py_st
-        xarray<double> py_st = {{0.2919020913125989,0.2910574427841431,0.2580300593953858,
-                                 0.3232459987390728,0.3153226776575547,0.2504520617236133,
-                                 0.3139326813183467},
-                                {0.2527708846046769,0.2764325332460881,0.267053399731564 ,
-                                 0.2578925708055235,0.2684625583028821,0.287210981903917 ,
-                                 0.2532345742002578},
-                                {0.3282519223736695,0.2644492525322773,0.3173952810339555,
-                                 0.3340937017408228,0.2326189490773349,0.3002202526379938,
-                                 0.2578076800617456},
-                                {0.2966186662504957,0.2790530775552622,0.2470922377111919,
-                                 0.3200719555418272,0.231615167582378 ,0.2245785759453552,
-                                 0.2781521861051376},
-                                {0.2686810298656885,0.2684288870723489,0.303645074414295 ,
-                                 0.2760869705409314,0.2908459276390122,0.2861970369568428,
-                                 0.2990611275447452}};
+        xarray<double> py_st = {
+            {0.2919020913125989,
+             0.2910574427841431,
+             0.2580300593953858,
+             0.3232459987390728,
+             0.3153226776575547,
+             0.2504520617236133,
+             0.3139326813183467},
+            {0.2527708846046769,
+             0.2764325332460881,
+             0.267053399731564,
+             0.2578925708055235,
+             0.2684625583028821,
+             0.287210981903917,
+             0.2532345742002578},
+            {0.3282519223736695,
+             0.2644492525322773,
+             0.3173952810339555,
+             0.3340937017408228,
+             0.2326189490773349,
+             0.3002202526379938,
+             0.2578076800617456},
+            {0.2966186662504957,
+             0.2790530775552622,
+             0.2470922377111919,
+             0.3200719555418272,
+             0.231615167582378,
+             0.2245785759453552,
+             0.2781521861051376},
+            {0.2686810298656885,
+             0.2684288870723489,
+             0.303645074414295,
+             0.2760869705409314,
+             0.2908459276390122,
+             0.2861970369568428,
+             0.2990611275447452}
+        };
 
         auto st_all = xt::stddev(py_a);
         auto vr_all = xt::variance(py_a);
+        auto vr_all_ddof = xt::variance(py_a, {0, 1, 2, 3}, 1);
+        std::vector<size_t> axes_all = {0, 1, 2, 3};
+        auto vr_all_ddof_with_axes_arr = xt::variance(py_a, axes_all, 1);
 
-        auto vr = xt::variance(py_a, {0, 2});
         auto st = xt::stddev(py_a, {0, 2});
+        auto vr = xt::variance(py_a, {0, 2});
+        auto vr_ddof = xt::variance(py_a, {0, 2}, 1);
+        std::vector<size_t> axes02 = {0, 2};
+        auto vr_ddof_with_axes_arr = xt::variance(py_a, axes02, 1);
 
         EXPECT_TRUE(xt::allclose(st_all, py_st_all));
         EXPECT_TRUE(xt::allclose(vr_all, py_vr_all));
+        EXPECT_TRUE(xt::allclose(vr_all_ddof, py_vr_all_ddof));
+        EXPECT_TRUE(xt::allclose(vr_all_ddof_with_axes_arr, py_vr_all_ddof));
         EXPECT_TRUE(xt::allclose(st, py_st));
         EXPECT_TRUE(xt::allclose(vr, py_vr));
+        EXPECT_TRUE(xt::allclose(vr_ddof, py_vr_ddof));
+        EXPECT_TRUE(xt::allclose(vr_ddof_with_axes_arr, py_vr_ddof));
     }
 
 }
-
diff --git a/test/test_extended_xsort.cpp b/test/test_extended_xsort.cpp
new file mode 100644
index 000000000..2650a4a94
--- /dev/null
+++ b/test/test_extended_xsort.cpp
@@ -0,0 +1,847 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+// This file is generated from test/files/cppy_source/test_extended_xsort.cppy by preprocess.py!
+// Warning: This file should not be modified directly! Instead, modify the `*.cppy` file.
+
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xsort.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    using namespace xt::placeholders;
+
+    template <class T>
+    bool check_partition_equal(const T& a1, const T& a2, std::size_t kth)
+    {
+        auto p = a1[kth];
+        EXPECT_EQ(p, a2[kth]);
+
+        for (std::size_t i = 0; i < kth; ++i)
+        {
+            EXPECT_TRUE(a1[i] < p);
+            EXPECT_TRUE(a2[i] < p);
+        }
+
+        for (std::size_t i = kth + 1; i < a1.size(); ++i)
+        {
+            EXPECT_TRUE(p < a1[i]);
+            EXPECT_TRUE(p < a2[i]);
+        }
+        return true;
+    }
+
+    template <class X, class Y, class Z>
+    bool check_argpartition_equal(const X& data, const Y& a1, const Z& a2, std::size_t kth)
+    {
+        auto p = static_cast<std::size_t>(a1[kth]);
+        EXPECT_EQ(p, std::size_t(a2[kth]));
+        auto el = data[static_cast<std::size_t>(a1[kth])];
+        for (std::size_t i = 0; i < kth; ++i)
+        {
+            EXPECT_TRUE(data[static_cast<std::size_t>(a1[i])] < el);
+            EXPECT_TRUE(data[static_cast<std::size_t>(a2[i])] < el);
+        }
+
+        for (std::size_t i = kth + std::size_t(1); i < a1.size(); ++i)
+        {
+            EXPECT_TRUE(el < data[static_cast<std::size_t>(a1[i])]);
+            EXPECT_TRUE(el < data[static_cast<std::size_t>(a2[i])]);
+        }
+        return true;
+    }
+
+    /*py
+    a = np.random.randint(0, 1000, size=(20,))
+    */
+    TEST(xtest_extended, partition)
+    {
+        // py_a
+        xarray<long> py_a = {102, 435, 860, 270, 106, 71,  700, 20,  614, 121,
+                             466, 214, 330, 458, 87,  372, 99,  871, 663, 130};
+
+        // py_p5 = np.partition(a, 5)
+        xarray<long> py_p5 = {20,  71,  87,  99,  102, 106, 121, 700, 614, 435,
+                              466, 214, 330, 458, 270, 372, 860, 871, 663, 130};
+        // py_p0 = np.partition(a, 0)
+        xarray<long> py_p0 = {20,  435, 860, 270, 106, 71,  700, 102, 614, 121,
+                              466, 214, 330, 458, 87,  372, 99,  871, 663, 130};
+        // py_p13 = np.partition(a, 13)
+        xarray<long> py_p13 = {20,  102, 99,  87,  106, 71,  121, 270, 130, 435,
+                               372, 214, 330, 458, 614, 466, 860, 871, 663, 700};
+        // py_p19 = np.partition(a, 19)
+        xarray<long> py_p19 = {20,  102, 99,  87,  106, 71,  121, 270, 130, 435,
+                               372, 214, 330, 458, 663, 614, 466, 700, 860, 871};
+
+        // py_a5 = np.argpartition(a, 5)
+        xarray<long> py_a5 = {7, 5, 14, 16, 0, 4, 9, 6, 8, 1, 10, 11, 12, 13, 3, 15, 2, 17, 18, 19};
+        // py_a0 = np.argpartition(a, 0)
+        xarray<long> py_a0 = {7, 1, 2, 3, 4, 5, 6, 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
+        // py_a13 = np.argpartition(a, 13)
+        xarray<long> py_a13 = {7, 0, 16, 14, 4, 5, 9, 3, 19, 1, 15, 11, 12, 13, 8, 10, 2, 17, 18, 6};
+        // py_a19 = np.argpartition(a, 19)
+        xarray<long> py_a19 = {7, 0, 16, 14, 4, 5, 9, 3, 19, 1, 15, 11, 12, 13, 18, 8, 10, 6, 2, 17};
+
+        auto part_a0 = xt::partition(py_a, 0);
+
+        check_partition_equal(py_p0, part_a0, 0);
+        check_partition_equal(py_p5, xt::partition(py_a, 5), 5);
+        check_partition_equal(py_p13, xt::partition(py_a, 13), 13);
+        check_partition_equal(py_p19, xt::partition(py_a, 19), 19);
+
+        auto parta_a0 = xt::argpartition(py_a, 0);
+        check_argpartition_equal(py_a, py_a0, parta_a0, 0);
+        check_argpartition_equal(py_a, py_a5, xt::argpartition(py_a, 5), 5);
+        check_argpartition_equal(py_a, py_a13, xt::argpartition(py_a, 13), 13);
+        check_argpartition_equal(py_a, py_a19, xt::argpartition(py_a, 19), 19);
+
+        // py_median = np.median(a)
+        double py_median = 300.0;
+        EXPECT_EQ(static_cast<decltype(py_a)::value_type>(py_median), xt::median(py_a));
+    }
+
+    /*py
+    a = np.random.randint(0, 20, size=(20,))
+    */
+    TEST(xtest_extended, multi_partition)
+    {
+        // py_a
+        xarray<long> py_a = {1, 11, 5, 1, 0, 11, 11, 16, 9, 15, 14, 14, 18, 11, 19, 2, 4, 18, 6, 8};
+
+        // py_p0 = np.partition(a, (4, 5, 6))
+        xarray<long> py_p0 = {1, 1, 0, 2, 4, 5, 6, 8, 9, 11, 14, 14, 18, 11, 19, 16, 11, 18, 11, 15};
+        // py_p1 = np.partition(a, (2, 7, 12))
+        xarray<long> py_p1 = {0, 1, 1, 2, 4, 5, 6, 8, 9, 11, 11, 11, 11, 15, 19, 16, 14, 18, 18, 14};
+
+        auto part_p0 = xt::partition(py_a, {4, 5, 6});
+        auto part_p1 = xt::partition(py_a, {2, 7, 12});
+
+        EXPECT_EQ(part_p0(4), py_p0(4));
+        EXPECT_EQ(part_p0(5), py_p0(5));
+        EXPECT_EQ(part_p0(6), py_p0(6));
+
+        EXPECT_EQ(part_p1(2), py_p1(2));
+        EXPECT_EQ(part_p1(7), py_p1(7));
+        EXPECT_EQ(part_p1(12), py_p1(12));
+
+        // py_a0 = np.argpartition(a, (4, 5, 6))
+        xarray<long> py_a0 = {0, 3, 4, 15, 16, 2, 18, 19, 8, 1, 10, 11, 12, 13, 14, 7, 6, 17, 5, 9};
+        // py_a1 = np.argpartition(a, (2, 7, 12))
+        xarray<long> py_a1 = {4, 3, 0, 15, 16, 2, 18, 19, 8, 13, 1, 6, 5, 9, 14, 7, 10, 17, 12, 11};
+
+        auto part_a0 = xt::argpartition(py_a, {4, 5, 6});
+        auto part_a1 = xt::argpartition(py_a, {2, 7, 12});
+
+        EXPECT_EQ(py_a[part_a0(4)], py_a[static_cast<std::size_t>(py_a0(4))]);
+        EXPECT_EQ(py_a[part_a0(5)], py_a[static_cast<std::size_t>(py_a0(5))]);
+        EXPECT_EQ(py_a[part_a0(6)], py_a[static_cast<std::size_t>(py_a0(6))]);
+
+        EXPECT_EQ(py_a[part_a1(2)], py_a[static_cast<std::size_t>(py_a1(2))]);
+        EXPECT_EQ(py_a[part_a1(7)], py_a[static_cast<std::size_t>(py_a1(7))]);
+        EXPECT_EQ(py_a[part_a1(12)], py_a[static_cast<std::size_t>(py_a1(12))]);
+    }
+
+    /*py
+    a = np.random.rand(4, 5, 6)
+    */
+    TEST(xtest_extended, quantile_axis)
+    {
+        // py_a
+        xarray<double> py_a = {
+            {{0.0650515929852795, 0.9488855372533332, 0.9656320330745594, 0.8083973481164611, 0.3046137691733707, 0.0976721140063839
+             },
+             {0.6842330265121569, 0.4401524937396013, 0.1220382348447788, 0.4951769101112702, 0.0343885211152184, 0.9093204020787821
+             },
+             {0.2587799816000169, 0.662522284353982, 0.311711076089411, 0.5200680211778108, 0.5467102793432796, 0.184854455525527
+             },
+             {0.9695846277645586, 0.7751328233611146, 0.9394989415641891, 0.8948273504276488, 0.5978999788110851, 0.9218742350231168
+             },
+             {0.0884925020519195, 0.1959828624191452, 0.0452272889105381, 0.3253303307632643, 0.388677289689482, 0.2713490317738959
+             }},
+
+            {{0.8287375091519293, 0.3567533266935893, 0.2809345096873808, 0.5426960831582485, 0.1409242249747626, 0.8021969807540397
+             },
+             {0.0745506436797708, 0.9868869366005173, 0.7722447692966574, 0.1987156815341724, 0.0055221171236024, 0.8154614284548342
+             },
+             {0.7068573438476171, 0.7290071680409873, 0.7712703466859457, 0.0740446517340904, 0.3584657285442726, 0.1158690595251297
+             },
+             {0.8631034258755935, 0.6232981268275579, 0.3308980248526492, 0.0635583502860236, 0.3109823217156622, 0.325183322026747
+             },
+             {0.7296061783380641, 0.6375574713552131, 0.8872127425763265, 0.4722149251619493, 0.1195942459383017, 0.713244787222995
+             }},
+
+            {{0.7607850486168974, 0.5612771975694962, 0.770967179954561, 0.4937955963643907, 0.5227328293819941, 0.4275410183585496
+             },
+             {0.0254191267440952, 0.1078914269933045, 0.0314291856867343, 0.6364104112637804, 0.3143559810763267, 0.5085706911647028
+             },
+             {0.907566473926093, 0.2492922291488749, 0.4103829230356297, 0.7555511385430487, 0.2287981654916225, 0.076979909828793
+             },
+             {0.289751452913768, 0.1612212872540044, 0.9296976523425731, 0.808120379564417, 0.6334037565104235, 0.8714605901877177
+             },
+             {0.8036720768991145, 0.1865700588860358, 0.8925589984899778, 0.5393422419156507, 0.8074401551640625, 0.8960912999234932
+             }},
+
+            {{0.3180034749718639, 0.1100519245276768, 0.2279351625419417, 0.4271077886262563, 0.8180147659224931, 0.8607305832563434
+             },
+             {0.0069521305311907, 0.5107473025775657, 0.417411003148779, 0.2221078104707302, 0.1198653673336828, 0.337615171403628
+             },
+             {0.9429097039125192, 0.3232029320207552, 0.5187906217433661, 0.7030189588951778, 0.363629602379294, 0.9717820827209607
+             },
+             {0.9624472949421112, 0.2517822958253642, 0.4972485058923855, 0.3008783098167697, 0.2848404943774676, 0.0368869473545328
+             },
+             {0.6095643339798968, 0.5026790232288615, 0.0514787512499894, 0.2786464642366114, 0.9082658859666537, 0.2395618906669724
+             }}
+        };
+
+        // py_q0 = np.quantile(a, [0., .3, .1, 1.], axis=0)
+        xarray<double> py_q0 = {
+            {{0.0650515929852795, 0.1100519245276768, 0.2279351625419417, 0.4271077886262563, 0.1409242249747626, 0.0976721140063839
+             },
+             {0.0069521305311907, 0.1078914269933045, 0.0314291856867343, 0.1987156815341724, 0.0055221171236024, 0.337615171403628
+             },
+             {0.2587799816000169, 0.2492922291488749, 0.311711076089411, 0.0740446517340904, 0.2287981654916225, 0.076979909828793
+             },
+             {0.289751452913768, 0.1612212872540044, 0.3308980248526492, 0.0635583502860236, 0.2848404943774676, 0.0368869473545328
+             },
+             {0.0884925020519195, 0.1865700588860358, 0.0452272889105381, 0.2786464642366114, 0.1195942459383017, 0.2395618906669724
+             }},
+
+            {{0.2927082867732054, 0.332083186476998, 0.2756345749728368, 0.4871268155905773, 0.2882448147535099, 0.394554127923333
+             },
+             {0.0235724271228047, 0.4069263870649716, 0.1129773299289744, 0.2197685975770745, 0.0315018807160568, 0.4914751391885953
+             },
+             {0.662049607622857, 0.3158118617335672, 0.4005157383410078, 0.4754656842334387, 0.3454989722390076, 0.111980144555496
+             },
+             {0.8057682285794109, 0.2427261949682282, 0.4806134577884118, 0.277146313863695, 0.3083681389818427, 0.2963536845595256
+             },
+             {0.5574571507870991, 0.1950415820658343, 0.0508536050160442, 0.3206619441105991, 0.361768985314364, 0.2681703176632035
+             }},
+
+            {{0.1409371575812548, 0.1840623451774505, 0.2438349666855734, 0.4471141309476966, 0.1900310882343451, 0.1966327853120336
+             },
+             {0.012492229395062, 0.2075697470171935, 0.0586119004341476, 0.2057333202151398, 0.0141820383210872, 0.3889018273319504
+             },
+             {0.393203190274297, 0.271465440010439, 0.3413126301732766, 0.2078516625672065, 0.2676984344074175, 0.088646654737694
+             },
+             {0.4617570448023157, 0.1883895898254123, 0.3808031691645701, 0.1347543381452475, 0.292683042578926, 0.1233758597561971
+             },
+             {0.2448140516303127, 0.1893938999459686, 0.0471027276123735, 0.2926516241946073, 0.2003191590636558, 0.2490980329990495
+             }},
+
+            {{0.8287375091519293, 0.9488855372533332, 0.9656320330745594, 0.8083973481164611, 0.8180147659224931, 0.8607305832563434
+             },
+             {0.6842330265121569, 0.9868869366005173, 0.7722447692966574, 0.6364104112637804, 0.3143559810763267, 0.9093204020787821
+             },
+             {0.9429097039125192, 0.7290071680409873, 0.7712703466859457, 0.7555511385430487, 0.5467102793432796, 0.9717820827209607
+             },
+             {0.9695846277645586, 0.7751328233611146, 0.9394989415641891, 0.8948273504276488, 0.6334037565104235, 0.9218742350231168
+             },
+             {0.8036720768991145, 0.6375574713552131, 0.8925589984899778, 0.5393422419156507, 0.9082658859666537, 0.8960912999234932
+             }}
+        };
+        // py_q1 = np.quantile(a, [0., .3, .1, 1.], axis=1)
+        xarray<double> py_q1 = {
+            {{0.0650515929852795, 0.1959828624191452, 0.0452272889105381, 0.3253303307632643, 0.0343885211152184, 0.0976721140063839
+             },
+             {0.0745506436797708, 0.3567533266935893, 0.2809345096873808, 0.0635583502860236, 0.0055221171236024, 0.1158690595251297
+             },
+             {0.0254191267440952, 0.1078914269933045, 0.0314291856867343, 0.4937955963643907, 0.2287981654916225, 0.076979909828793
+             },
+             {0.0069521305311907, 0.1100519245276768, 0.0514787512499894, 0.2221078104707302, 0.1198653673336828, 0.0368869473545328
+             }},
+
+            {{0.122549997961539, 0.4846264518624774, 0.1599728030937052, 0.5001551323245783, 0.321426473276593, 0.2021533707752008
+             },
+             {0.7114071107457065, 0.6261499957330889, 0.4189724892193085, 0.0989788576941068, 0.1238602417455939, 0.4027956150659966
+             },
+             {0.3839581720543939, 0.1662910415804107, 0.4824997744194159, 0.5587558757852766, 0.3560313507374601, 0.4437469529197803
+             },
+             {0.3763156467734705, 0.2660664230644424, 0.2658303306633091, 0.2830928333526431, 0.3005983159778329, 0.2591725468143035
+             }},
+
+            {{0.0744279566119355, 0.2936507149473276, 0.0759516672842344, 0.3932689625024667, 0.1424786203384793, 0.1325450506140411
+             },
+             {0.3274733237469094, 0.4633712467471767, 0.3009199157534881, 0.0677528708652503, 0.0511509686494821, 0.1995947645257767
+             },
+             {0.1311520572119643, 0.1292233710975844, 0.1830106806262924, 0.5120142545848947, 0.2630212917255041, 0.2172043532406956
+             },
+             {0.13137266830746, 0.1667440730467517, 0.1220613157667703, 0.2447232719770827, 0.1858554181511967, 0.1179569246795086
+             }},
+
+            {{0.9695846277645586, 0.9488855372533332, 0.9656320330745594, 0.8948273504276488, 0.5978999788110851, 0.9218742350231168
+             },
+             {0.8631034258755935, 0.9868869366005173, 0.8872127425763265, 0.5426960831582485, 0.3584657285442726, 0.8154614284548342
+             },
+             {0.907566473926093, 0.5612771975694962, 0.9296976523425731, 0.808120379564417, 0.8074401551640625, 0.8960912999234932
+             },
+             {0.9624472949421112, 0.5107473025775657, 0.5187906217433661, 0.7030189588951778, 0.9082658859666537, 0.9717820827209607
+             }}
+        };
+        // py_q2 = np.quantile(a, [0., .3, .1, 1.], axis=2)
+        xarray<double> py_q2 = {
+            {{0.0650515929852795, 0.0343885211152184, 0.184854455525527, 0.5978999788110851, 0.0452272889105381},
+             {0.1409242249747626, 0.0055221171236024, 0.0740446517340904, 0.0635583502860236, 0.1195942459383017},
+             {0.4275410183585496, 0.0254191267440952, 0.076979909828793, 0.1612212872540044, 0.1865700588860358},
+             {0.1100519245276768, 0.0069521305311907, 0.3232029320207552, 0.0368869473545328, 0.0514787512499894
+             }},
+
+            {{0.2011429415898773, 0.2810953642921901, 0.2852455288447139, 0.8349800868943817, 0.1422376822355323},
+             {0.318843918190485, 0.1366331626069716, 0.2371673940347012, 0.3180828218712046, 0.5548861982585812},
+             {0.5082642128731925, 0.0696603063400194, 0.2390451973202487, 0.4615776047120957, 0.6715071594073826},
+             {0.2729693187569028, 0.1709865889022065, 0.44121011206133, 0.2683113951014159, 0.2591041774517919}},
+
+            {{0.0813618534958317, 0.0782133779799986, 0.221817218562772, 0.6865164010860998, 0.0668598954812288},
+             {0.2109293673310717, 0.0400363804016866, 0.09495685562961, 0.1872703360008429, 0.2959045855501255},
+             {0.4606683073614702, 0.0284241562154147, 0.1528890376602077, 0.2254863700838862, 0.3629561504008433},
+             {0.1689935435348092, 0.0634087489324368, 0.3434162672000246, 0.1443346215899485, 0.1455203209584809
+             }},
+
+            {{0.9656320330745594, 0.9093204020787821, 0.662522284353982, 0.9695846277645586, 0.388677289689482},
+             {0.8287375091519293, 0.9868869366005173, 0.7712703466859457, 0.8631034258755935, 0.8872127425763265},
+             {0.770967179954561, 0.6364104112637804, 0.907566473926093, 0.9296976523425731, 0.8960912999234932},
+             {0.8607305832563434, 0.5107473025775657, 0.9717820827209607, 0.9624472949421112, 0.9082658859666537}}
+        };
+
+        EXPECT_TRUE(xt::allclose(py_q0, xt::quantile(py_a, {0., .3, .1, 1.}, 0)));
+        EXPECT_TRUE(xt::allclose(py_q1, xt::quantile(py_a, {0., .3, .1, 1.}, 1)));
+        EXPECT_TRUE(xt::allclose(py_q2, xt::quantile(py_a, {0., .3, .1, 1.}, 2)));
+    }
+
+    /*py
+    a = np.random.rand(4, 5, 6)
+    */
+    TEST(xtest_extended, quantile_methods)
+    {
+        // py_a
+        xarray<double> py_a = {
+            {{0.1448948720912231, 0.489452760277563, 0.9856504541106007, 0.2420552715115004, 0.6721355474058786, 0.7616196153287176
+             },
+             {0.2376375439923997, 0.7282163486118596, 0.3677831327192532, 0.6323058305935795, 0.6335297107608947, 0.5357746840747585
+             },
+             {0.0902897700544083, 0.835302495589238, 0.3207800649717358, 0.1865185103998542, 0.0407751415547639, 0.5908929431882418
+             },
+             {0.6775643618422824, 0.0165878289278562, 0.512093058299281, 0.226495775197938, 0.6451727904094499, 0.1743664290049914
+             },
+             {0.690937738102466, 0.3867353463005374, 0.9367299887367345, 0.1375209441459933, 0.3410663510502585, 0.1134735212405891
+             }},
+
+            {{0.9246936182785628, 0.877339353380981, 0.2579416277151556, 0.659984046034179, 0.8172222002012158, 0.5552008115994623
+             },
+             {0.5296505783560065, 0.2418522909004517, 0.0931027678058992, 0.8972157579533268, 0.9004180571633305, 0.6331014572732679
+             },
+             {0.3390297910487007, 0.3492095746126609, 0.7259556788702394, 0.8971102599525771, 0.8870864242651173, 0.7798755458576239
+             },
+             {0.6420316461542878, 0.0841399649950488, 0.1616287140946138, 0.8985541885270792, 0.6064290596595899, 0.0091970516166296
+             },
+             {0.1014715428660321, 0.6635017691080558, 0.0050615838462187, 0.1608080514174987, 0.5487337893665861, 0.6918951976926933
+             }},
+
+            {{0.6519612595026005, 0.2242693094605598, 0.7121792213475359, 0.2372490874968001, 0.3253996981592677, 0.7464914051180241
+             },
+             {0.6496328990472147, 0.8492234104941779, 0.6576128923003434, 0.5683086033354716, 0.0936747678280925, 0.3677158030594335
+             },
+             {0.2652023676817254, 0.2439896433790836, 0.9730105547524456, 0.3930977246667604, 0.8920465551771133, 0.6311386259972629
+             },
+             {0.7948113035416484, 0.5026370931051921, 0.5769038846263591, 0.4925176938188639, 0.1952429877980445, 0.7224521152615053
+             },
+             {0.2807723624408558, 0.0243159664314538, 0.6454722959071678, 0.1771106794070489, 0.9404585843529143, 0.9539285770025874
+             }},
+
+            {{0.9148643902204485, 0.3701587002554444, 0.0154566165288674, 0.9283185625877254, 0.4281841483173143, 0.9666548190436696
+             },
+             {0.9636199770892528, 0.8530094554673601, 0.2944488920695857, 0.3850977286019253, 0.8511366715168569, 0.3169220051562777
+             },
+             {0.1694927466860925, 0.5568012624583502, 0.936154774160781, 0.696029796674973, 0.570061170089365, 0.0971764937707685
+             },
+             {0.6150072266991697, 0.9900538501042633, 0.140084015236524, 0.5183296523637367, 0.8773730719279554, 0.7407686177542044
+             },
+             {0.697015740995268, 0.7024840839871093, 0.3594911512197552, 0.2935918442644934, 0.8093611554785136, 0.8101133946791808
+             }}
+        };
+
+        // py_q4 = np.quantile(a, [0., .3, .1, 1.], method="interpolated_inverted_cdf")
+        xarray<double> py_q4 = {0.0050615838462187, 0.3169220051562777, 0.1014715428660321, 0.9900538501042633};
+        // py_q5 = np.quantile(a, [0., .3, .1, 1.], method="hazen")
+        xarray<double> py_q5 = {0.0050615838462187, 0.3188510350640067, 0.1074725320533106, 0.9900538501042633};
+        // py_q6 = np.quantile(a, [0., .3, .1, 1.], method="weibull")
+        xarray<double> py_q6 = {0.0050615838462187, 0.3180794231009151, 0.1026717407034878, 0.9900538501042633};
+        // py_q7 = np.quantile(a, [0., .3, .1, 1.], method="linear")
+        xarray<double> py_q7 = {0.0050615838462187, 0.3196226470270984, 0.1122733234031334, 0.9900538501042633};
+        // py_q8 = np.quantile(a, [0., .3, .1, 1.], method="median_unbiased")
+        xarray<double> py_q8 = {0.0050615838462187, 0.3185938310763095, 0.1058722682700363, 0.9900538501042633};
+        // py_q9 = np.quantile(a, [0., .3, .1, 1.], method="normal_unbiased")
+        xarray<double> py_q9 = {0.0050615838462187, 0.3186581320732338, 0.1062723342158549, 0.9900538501042633};
+
+        EXPECT_TRUE(
+            xt::allclose(py_q4, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::interpolated_inverted_cdf))
+        );
+        EXPECT_TRUE(xt::allclose(py_q5, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::hazen)));
+        EXPECT_TRUE(xt::allclose(py_q6, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::weibull)));
+        EXPECT_TRUE(xt::allclose(py_q7, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::linear)));
+        EXPECT_TRUE(xt::allclose(py_q8, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::median_unbiased)));
+        EXPECT_TRUE(xt::allclose(py_q9, xt::quantile(py_a, {0., .3, .1, 1.}, quantile_method::normal_unbiased)));
+    }
+
+    /*py
+    a = np.random.rand(5, 5, 5)
+    */
+    TEST(xtest_extended, axis_median)
+    {
+        // py_a
+        xarray<double> py_a = {
+            {{0.8670723185801037, 0.9132405525564713, 0.5113423988609378, 0.5015162946871996, 0.7982951789667752},
+             {0.6499639307777652, 0.7019668772577033, 0.795792669436101, 0.8900053418175663, 0.3379951568515358},
+             {0.375582952639944, 0.093981939840869, 0.578280140996174, 0.0359422737967421, 0.4655980181324602},
+             {0.5426446347075766, 0.2865412521282844, 0.5908332605690108, 0.0305002499390494, 0.0373481887492144},
+             {0.8226005606596583, 0.3601906414112629, 0.1270605126518848, 0.5222432600548044, 0.7699935530986108
+             }},
+
+            {{0.2158210274968432, 0.6228904758190003, 0.085347464993768, 0.0516817211686077, 0.531354631568148},
+             {0.5406351216101065, 0.6374299014982066, 0.7260913337226615, 0.9758520794625346, 0.5163003483011953},
+             {0.322956472941246, 0.7951861947687037, 0.2708322512620742, 0.4389714207056361, 0.078456381342266},
+             {0.0253507434154575, 0.9626484146779251, 0.8359801205122058, 0.695974206093698, 0.4089529444142699},
+             {0.1732943200708458, 0.156437042671086, 0.2502428981645953, 0.5492266647061205, 0.7145959227000623}},
+
+            {{0.6601973767177313, 0.2799338969459428, 0.9548652806631941, 0.7378969166957685, 0.5543540525114007},
+             {0.6117207462343522, 0.4196000624277899, 0.2477309895011575, 0.3559726786512616, 0.7578461104643691},
+             {0.0143934886297559, 0.1160726405069162, 0.0460026420217527, 0.0407288023189701, 0.8554605840110072},
+             {0.7036578593800237, 0.4741738290873252, 0.0978341606510015, 0.4916158751168324, 0.4734717707805657},
+             {0.1732018699100152, 0.433851649237973, 0.3985047343973734, 0.6158500980522165, 0.6350936508676438}},
+
+            {{0.0453040097720445, 0.3746126146264712, 0.6258599157142364, 0.5031362585800877, 0.8564898411883223},
+             {0.658693631618945, 0.1629344270814297, 0.0705687474004298, 0.6424192782063156, 0.0265113105416218},
+             {0.5857755812734633, 0.9402302414249576, 0.575474177875879, 0.3881699262065219, 0.6432882184423532},
+             {0.4582528904915166, 0.5456167893159349, 0.9414648087765252, 0.3861026378007743, 0.9611905638239142},
+             {0.9053506419560637, 0.1957911347892964, 0.0693613008751655, 0.1007780013774267, 0.0182218256515497
+             }},
+
+            {{0.0944429607559284, 0.6830067734163568, 0.071188648460229, 0.3189756302937613, 0.8448753109694546},
+             {0.0232719357358259, 0.8144684825889358, 0.2818547747733999, 0.1181648276216563, 0.6967371653641506},
+             {0.628942846779884, 0.877472013527053, 0.7350710438038858, 0.8034809303848486, 0.2820345725713065},
+             {0.1774395437797228, 0.7506147516408583, 0.806834739267264, 0.9905051420006733, 0.4126176769114265},
+             {0.3720180857927832, 0.7764129607419968, 0.3408035402530178, 0.9307573256035647, 0.8584127518430118}}
+        };
+        // py_m = np.median(a)
+        double py_m = 0.5113423988609378;
+
+        // py_m0 = np.median(a, 0)
+        xarray<double> py_m0 = {
+            {0.2158210274968432, 0.6228904758190003, 0.5113423988609378, 0.5015162946871996, 0.7982951789667752},
+            {0.6117207462343522, 0.6374299014982066, 0.2818547747733999, 0.6424192782063156, 0.5163003483011953},
+            {0.375582952639944, 0.7951861947687037, 0.575474177875879, 0.3881699262065219, 0.4655980181324602},
+            {0.4582528904915166, 0.5456167893159349, 0.806834739267264, 0.4916158751168324, 0.4126176769114265},
+            {0.3720180857927832, 0.3601906414112629, 0.2502428981645953, 0.5492266647061205, 0.7145959227000623}
+        };
+        // py_m1 = np.median(a, 1)
+        xarray<double> py_m1 = {
+            {0.6499639307777652, 0.3601906414112629, 0.578280140996174, 0.5015162946871996, 0.4655980181324602},
+            {0.2158210274968432, 0.6374299014982066, 0.2708322512620742, 0.5492266647061205, 0.5163003483011953},
+            {0.6117207462343522, 0.4196000624277899, 0.2477309895011575, 0.4916158751168324, 0.6350936508676438},
+            {0.5857755812734633, 0.3746126146264712, 0.575474177875879, 0.3881699262065219, 0.6432882184423532},
+            {0.1774395437797228, 0.7764129607419968, 0.3408035402530178, 0.8034809303848486, 0.6967371653641506}
+        };
+        // py_m2 = np.median(a, 2)
+        xarray<double> py_m2 = {
+            {0.7982951789667752, 0.7019668772577033, 0.375582952639944, 0.2865412521282844, 0.5222432600548044},
+            {0.2158210274968432, 0.6374299014982066, 0.322956472941246, 0.695974206093698, 0.2502428981645953},
+            {0.6601973767177313, 0.4196000624277899, 0.0460026420217527, 0.4741738290873252, 0.433851649237973},
+            {0.5031362585800877, 0.1629344270814297, 0.5857755812734633, 0.5456167893159349, 0.1007780013774267},
+            {0.3189756302937613, 0.2818547747733999, 0.7350710438038858, 0.7506147516408583, 0.7764129607419968}
+        };
+
+        EXPECT_EQ(py_m, xt::median(py_a));
+        EXPECT_EQ(py_m0, xt::median(py_a, 0));
+        EXPECT_EQ(py_m1, xt::median(py_a, 1));
+        EXPECT_EQ(py_m2, xt::median(py_a, 2));
+    }
+
+    /*py
+    a = np.random.permutation(np.arange(5 * 5 * 5)).reshape(5, 5, 5)
+    */
+    TEST(xtest_extended, axis_partition)
+    {
+        // py_a
+        xarray<long> py_a = {
+            {{110, 67, 43, 114, 86},
+             {117, 31, 40, 46, 62},
+             {10, 78, 33, 103, 14},
+             {23, 101, 66, 91, 89},
+             {20, 123, 32, 50, 106}},
+
+            {{69, 108, 96, 64, 65},
+             {59, 55, 76, 19, 119},
+             {92, 2, 42, 25, 9},
+             {63, 79, 115, 30, 5},
+             {35, 3, 53, 90, 105}},
+
+            {{71, 21, 0, 44, 47},
+             {7, 102, 37, 36, 28},
+             {97, 1, 72, 26, 49},
+             {73, 81, 39, 109, 45},
+             {6, 116, 80, 100, 17}},
+
+            {{74, 34, 4, 13, 113},
+             {57, 41, 87, 38, 56},
+             {93, 121, 52, 84, 95},
+             {24, 118, 68, 15, 82},
+             {51, 94, 77, 27, 70}},
+
+            {{8, 75, 107, 60, 11},
+             {99, 48, 18, 58, 122},
+             {85, 120, 111, 83, 61},
+             {124, 16, 29, 104, 98},
+             {88, 22, 12, 54, 112}}
+        };
+
+        // py_p0 = np.partition(a, 2, 0)
+        xarray<long> py_p0 = {
+            {{8, 21, 0, 13, 11}, {7, 31, 18, 19, 28}, {10, 1, 33, 25, 9}, {23, 16, 29, 15, 5}, {6, 3, 12, 27, 17}
+            },
+
+            {{69, 34, 4, 44, 47},
+             {57, 41, 37, 36, 56},
+             {85, 2, 42, 26, 14},
+             {24, 79, 39, 30, 45},
+             {20, 22, 32, 50, 70}},
+
+            {{71, 67, 43, 60, 65},
+             {59, 48, 40, 38, 62},
+             {92, 78, 52, 83, 49},
+             {63, 81, 66, 91, 82},
+             {35, 94, 53, 54, 105}},
+
+            {{74, 108, 96, 114, 113},
+             {117, 55, 87, 46, 119},
+             {93, 121, 72, 84, 95},
+             {73, 118, 68, 109, 89},
+             {51, 116, 77, 90, 106}},
+
+            {{110, 75, 107, 64, 86},
+             {99, 102, 76, 58, 122},
+             {97, 120, 111, 103, 61},
+             {124, 101, 115, 104, 98},
+             {88, 123, 80, 100, 112}}
+        };
+        // py_p1 = np.partition(a, 4, 1)
+        xarray<long> py_p1 = {
+            {{10, 31, 32, 91, 62},
+             {20, 67, 33, 50, 14},
+             {23, 78, 40, 46, 86},
+             {110, 101, 43, 103, 89},
+             {117, 123, 66, 114, 106}},
+
+            {{63, 2, 42, 30, 5},
+             {35, 3, 53, 25, 9},
+             {59, 55, 76, 19, 65},
+             {69, 79, 96, 64, 105},
+             {92, 108, 115, 90, 119}},
+
+            {{7, 1, 39, 36, 45},
+             {6, 21, 0, 26, 17},
+             {71, 81, 37, 44, 28},
+             {73, 102, 72, 100, 47},
+             {97, 116, 80, 109, 49}},
+
+            {{24, 41, 4, 15, 82},
+             {51, 34, 52, 13, 70},
+             {57, 94, 68, 27, 56},
+             {74, 118, 77, 38, 95},
+             {93, 121, 87, 84, 113}},
+
+            {{8, 16, 29, 58, 11},
+             {85, 22, 12, 54, 61},
+             {88, 48, 18, 60, 98},
+             {99, 75, 107, 83, 112},
+             {124, 120, 111, 104, 122}}
+        };
+        // py_p2 = np.partition(a, 3, 2)
+        xarray<long> py_p2 = {
+            {{67, 43, 86, 110, 114},
+             {46, 40, 31, 62, 117},
+             {10, 14, 33, 78, 103},
+             {23, 66, 89, 91, 101},
+             {20, 32, 50, 106, 123}},
+
+            {{64, 65, 69, 96, 108},
+             {19, 59, 55, 76, 119},
+             {25, 9, 2, 42, 92},
+             {30, 5, 63, 79, 115},
+             {3, 35, 53, 90, 105}},
+
+            {{44, 0, 21, 47, 71},
+             {7, 28, 36, 37, 102},
+             {26, 49, 1, 72, 97},
+             {39, 45, 73, 81, 109},
+             {6, 17, 80, 100, 116}},
+
+            {{13, 4, 34, 74, 113},
+             {38, 56, 41, 57, 87},
+             {84, 52, 93, 95, 121},
+             {15, 24, 68, 82, 118},
+             {27, 51, 70, 77, 94}},
+
+            {{8, 11, 60, 75, 107},
+             {58, 18, 48, 99, 122},
+             {83, 61, 85, 111, 120},
+             {16, 29, 98, 104, 124},
+             {54, 12, 22, 88, 112}}
+        };
+
+        auto p0 = xt::partition(py_a, 2, 0);
+        auto p1 = xt::partition(py_a, 4, 1);
+        auto p2 = xt::partition(py_a, 3, 2);
+
+        EXPECT_EQ(xt::view(py_p0, 2, all(), all()), xt::view(p0, 2, all(), all()));
+        EXPECT_EQ(xt::view(py_p1, all(), 4, all()), xt::view(p1, all(), 4, all()));
+        EXPECT_EQ(xt::view(py_p2, all(), all(), 3), xt::view(p2, all(), all(), 3));
+
+        // py_a0 = np.argpartition(a, 2, 0)
+        xarray<long> py_a0 = {
+            {{4, 2, 2, 3, 4}, {2, 0, 4, 1, 2}, {0, 2, 0, 1, 1}, {0, 4, 4, 3, 1}, {2, 1, 4, 3, 2}},
+
+            {{1, 3, 3, 2, 2}, {3, 3, 2, 2, 3}, {4, 1, 1, 2, 0}, {3, 1, 2, 1, 2}, {0, 4, 0, 0, 3}},
+
+            {{2, 0, 0, 4, 1}, {1, 4, 0, 3, 0}, {1, 0, 3, 4, 2}, {1, 2, 0, 0, 3}, {1, 3, 1, 4, 1}},
+
+            {{3, 1, 1, 0, 3}, {0, 1, 3, 0, 1}, {3, 3, 2, 3, 3}, {2, 3, 3, 2, 0}, {3, 2, 3, 1, 0}},
+
+            {{0, 4, 4, 1, 0}, {4, 2, 1, 4, 4}, {2, 4, 4, 0, 4}, {4, 0, 1, 4, 4}, {4, 0, 2, 2, 4}}
+        };
+        // py_a1 = np.argpartition(a, 4, 1)
+        xarray<long> py_a1 = {
+            {{2, 1, 4, 3, 1}, {4, 0, 2, 4, 2}, {3, 2, 1, 1, 0}, {0, 3, 0, 2, 3}, {1, 4, 3, 0, 4}},
+
+            {{3, 2, 2, 3, 3}, {4, 4, 4, 2, 2}, {1, 1, 1, 1, 0}, {0, 3, 0, 0, 4}, {2, 0, 3, 4, 1}},
+
+            {{1, 2, 3, 1, 3}, {4, 0, 0, 2, 4}, {0, 3, 1, 0, 1}, {3, 1, 2, 4, 0}, {2, 4, 4, 3, 2}},
+
+            {{3, 1, 0, 3, 3}, {4, 0, 2, 0, 4}, {1, 4, 3, 4, 1}, {0, 3, 4, 1, 2}, {2, 2, 1, 2, 0}},
+
+            {{0, 3, 3, 1, 0}, {2, 4, 4, 4, 2}, {4, 1, 1, 0, 3}, {1, 0, 0, 2, 4}, {3, 2, 2, 3, 1}}
+        };
+        // py_a2 = np.argpartition(a, 3, 2)
+        xarray<long> py_a2 = {
+            {{1, 2, 4, 0, 3}, {3, 2, 1, 4, 0}, {0, 4, 2, 1, 3}, {0, 2, 4, 3, 1}, {0, 2, 3, 4, 1}},
+
+            {{3, 4, 0, 2, 1}, {3, 0, 1, 2, 4}, {3, 4, 1, 2, 0}, {3, 4, 0, 1, 2}, {1, 0, 2, 3, 4}},
+
+            {{3, 2, 1, 4, 0}, {0, 4, 3, 2, 1}, {3, 4, 1, 2, 0}, {2, 4, 0, 1, 3}, {0, 4, 2, 3, 1}},
+
+            {{3, 2, 1, 0, 4}, {3, 4, 1, 0, 2}, {3, 2, 0, 4, 1}, {3, 0, 2, 4, 1}, {3, 0, 4, 2, 1}},
+
+            {{0, 4, 3, 1, 2}, {3, 2, 1, 0, 4}, {3, 4, 0, 2, 1}, {1, 2, 4, 3, 0}, {3, 2, 1, 0, 4}}
+        };
+
+        auto a0 = xt::argpartition(py_a, 2, 0);
+        auto a1 = xt::argpartition(py_a, 4, 1);
+        auto a2 = xt::argpartition(py_a, 3, 2);
+
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a0, 2, all(), all())), xt::view(a0, 2, all(), all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a1, all(), 4, all())), xt::view(a1, all(), 4, all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a2, all(), all(), 3)), xt::view(a2, all(), all(), 3));
+    }
+
+    /*py
+    a = np.random.permutation(np.arange(5 * 5 * 5)).reshape(5, 5, 5)
+    */
+    TEST(xtest_extended, multi_k_axis_partition)
+    {
+        // py_a
+        xarray<long> py_a = {
+            {{87, 38, 85, 104, 100},
+             {69, 50, 60, 108, 42},
+             {19, 113, 66, 122, 54},
+             {81, 31, 109, 111, 78},
+             {43, 93, 6, 105, 1}},
+
+            {{98, 110, 97, 3, 77},
+             {61, 44, 118, 8, 123},
+             {52, 96, 18, 39, 112},
+             {41, 36, 22, 119, 37},
+             {51, 121, 107, 88, 94}},
+
+            {{79, 47, 20, 120, 80},
+             {92, 33, 70, 82, 67},
+             {90, 58, 21, 84, 99},
+             {25, 10, 124, 17, 64},
+             {114, 4, 29, 55, 9}},
+
+            {{65, 24, 46, 68, 5},
+             {34, 45, 12, 28, 76},
+             {83, 32, 72, 16, 62},
+             {26, 63, 40, 106, 103},
+             {49, 59, 57, 102, 89}},
+
+            {{35, 91, 7, 27, 23},
+             {75, 101, 71, 115, 95},
+             {73, 11, 74, 56, 86},
+             {15, 2, 117, 53, 116},
+             {0, 30, 14, 13, 48}}
+        };
+
+        // py_p0 = np.partition(a, (1, 2), 0)
+        xarray<long> py_p0 = {
+            {{35, 24, 7, 3, 5}, {34, 33, 12, 8, 42}, {19, 11, 18, 16, 54}, {15, 2, 22, 17, 37}, {0, 4, 6, 13, 1}},
+
+            {{65, 38, 20, 27, 23},
+             {61, 44, 60, 28, 67},
+             {52, 32, 21, 39, 62},
+             {25, 10, 40, 53, 64},
+             {43, 30, 14, 55, 9}},
+
+            {{79, 47, 46, 68, 77},
+             {69, 45, 70, 82, 76},
+             {73, 58, 66, 56, 86},
+             {26, 31, 109, 106, 78},
+             {49, 59, 29, 88, 48}},
+
+            {{98, 110, 97, 120, 100},
+             {92, 50, 118, 108, 123},
+             {83, 96, 72, 122, 112},
+             {41, 63, 124, 111, 103},
+             {114, 93, 57, 102, 89}},
+
+            {{87, 91, 85, 104, 80},
+             {75, 101, 71, 115, 95},
+             {90, 113, 74, 84, 99},
+             {81, 36, 117, 119, 116},
+             {51, 121, 107, 105, 94}}
+        };
+        // py_p1 = np.partition(a, (1, 4), 1)
+        xarray<long> py_p1 = {
+            {{19, 31, 6, 104, 1},
+             {43, 38, 60, 105, 42},
+             {69, 50, 66, 108, 54},
+             {81, 93, 85, 111, 78},
+             {87, 113, 109, 122, 100}},
+
+            {{41, 36, 18, 3, 37},
+             {51, 44, 22, 8, 77},
+             {52, 96, 97, 39, 94},
+             {61, 110, 107, 88, 112},
+             {98, 121, 118, 119, 123}},
+
+            {{25, 4, 20, 17, 9},
+             {79, 10, 21, 55, 64},
+             {90, 33, 29, 82, 67},
+             {92, 47, 70, 84, 80},
+             {114, 58, 124, 120, 99}},
+
+            {{26, 24, 12, 16, 5},
+             {34, 32, 40, 28, 62},
+             {49, 45, 46, 68, 76},
+             {65, 59, 57, 102, 89},
+             {83, 63, 72, 106, 103}},
+
+            {{0, 2, 7, 13, 23},
+             {15, 11, 14, 27, 48},
+             {35, 30, 71, 53, 86},
+             {73, 91, 74, 56, 95},
+             {75, 101, 117, 115, 116}}
+        };
+        // py_p2 = np.partition(a, (1, 3), 2)
+        xarray<long> py_p2 = {
+            {{38, 85, 87, 100, 104},
+             {42, 50, 60, 69, 108},
+             {19, 54, 66, 113, 122},
+             {31, 78, 81, 109, 111},
+             {1, 6, 43, 93, 105}},
+
+            {{3, 77, 97, 98, 110},
+             {8, 44, 61, 118, 123},
+             {18, 39, 52, 96, 112},
+             {22, 36, 37, 41, 119},
+             {51, 88, 94, 107, 121}},
+
+            {{20, 47, 79, 80, 120},
+             {33, 67, 70, 82, 92},
+             {21, 58, 84, 90, 99},
+             {10, 17, 25, 64, 124},
+             {4, 9, 29, 55, 114}},
+
+            {{5, 24, 46, 65, 68},
+             {12, 28, 34, 45, 76},
+             {16, 32, 62, 72, 83},
+             {26, 40, 63, 103, 106},
+             {49, 57, 59, 89, 102}},
+
+            {{7, 23, 27, 35, 91},
+             {71, 75, 95, 101, 115},
+             {11, 56, 73, 74, 86},
+             {2, 15, 53, 116, 117},
+             {0, 13, 14, 30, 48}}
+        };
+
+        auto p0 = xt::partition(py_a, {1, 2}, 0);
+        auto p1 = xt::partition(py_a, {1, 4}, 1);
+        auto p2 = xt::partition(py_a, {1, 3}, 2);
+
+        EXPECT_EQ(xt::view(py_p0, 2, all(), all()), xt::view(p0, 2, all(), all()));
+        EXPECT_EQ(xt::view(py_p1, all(), 4, all()), xt::view(p1, all(), 4, all()));
+        EXPECT_EQ(xt::view(py_p2, all(), all(), 3), xt::view(p2, all(), all(), 3));
+
+        EXPECT_EQ(xt::view(py_p0, 1, all(), all()), xt::view(p0, 1, all(), all()));
+        EXPECT_EQ(xt::view(py_p1, all(), 1, all()), xt::view(p1, all(), 1, all()));
+        EXPECT_EQ(xt::view(py_p2, all(), all(), 1), xt::view(p2, all(), all(), 1));
+
+        // py_a0 = np.argpartition(a, (1, 2), 0)
+        xarray<long> py_a0 = {
+            {{4, 3, 4, 1, 3}, {3, 2, 3, 1, 0}, {0, 4, 1, 3, 0}, {4, 4, 1, 2, 1}, {4, 2, 0, 4, 0}},
+
+            {{3, 0, 2, 4, 4}, {1, 1, 0, 3, 2}, {1, 3, 2, 1, 3}, {2, 2, 3, 4, 2}, {0, 4, 4, 2, 2}},
+
+            {{2, 2, 3, 3, 1}, {0, 3, 2, 2, 3}, {4, 2, 0, 4, 4}, {3, 0, 0, 3, 0}, {3, 3, 2, 1, 4}},
+
+            {{1, 1, 1, 2, 0}, {2, 0, 1, 0, 1}, {3, 1, 3, 0, 1}, {1, 3, 2, 0, 3}, {2, 0, 3, 3, 3}},
+
+            {{0, 4, 0, 0, 2}, {4, 4, 4, 4, 4}, {2, 0, 4, 2, 2}, {0, 1, 4, 1, 4}, {1, 1, 1, 0, 1}}
+        };
+        // py_a1 = np.argpartition(a, (1, 4), 1)
+        xarray<long> py_a1 = {
+            {{2, 3, 4, 0, 4}, {4, 0, 1, 4, 1}, {1, 1, 2, 1, 2}, {3, 4, 0, 3, 3}, {0, 2, 3, 2, 0}},
+
+            {{3, 3, 2, 0, 3}, {4, 1, 3, 1, 0}, {2, 2, 0, 2, 4}, {1, 0, 4, 4, 2}, {0, 4, 1, 3, 1}},
+
+            {{3, 4, 0, 3, 4}, {0, 3, 2, 4, 3}, {2, 1, 4, 1, 1}, {1, 0, 1, 2, 0}, {4, 2, 3, 0, 2}},
+
+            {{3, 0, 1, 2, 0}, {1, 2, 3, 1, 2}, {4, 1, 0, 0, 1}, {0, 4, 4, 4, 4}, {2, 3, 2, 3, 3}},
+
+            {{4, 3, 0, 4, 0}, {3, 2, 4, 0, 4}, {0, 4, 1, 3, 2}, {2, 0, 2, 2, 1}, {1, 1, 3, 1, 3}}
+        };
+        // py_a2 = np.argpartition(a, (1, 3), 2)
+        xarray<long> py_a2 = {
+            {{1, 2, 0, 4, 3}, {4, 1, 2, 0, 3}, {0, 4, 2, 1, 3}, {1, 4, 0, 2, 3}, {4, 2, 0, 1, 3}},
+
+            {{3, 4, 2, 0, 1}, {3, 1, 0, 2, 4}, {2, 3, 0, 1, 4}, {2, 1, 4, 0, 3}, {0, 3, 4, 2, 1}},
+
+            {{2, 1, 0, 4, 3}, {1, 4, 2, 3, 0}, {2, 1, 3, 0, 4}, {1, 3, 0, 4, 2}, {1, 4, 2, 3, 0}},
+
+            {{4, 1, 2, 0, 3}, {2, 3, 0, 1, 4}, {3, 1, 4, 2, 0}, {0, 2, 1, 4, 3}, {0, 2, 1, 4, 3}},
+
+            {{2, 4, 3, 0, 1}, {2, 0, 4, 1, 3}, {1, 3, 0, 2, 4}, {1, 0, 3, 4, 2}, {0, 3, 2, 1, 4}}
+        };
+
+        auto a0 = xt::argpartition(py_a, {1, 2}, 0);
+        auto a1 = xt::argpartition(py_a, {1, 4}, 1);
+        auto a2 = xt::argpartition(py_a, {1, 3}, 2);
+
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a0, 2, all(), all())), xt::view(a0, 2, all(), all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a1, all(), 4, all())), xt::view(a1, all(), 4, all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a2, all(), all(), 3)), xt::view(a2, all(), all(), 3));
+
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a0, 1, all(), all())), xt::view(a0, 1, all(), all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a1, all(), 1, all())), xt::view(a1, all(), 1, all()));
+        EXPECT_EQ(xt::cast<std::size_t>(xt::view(py_a2, all(), all(), 1)), xt::view(a2, all(), all(), 1));
+    }
+}
diff --git a/test/test_sfinae.cpp b/test/test_sfinae.cpp
new file mode 100644
index 000000000..d2e8cc8ca
--- /dev/null
+++ b/test/test_sfinae.cpp
@@ -0,0 +1,132 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <complex>
+#include <limits>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
+
+// #include "xtensor/xfixed.hpp"
+
+namespace xt
+{
+    template <class E, std::enable_if_t<(xt::get_rank<E>() != 2), int> = 0>
+    inline size_t sfinae_rank_basic_func(E&&)
+    {
+        return 0;
+    }
+
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == 2), int> = 0>
+    inline size_t sfinae_rank_basic_func(E&&)
+    {
+        return 2;
+    }
+
+    TEST(sfinae, rank_basic)
+    {
+        xt::xarray<size_t> a = {{9, 9, 9}, {9, 9, 9}};
+        xt::xtensor<size_t, 1> b = {9, 9};
+        xt::xtensor<size_t, 2> c = {{9, 9}, {9, 9}};
+        // xt::xtensor_fixed<size_t, xt::xshape<2, 2>> d = {{9, 9}, {9, 9}};
+        auto v = xt::view(c, 0, xt::all());
+
+        EXPECT_TRUE(sfinae_rank_basic_func(a) == 0ul);
+        EXPECT_TRUE(sfinae_rank_basic_func(b) == 0ul);
+        EXPECT_TRUE(sfinae_rank_basic_func(c) == 2ul);
+        // EXPECT_TRUE(sfinae_rank_basic_func(d) == 2ul);
+        EXPECT_TRUE(sfinae_rank_basic_func(v) == 0ul);
+        EXPECT_TRUE(sfinae_rank_basic_func(2ul * a) == 0ul);
+        EXPECT_TRUE(sfinae_rank_basic_func(2ul * b) == 0ul);
+        EXPECT_TRUE(sfinae_rank_basic_func(2ul * c) == 0ul);
+    }
+
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == SIZE_MAX), int> = 0>
+    inline size_t sfinae_rank_func(E&&)
+    {
+        return 0;
+    }
+
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == 1), int> = 0>
+    inline size_t sfinae_rank_func(E&&)
+    {
+        return 1;
+    }
+
+    template <class E, std::enable_if_t<(xt::get_rank<E>() == 2), int> = 0>
+    inline size_t sfinae_rank_func(E&&)
+    {
+        return 2;
+    }
+
+    TEST(sfinae, rank)
+    {
+        xt::xarray<size_t> a = {{9, 9, 9}, {9, 9, 9}};
+        xt::xtensor<size_t, 1> b = {9, 9};
+        xt::xtensor<size_t, 2> c = {{9, 9}, {9, 9}};
+        // xt::xtensor_fixed<size_t, xt::xshape<2, 2>> d = {{9, 9}, {9, 9}};
+        auto v = xt::view(c, 0, xt::all());
+
+        EXPECT_TRUE(sfinae_rank_func(a) == 0ul);
+        EXPECT_TRUE(sfinae_rank_func(b) == 1ul);
+        EXPECT_TRUE(sfinae_rank_func(c) == 2ul);
+        // EXPECT_TRUE(sfinae_rank_func(d) == 2ul);
+        EXPECT_TRUE(sfinae_rank_func(v) == 0ul);
+        EXPECT_TRUE(sfinae_rank_func(2ul * a) == 0ul);
+        EXPECT_TRUE(sfinae_rank_func(2ul * b) == 0ul);
+        EXPECT_TRUE(sfinae_rank_func(2ul * c) == 0ul);
+    }
+
+    template <class E, std::enable_if_t<!xt::has_fixed_rank<E>(), int> = 0>
+    inline bool sfinae_fixed_func(E&&)
+    {
+        return false;
+    }
+
+    template <class E, std::enable_if_t<xt::has_fixed_rank<E>(), int> = 0>
+    inline bool sfinae_fixed_func(E&&)
+    {
+        return true;
+    }
+
+    TEST(sfinae, fixed_rank)
+    {
+        xt::xarray<size_t> a = {{9, 9, 9}, {9, 9, 9}};
+        xt::xtensor<size_t, 1> b = {9, 9};
+        xt::xtensor<size_t, 2> c = {{9, 9}, {9, 9}};
+        // xt::xtensor_fixed<size_t, xt::xshape<2, 2>> d = {{9, 9}, {9, 9}};
+        auto v = xt::view(c, 0, xt::all());
+
+        EXPECT_TRUE(sfinae_fixed_func(a) == false);
+        EXPECT_TRUE(sfinae_fixed_func(b) == true);
+        EXPECT_TRUE(sfinae_fixed_func(c) == true);
+        // EXPECT_TRUE(sfinae_fixed_func(d) == 2ul);
+        EXPECT_TRUE(sfinae_fixed_func(v) == false);
+        EXPECT_TRUE(sfinae_fixed_func(2ul * a) == false);
+        EXPECT_TRUE(sfinae_fixed_func(2ul * b) == false);
+        EXPECT_TRUE(sfinae_fixed_func(2ul * c) == false);
+    }
+
+    TEST(sfinae, get_rank)
+    {
+        xt::xtensor<double, 1> A = xt::zeros<double>({2});
+        xt::xtensor<double, 2> B = xt::zeros<double>({2, 2});
+        xt::xarray<double> C = xt::zeros<double>({2, 2});
+
+        static_assert(get_rank<decltype(A)>() == 1ul);
+        static_assert(get_rank<decltype(B)>() == 2ul);
+        static_assert(get_rank<decltype(C)>() == SIZE_MAX);
+        static_assert(get_rank<decltype(2.0 * A)>() == SIZE_MAX);
+        static_assert(get_rank<decltype(2.0 * B)>() == SIZE_MAX);
+        static_assert(get_rank<decltype(2.0 * C)>() == SIZE_MAX);
+    }
+}
diff --git a/test/test_strided_assign.cpp b/test/test_strided_assign.cpp
new file mode 100644
index 000000000..a0131b27d
--- /dev/null
+++ b/test/test_strided_assign.cpp
@@ -0,0 +1,199 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <type_traits>
+#include <vector>
+
+#include "xtensor/containers/xadapt.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xassign.hpp"
+#include "xtensor/core/xlayout.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common.hpp"
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    TEST(xassign_strided, mix_shape_types)
+    {
+        auto check_linear_assign = [](auto a, auto b)
+        {
+            assert_compatible_shape(a, b);
+            return xassign_traits<decltype(a), decltype(b)>::linear_assign(a, b, true);
+        };
+        auto check_strided_assign = [](auto a, auto b)
+        {
+            assert_compatible_shape(a, b);
+#ifndef _WIN32
+            static_assert(
+                xassign_traits<decltype(a), decltype(b)>::strided_assign(),
+                "Failed to do strided assign"
+            );
+#endif
+            return strided_assign_detail::get_loop_sizes(a, b).can_do_strided_assign;
+        };
+        {
+            size_t size = 50;
+            const std::array<size_t, 3> shape = {size, size, size};
+            xt::xtensor<double, 3> a(shape), b(shape);
+            auto core = xt::range(1, size - 1);
+            auto lhs = xt::view(b, core, core, core);
+            auto rhs = 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));
+            xt::noalias(lhs) = rhs;
+            EXPECT_TRUE(check_strided_assign(lhs, rhs));
+        }
+        {
+            auto data = std::vector<double>{1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
+                                            11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+            auto simple_xtensor_12 = xt::xtensor<double, 2, layout_type::row_major>{
+                {1, 2, 3, 4},
+                {5, 6, 7, 8},
+                {9, 10, 11, 12}
+            };
+            auto simple_xtensor_16 = xt::xtensor<double, 2, layout_type::row_major>{
+                {1, 2, 3, 4},
+                {5, 6, 7, 8},
+                {9, 10, 11, 12},
+                {13, 14, 15, 16}
+            };
+            auto adapter_strided_noncont = xt::adapt(
+                data.data(),
+                12,
+                xt::no_ownership(),
+                std::vector<size_t>{4, 3},
+                std::vector<size_t>{4, 1}
+            );
+            auto adapter_strided_cont = xt::adapt(
+                data.data() + 1,
+                12,
+                xt::no_ownership(),
+                std::vector<size_t>{3, 4},
+                std::vector<size_t>{4, 1}
+            );
+            auto adapter_strided_noncont_43 = xt::adapt(
+                data.data(),
+                12,
+                xt::no_ownership(),
+                std::vector<size_t>{3, 4},
+                std::vector<size_t>{5, 1}
+            );
+            EXPECT_FALSE(check_strided_assign(adapter_strided_noncont, xt::transpose(adapter_strided_cont)));
+            auto contiguous_view = xt::view(simple_xtensor_12, xt::range(0, 3), xt::all());
+            EXPECT_TRUE(check_linear_assign(contiguous_view, adapter_strided_cont));
+            EXPECT_FALSE(check_linear_assign(contiguous_view, xt::transpose(adapter_strided_noncont)));
+            EXPECT_FALSE(check_linear_assign(xt::transpose(adapter_strided_noncont), contiguous_view));
+            EXPECT_FALSE(check_linear_assign(contiguous_view, adapter_strided_noncont_43));
+            EXPECT_FALSE(check_linear_assign(adapter_strided_noncont_43, contiguous_view));
+            EXPECT_TRUE(check_strided_assign(contiguous_view, adapter_strided_noncont_43));
+            EXPECT_TRUE(check_strided_assign(adapter_strided_noncont_43, contiguous_view));
+            auto contiguous_view2 = xt::view(simple_xtensor_12, xt::range(1, 3), xt::all());
+            auto contiguous_view3 = xt::view(simple_xtensor_12, xt::range(0, 2), xt::all());
+            EXPECT_TRUE(check_linear_assign(contiguous_view2, contiguous_view3));
+            {
+                auto view_noncont = xt::view(simple_xtensor_16, xt::all(), xt::range(0, 3));
+                EXPECT_FALSE(check_linear_assign(adapter_strided_noncont, view_noncont));
+                EXPECT_TRUE(check_strided_assign(adapter_strided_noncont, view_noncont));
+            }
+            {
+                auto view_cont = xt::view(simple_xtensor_16, xt::range(0, 1), xt::range(0, 4));
+                auto view_cont2 = xt::view(simple_xtensor_16, xt::range(3, 4), xt::range(0, 4));
+                EXPECT_TRUE(check_linear_assign(view_cont, view_cont2));
+                auto view_noncont = xt::view(simple_xtensor_16, xt::range(0, 4), xt::range(0, 3));
+                auto view_noncont2 = xt::view(simple_xtensor_16, xt::range(0, 4), xt::range(1, 4));
+                EXPECT_FALSE(check_linear_assign(view_noncont, view_noncont2));
+                EXPECT_TRUE(check_strided_assign(view_noncont, view_noncont2));
+            }
+
+            {
+                std::vector<double> data2{-1, -1, -1, -1};
+                auto linear_adapter = xt::adapt<layout_type::row_major>(
+                    data2.data(),
+                    4,
+                    xt::no_ownership(),
+                    std::vector<size_t>{4, 1}
+                );
+                auto adapter_cont2 = xt::adapt<layout_type::row_major>(
+                    data.data(),
+                    4,
+                    xt::no_ownership(),
+                    std::vector<size_t>{1, 4}
+                );
+                EXPECT_TRUE(linear_adapter.is_contiguous());
+                EXPECT_TRUE(adapter_cont2.is_contiguous());
+                bool success_one = check_linear_assign(linear_adapter, xt::transpose(adapter_cont2));
+                bool success_two = check_linear_assign(adapter_cont2, xt::transpose(linear_adapter));
+                EXPECT_TRUE(success_one && success_two);
+                auto adapter_noncont_singlecol = xt::adapt(
+                    data.data(),
+                    4,
+                    xt::no_ownership(),
+                    std::vector<size_t>{4, 1},
+                    std::vector<size_t>{4, 1}
+                );
+                EXPECT_FALSE(check_linear_assign(adapter_noncont_singlecol, linear_adapter));
+                EXPECT_FALSE(check_linear_assign(linear_adapter, adapter_noncont_singlecol));
+                EXPECT_FALSE(check_strided_assign(adapter_noncont_singlecol, linear_adapter));
+                EXPECT_FALSE(check_strided_assign(linear_adapter, adapter_noncont_singlecol));
+                auto adapter_noncont_twocol = xt::adapt(
+                    data.data(),
+                    4,
+                    xt::no_ownership(),
+                    std::vector<size_t>{2, 2},
+                    std::vector<size_t>{4, 1}
+                );
+                EXPECT_FALSE(check_linear_assign(adapter_noncont_twocol, linear_adapter.reshape({2, 2})));
+                EXPECT_FALSE(check_linear_assign(linear_adapter.reshape({2, 2}), adapter_noncont_twocol));
+                EXPECT_TRUE(check_strided_assign(adapter_noncont_twocol, linear_adapter.reshape({2, 2})));
+                EXPECT_TRUE(check_strided_assign(linear_adapter.reshape({2, 2}), adapter_noncont_twocol));
+                auto adapter_zero_strides = xt::adapt(
+                    data.data(),
+                    4,
+                    xt::no_ownership(),
+                    std::vector<size_t>{2, 2},
+                    std::vector<size_t>{0, 0}
+                );
+                EXPECT_FALSE(check_linear_assign(adapter_zero_strides, adapter_zero_strides));
+                EXPECT_FALSE(check_strided_assign(adapter_zero_strides, adapter_zero_strides));
+                EXPECT_FALSE(check_linear_assign(adapter_zero_strides, linear_adapter));
+            }
+
+            {
+                std::vector<double> data2{-1, -1, -1, -1, -1, -1};
+                auto linear_adapter2 = xt::adapt<layout_type::row_major>(
+                    data2.data(),
+                    6,
+                    xt::no_ownership(),
+                    std::vector<size_t>{3, 2}
+                );
+                auto strided_adapter = xt::adapt(
+                    data.data(),
+                    6,
+                    xt::no_ownership(),
+                    std::vector<size_t>{3, 2},
+                    std::vector<size_t>{4, 1}
+                );
+                EXPECT_FALSE(check_linear_assign(linear_adapter2, strided_adapter));
+                EXPECT_FALSE(check_linear_assign(strided_adapter, linear_adapter2));
+                EXPECT_TRUE(check_strided_assign(linear_adapter2, strided_adapter));
+                EXPECT_TRUE(check_strided_assign(strided_adapter, linear_adapter2));
+                xt::noalias(strided_adapter) = linear_adapter2;
+                auto result_expected = std::vector<double>{-1, -1, 3,  4,  -1, -1, 7,  8,  -1, -1,
+                                                           11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
+                EXPECT_EQ(data, result_expected);
+            }
+        }
+    }
+}
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
new file mode 100644
index 000000000..d196ce63c
--- /dev/null
+++ b/test/test_utils.hpp
@@ -0,0 +1,100 @@
+#ifndef TEST_UTILS_HPP
+#define TEST_UTILS_HPP
+
+#include <cmath>
+#include <limits>
+#include <type_traits>
+
+#include "xtensor/core/xexpression.hpp"
+
+namespace xt
+{
+    namespace detail
+    {
+        template <class T>
+        bool check_is_small(const T& value, const T& tolerance)
+        {
+            using std::abs;
+            return abs(value) < abs(tolerance);
+        }
+
+        template <class T>
+        T safe_division(const T& lhs, const T& rhs)
+        {
+            if (rhs < static_cast<T>(1) && lhs > rhs * (std::numeric_limits<T>::max)())
+            {
+                return (std::numeric_limits<T>::max)();
+            }
+            if ((lhs == static_cast<T>(0))
+                || (rhs > static_cast<T>(1) && lhs < rhs * (std::numeric_limits<T>::min)()))
+            {
+                return static_cast<T>(0);
+            }
+            return lhs / rhs;
+        }
+
+        template <class T>
+        bool check_is_close(const T& lhs, const T& rhs, const T& relative_precision)
+        {
+            using std::abs;
+            T diff = abs(lhs - rhs);
+            T d1 = safe_division(diff, T(abs(rhs)));
+            T d2 = safe_division(diff, T(abs(lhs)));
+
+            return d1 <= relative_precision && d2 <= relative_precision;
+        }
+    }
+
+    template <class T>
+    bool scalar_near(const T& lhs, const T& rhs)
+    {
+        using std::abs;
+        using std::max;
+
+        if (std::isnan(lhs))
+        {
+            return std::isnan(rhs);
+        }
+
+        if (std::isinf(lhs))
+        {
+            return std::isinf(rhs) && (lhs * rhs > 0) /* same sign */;
+        }
+
+        T relative_precision = 2048 * std::numeric_limits<T>::epsilon();
+        T absolute_zero_prox = 2048 * std::numeric_limits<T>::epsilon();
+
+        if (max(abs(lhs), abs(rhs)) < T(1e-3))
+        {
+            using res_type = decltype(lhs - rhs);
+            return detail::check_is_small(lhs - rhs, res_type(absolute_zero_prox));
+        }
+        else
+        {
+            return detail::check_is_close(lhs, rhs, relative_precision);
+        }
+    }
+
+    template <class T>
+    bool scalar_near(const std::complex<T>& lhs, const std::complex<T>& rhs)
+    {
+        return scalar_near(lhs.real(), rhs.real()) && scalar_near(lhs.imag(), rhs.imag());
+    }
+
+    template <class E1, class E2>
+    bool tensor_near(const E1& e1, const E2& e2)
+    {
+        bool res = e1.dimension() == e2.dimension()
+                   && std::equal(e1.shape().begin(), e1.shape().end(), e2.shape().begin());
+        auto iter1 = e1.begin();
+        auto iter2 = e2.begin();
+        auto iter_end = e1.end();
+        while (res && iter1 != iter_end)
+        {
+            res = scalar_near(*iter1++, *iter2++);
+        }
+        return res;
+    }
+}
+
+#endif
diff --git a/test/test_xaccumulator.cpp b/test/test_xaccumulator.cpp
index 1e3a62c81..a0eb1f1b2 100644
--- a/test/test_xaccumulator.cpp
+++ b/test/test_xaccumulator.cpp
@@ -1,64 +1,75 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xaccumulator.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xmath.hpp"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xfixed.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/reducers/xaccumulator.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     TEST(xaccumulator, one_d)
     {
-        xt::xarray<short> a = { short(1), short(2), short(3), short(4)};
-        xt::xarray<long> expected = { 1, 3, 6, 10};
+        xt::xarray<short> a = {short(1), short(2), short(3), short(4)};
+        xt::xarray<int> expected = {1, 3, 6, 10};
         auto no_axis = cumsum(a);
         auto with_axis = cumsum(a, 0);
-        bool promotion_works = std::is_same<decltype(no_axis)::value_type, long long>::value;
+        bool promotion_works = std::is_same<decltype(no_axis)::value_type, int>::value;
         EXPECT_TRUE(promotion_works);
         EXPECT_TRUE(all(equal(no_axis, expected)));
 
         EXPECT_TRUE(all(equal(with_axis, expected)));
     }
 
+    TEST(xaccumulator, dim_one)
+    {
+        xt::xarray<double> arr = {{5., 6., 7.}};
+        xt::xarray<double> res = xt::cumsum(arr, 0);
+        EXPECT_EQ(res, arr);
+
+        xt::xarray<double> arr2 = xt::transpose(arr);
+        xt::xarray<double> res2 = xt::cumsum(arr2, 1);
+        EXPECT_EQ(res2, arr2);
+    }
+
     TEST(xaccumulator, four_d)
     {
-        xarray<double> arg_0 = {{{{ 0., 1., 2.},
-                                  { 3., 4., 5.}},
+        xarray<double> arg_0 = {
+            {{{0., 1., 2.}, {3., 4., 5.}},
 
-                                 {{ 6., 7., 8.},
-                                  { 9.,10.,11.}},
+             {{6., 7., 8.}, {9., 10., 11.}},
 
-                                 {{12.,13.,14.},
-                                  {15.,16.,17.}}},
+             {{12., 13., 14.}, {15., 16., 17.}}},
 
 
-                                {{{18.,19.,20.},
-                                  {21.,22.,23.}},
+            {{{18., 19., 20.}, {21., 22., 23.}},
 
-                                 {{24.,25.,26.},
-                                  {27.,28.,29.}},
+             {{24., 25., 26.}, {27., 28., 29.}},
 
-                                 {{30.,31.,32.},
-                                  {33.,34.,35.}}}};
+             {{30., 31., 32.}, {33., 34., 35.}}}
+        };
         auto res = cumsum(arg_0);
-        xarray<double> expected = {  0.,  1.,  3.,  6., 10., 15., 21., 28., 36., 45., 55., 66., 78., 91.,
-                                   105.,120.,136.,153.,171.,190.,210.,231.,253.,276.,300.,325.,351.,378.,
-                                   406.,435.,465.,496.,528.,561.,595.,630.};
-
-        xarray<double> expected_col = {   0.,   18.,   24.,   48.,   60.,   90.,   93.,  114.,  123.,  150.,  165.,  198.,
-                                        199.,  218.,  225.,  250.,  263.,  294.,  298.,  320.,  330.,  358.,  374.,  408.,
-                                        410.,  430.,  438.,  464.,  478.,  510.,  515.,  538.,  549.,  578.,  595.,  630.};
-        if (arg_0.layout() == layout_type::row_major)
+        xarray<double> expected = {0.,   1.,   3.,   6.,   10.,  15.,  21.,  28.,  36.,  45.,  55.,  66.,
+                                   78.,  91.,  105., 120., 136., 153., 171., 190., 210., 231., 253., 276.,
+                                   300., 325., 351., 378., 406., 435., 465., 496., 528., 561., 595., 630.};
+
+        xarray<double> expected_col = {0.,   18.,  24.,  48.,  60.,  90.,  93.,  114., 123.,
+                                       150., 165., 198., 199., 218., 225., 250., 263., 294.,
+                                       298., 320., 330., 358., 374., 408., 410., 430., 438.,
+                                       464., 478., 510., 515., 538., 549., 578., 595., 630.};
+        if (XTENSOR_DEFAULT_TRAVERSAL == layout_type::row_major)
         {
             EXPECT_TRUE(allclose(expected, res));
         }
@@ -68,90 +79,74 @@ namespace xt
         }
 
         auto res_0 = cumsum(arg_0, 0);
-        xarray<double> expected_0 = {{{{ 0., 1., 2.},
-                                       { 3., 4., 5.}},
+        xarray<double> expected_0 = {
+            {{{0., 1., 2.}, {3., 4., 5.}},
 
-                                      {{ 6., 7., 8.},
-                                       { 9.,10.,11.}},
+             {{6., 7., 8.}, {9., 10., 11.}},
 
-                                      {{12.,13.,14.},
-                                       {15.,16.,17.}}},
+             {{12., 13., 14.}, {15., 16., 17.}}},
 
 
-                                     {{{18.,20.,22.},
-                                       {24.,26.,28.}},
+            {{{18., 20., 22.}, {24., 26., 28.}},
 
-                                      {{30.,32.,34.},
-                                       {36.,38.,40.}},
+             {{30., 32., 34.}, {36., 38., 40.}},
 
-                                      {{42.,44.,46.},
-                                       {48.,50.,52.}}}};
+             {{42., 44., 46.}, {48., 50., 52.}}}
+        };
 
         EXPECT_TRUE(all(equal(expected_0, res_0)));
 
         auto res_1 = cumsum(arg_0, 1);
-        xarray<double> expected_1 = {{{{ 0., 1., 2.},
-                                       { 3., 4., 5.}},
+        xarray<double> expected_1 = {
+            {{{0., 1., 2.}, {3., 4., 5.}},
 
-                                      {{ 6., 8.,10.},
-                                       {12.,14.,16.}},
+             {{6., 8., 10.}, {12., 14., 16.}},
 
-                                      {{18.,21.,24.},
-                                       {27.,30.,33.}}},
+             {{18., 21., 24.}, {27., 30., 33.}}},
 
 
-                                     {{{18.,19.,20.},
-                                       {21.,22.,23.}},
+            {{{18., 19., 20.}, {21., 22., 23.}},
 
-                                      {{42.,44.,46.},
-                                       {48.,50.,52.}},
+             {{42., 44., 46.}, {48., 50., 52.}},
 
-                                      {{72.,75.,78.},
-                                       {81.,84.,87.}}}};
+             {{72., 75., 78.}, {81., 84., 87.}}}
+        };
         EXPECT_TRUE(all(equal(res_1, expected_1)));
 
         auto res_2 = cumsum(arg_0, 2);
-        xarray<double> expected_2 = {{{{ 0., 1., 2.},
-                                      { 3., 5., 7.}},
+        xarray<double> expected_2 = {
+            {{{0., 1., 2.}, {3., 5., 7.}},
 
-                                     {{ 6., 7., 8.},
-                                      {15.,17.,19.}},
+             {{6., 7., 8.}, {15., 17., 19.}},
 
-                                     {{12.,13.,14.},
-                                      {27.,29.,31.}}},
+             {{12., 13., 14.}, {27., 29., 31.}}},
 
 
-                                    {{{18.,19.,20.},
-                                      {39.,41.,43.}},
+            {{{18., 19., 20.}, {39., 41., 43.}},
 
-                                     {{24.,25.,26.},
-                                      {51.,53.,55.}},
+             {{24., 25., 26.}, {51., 53., 55.}},
 
-                                     {{30.,31.,32.},
-                                      {63.,65.,67.}}}};
+             {{30., 31., 32.}, {63., 65., 67.}}}
+        };
 
         EXPECT_TRUE(all(equal(res_2, expected_2)));
 
         auto res_3 = cumsum(arg_0, 3);
         auto res_m1 = cumsum(arg_0, -1);
-        xarray<double> expected_3 = {{{{  0.,  1.,  3.},
-                                       {  3.,  7., 12.}},
+        xarray<double> expected_3 = {
+            {{{0., 1., 3.}, {3., 7., 12.}},
 
-                                      {{  6., 13., 21.},
-                                       {  9., 19., 30.}},
+             {{6., 13., 21.}, {9., 19., 30.}},
 
-                                      {{ 12., 25., 39.},
-                                       { 15., 31., 48.}}},
+             {{12., 25., 39.}, {15., 31., 48.}}},
 
 
-                                     {{{ 18., 37., 57.},
-                                       { 21., 43., 66.}},
+            {{{18., 37., 57.}, {21., 43., 66.}},
 
-                                      {{ 24., 49., 75.},
-                                       { 27., 55., 84.}},
+             {{24., 49., 75.}, {27., 55., 84.}},
 
-                                      {{ 30., 61., 93.},
-                                       { 33., 67.,102.}}}};
+             {{30., 61., 93.}, {33., 67., 102.}}}
+        };
         EXPECT_TRUE(allclose(expected_3, res_3));
         EXPECT_TRUE(allclose(expected_3, res_m1));
     }
@@ -168,48 +163,49 @@ namespace xt
 
     TEST(xaccumulator, cumprod)
     {
-        xarray<long> arg_0 = {{ 0, 1, 2},
-                              { 3, 4, 5},
-                              { 6, 7, 8},
-                              { 9,10,11}};
+        xarray<long> arg_0 = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}};
         auto res = cumprod(arg_0);
 
-        xarray<long> expected = {0,0,0,0,0,0,0,0,0,0,0,0};
+        xarray<long> expected = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
         EXPECT_TRUE(allclose(expected, res));
 
         auto res_0 = cumprod(arg_0, 0);
-        xarray<long> expected_0 = {{  0,   1,   2},
-                                   {  0,   4,  10},
-                                   {  0,  28,  80},
-                                   {  0, 280, 880}};
+        xarray<long> expected_0 = {{0, 1, 2}, {0, 4, 10}, {0, 28, 80}, {0, 280, 880}};
         EXPECT_TRUE(allclose(expected_0, res_0));
 
         auto res_1 = cumprod(arg_0, 1);
-        xarray<long> expected_1 = {{  0,  0,   0},
-                                   {  3, 12,  60},
-                                   {  6, 42, 336},
-                                   {  9, 90, 990}};
+        xarray<long> expected_1 = {{0, 0, 0}, {3, 12, 60}, {6, 42, 336}, {9, 90, 990}};
         EXPECT_TRUE(allclose(expected_1, res_1));
     }
 
     TEST(xaccumulator, xfixed)
     {
         xtensor_fixed<float, xshape<2, 4, 3>> a = xt::random::rand<float>({2, 4, 3});
-        auto res = cumsum(a, 1);
+        auto res = cumsum<double>(a, 1);
 
         bool truth = std::is_same<decltype(res), xtensor_fixed<double, xshape<2, 4, 3>>>::value;
         EXPECT_TRUE(truth);
-        xtensor_fixed<long, xshape<4, 3>> arg_0({{ 0, 1, 2},
-                                                 { 3, 4, 5},
-                                                 { 6, 7, 8},
-                                                 { 9,10,11}});
+        xtensor_fixed<long, xshape<4, 3>> arg_0({{0, 1, 2}, {3, 4, 5}, {6, 7, 8}, {9, 10, 11}});
         auto res_0 = cumprod(arg_0, 0);
-        xarray<long> expected_0 = {{  0,   1,   2},
-                                   {  0,   4,  10},
-                                   {  0,  28,  80},
-                                   {  0, 280, 880}};
+        xarray<long> expected_0 = {{0, 1, 2}, {0, 4, 10}, {0, 28, 80}, {0, 280, 880}};
         EXPECT_TRUE(expected_0 == res_0);
         truth = std::is_same<typename decltype(res_0)::shape_type, xshape<4, 3>>::value;
         EXPECT_TRUE(truth);
     }
-}
\ No newline at end of file
+
+    TEST(xaccumulator, empty_array)
+    {
+        xt::xarray<double> a = xt::ones<double>({3, 4, 0});
+
+        auto result0 = xt::cumsum(a);
+        auto expected0 = xt::xarray<double>::from_shape({0});
+        EXPECT_EQ(result0, expected0);
+
+        auto result1 = xt::cumsum(a, 2);
+        auto expected = xt::xarray<double>::from_shape({3, 4, 0});
+        EXPECT_EQ(result1, expected);
+
+        auto result2 = xt::cumsum(a, 1);
+        EXPECT_EQ(result2, expected);
+    }
+}
diff --git a/test/test_xadapt.cpp b/test/test_xadapt.cpp
index bad328cc9..ef5451b91 100644
--- a/test/test_xadapt.cpp
+++ b/test/test_xadapt.cpp
@@ -1,19 +1,75 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
-#include "xtensor/xadapt.hpp"
-#include "xtensor/xstrides.hpp"
+#include "xtensor/containers/xadapt.hpp"
+#include "xtensor/core/xstrides.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     using vec_type = std::vector<int>;
 
+    TEST(xarray_adaptor, xarray_pointer)
+    {
+        std::vector<int> data(4, 0);
+        xt::svector<std::size_t> shape = {2, 2};
+        xt::xarray_pointer<int> a = xt::adapt(data.data(), data.size(), xt::no_ownership(), shape);
+
+        a(0, 0) = 0;
+        a(0, 1) = 1;
+        a(1, 0) = 2;
+        a(1, 1) = 3;
+
+        if (XTENSOR_DEFAULT_LAYOUT == xt::layout_type::row_major)
+        {
+            EXPECT_EQ(0, data[0]);
+            EXPECT_EQ(1, data[1]);
+            EXPECT_EQ(2, data[2]);
+            EXPECT_EQ(3, data[3]);
+        }
+        else
+        {
+            EXPECT_EQ(0, data[0]);
+            EXPECT_EQ(2, data[1]);
+            EXPECT_EQ(1, data[2]);
+            EXPECT_EQ(3, data[3]);
+        }
+    }
+
+    TEST(xtensor_adaptor, xtensor_pointer)
+    {
+        std::vector<int> data(4, 0);
+        std::array<std::size_t, 2> shape = {2, 2};
+        xt::xtensor_pointer<int, 2> a = xt::adapt(data.data(), data.size(), xt::no_ownership(), shape);
+
+        a(0, 0) = 0;
+        a(0, 1) = 1;
+        a(1, 0) = 2;
+        a(1, 1) = 3;
+
+        if (XTENSOR_DEFAULT_LAYOUT == xt::layout_type::row_major)
+        {
+            EXPECT_EQ(0, data[0]);
+            EXPECT_EQ(1, data[1]);
+            EXPECT_EQ(2, data[2]);
+            EXPECT_EQ(3, data[3]);
+        }
+        else
+        {
+            EXPECT_EQ(0, data[0]);
+            EXPECT_EQ(2, data[1]);
+            EXPECT_EQ(1, data[2]);
+            EXPECT_EQ(3, data[3]);
+        }
+    }
+
     TEST(xarray_adaptor, adapt)
     {
         vec_type v(4, 0);
@@ -60,11 +116,32 @@ namespace xt
         delete[] data;
     }
 
+    TEST(xarray_adaptor, pointer_no_ownership_replace)
+    {
+        size_t size = 4;
+        int* data = new int[3 * size];
+        using shape_type = std::vector<vec_type::size_type>;
+        shape_type s({2, 2});
+
+        auto a1 = adapt(data, size, no_ownership(), s);
+        size_t st = static_cast<size_t>(a1.strides()[0]);
+
+        for (size_t i = 0; i < 3; ++i)
+        {
+            a1.reset_buffer(&data[i * size], size);
+            a1(1, 0) = static_cast<int>(i);
+            EXPECT_EQ(i, data[i * size + st]);
+        }
+
+        delete[] data;
+    }
+
     TEST(xarray_adaptor, pointer_acquire_ownership)
     {
         size_t size = 4;
         int* data = std::allocator<int>{}.allocate(size);
-        int* data2 =  std::allocator<int>{}.allocate(size);;
+        int* data2 = std::allocator<int>{}.allocate(size);
+        ;
         using shape_type = std::vector<vec_type::size_type>;
         shape_type s({2, 2});
 
@@ -78,6 +155,31 @@ namespace xt
         EXPECT_EQ(1, data2[2]);
     }
 
+    TEST(xarray_adaptor, c_stack_array)
+    {
+        double data[4] = {1., 2., 3., 4.};
+        using shape_type = std::vector<vec_type::size_type>;
+        shape_type s({2, 2});
+        auto a = adapt(data, s);
+
+        EXPECT_EQ(a.size(), 4u);
+        if (XTENSOR_DEFAULT_LAYOUT == xt::layout_type::row_major)
+        {
+            EXPECT_EQ(a(0, 1), 2.);
+            EXPECT_EQ(a(1, 0), 3.);
+        }
+        else
+        {
+            EXPECT_EQ(a(0, 1), 3.);
+            EXPECT_EQ(a(1, 0), 2.);
+        }
+        shape_type str({2, 1});
+        auto b = adapt(data, s, str);
+        EXPECT_EQ(b.size(), 4u);
+        EXPECT_EQ(b(0, 1), 2.);
+        EXPECT_EQ(b(1, 0), 3.);
+    }
+
     TEST(xarray_adaptor, no_ownership_assign)
     {
         size_t size = 1;
@@ -85,7 +187,7 @@ namespace xt
         int data2 = 1;
         int data3;
         using shape_type = std::vector<vec_type::size_type>;
-        shape_type s({ 1 });
+        shape_type s({1});
 
         auto a1 = adapt(&data1, size, no_ownership(), s);
         auto a2 = adapt(&data2, size, no_ownership(), s);
@@ -103,7 +205,7 @@ namespace xt
         data2[0] = 1;
         int* data3 = nullptr;
         using shape_type = std::vector<vec_type::size_type>;
-        shape_type s({ 1 });
+        shape_type s({1});
 
         auto a1 = adapt(data1, size, acquire_ownership(), s);
         auto a2 = adapt(data2, size, acquire_ownership(), s);
@@ -118,7 +220,7 @@ namespace xt
         int* data = new int[size];
 
         using shape_type = std::vector<vec_type::size_type>;
-        shape_type s = { size };
+        shape_type s = {size};
 
         auto a0 = adapt<layout_type::dynamic>(data, size, no_ownership(), s, layout_type::row_major);
         a0(3) = 3;
@@ -185,6 +287,25 @@ namespace xt
         delete[] data;
     }
 
+    TEST(xtensor_adaptor, pointer_no_ownership_replace)
+    {
+        size_t size = 4;
+        int* data = new int[3 * size];
+        std::array<size_t, 2> shape = {2, 2};
+
+        auto a1 = adapt(data, size, no_ownership(), shape);
+        size_t st = static_cast<size_t>(a1.strides()[0]);
+
+        for (size_t i = 0; i < 3; ++i)
+        {
+            a1.reset_buffer(&data[i * size], size);
+            a1(1, 0) = static_cast<int>(i);
+            EXPECT_EQ(i, data[i * size + st]);
+        }
+
+        delete[] data;
+    }
+
     TEST(xtensor_adaptor, pointer_const_no_ownership)
     {
         size_t size = 4;
@@ -195,6 +316,7 @@ namespace xt
         auto a0_view = adapt(const_data, size, no_ownership());
         a0(3) = 3;
         EXPECT_EQ(3, a0_view[3]);
+        EXPECT_EQ(a0.data(), a0_view.data());
 
         using shape_type = std::array<vec_type::size_type, 2>;
         shape_type s = {2, 2};
@@ -249,6 +371,32 @@ namespace xt
         EXPECT_EQ(1, data2[2]);
     }
 
+    TEST(xtensor_adaptor, c_stack_array)
+    {
+        double data[4] = {1., 2., 3., 4.};
+        using shape_type = std::array<vec_type::size_type, 2>;
+        shape_type s = {2, 2};
+        auto a = adapt(data, s);
+
+        EXPECT_EQ(a.size(), 4u);
+        if (XTENSOR_DEFAULT_LAYOUT == xt::layout_type::row_major)
+        {
+            EXPECT_EQ(a(0, 1), 2.);
+            EXPECT_EQ(a(1, 0), 3.);
+        }
+        else
+        {
+            EXPECT_EQ(a(0, 1), 3.);
+            EXPECT_EQ(a(1, 0), 2.);
+        }
+
+        shape_type str = {2, 1};
+        auto b = adapt(data, s, str);
+        EXPECT_EQ(b.size(), 4u);
+        EXPECT_EQ(b(0, 1), 2.);
+        EXPECT_EQ(b(1, 0), 3.);
+    }
+
     TEST(xtensor_adaptor, no_ownership_assign)
     {
         size_t size = 1;
@@ -256,7 +404,7 @@ namespace xt
         int data2 = 1;
         int data3;
         using shape_type = std::array<vec_type::size_type, 1>;
-        shape_type s = { 1 };
+        shape_type s = {1};
 
         auto a1 = adapt(&data1, size, no_ownership(), s);
         auto a2 = adapt(&data2, size, no_ownership(), s);
@@ -276,7 +424,7 @@ namespace xt
         int* p_data3 = &data3;
 
         using shape_type = std::array<vec_type::size_type, 1>;
-        shape_type s = { 1 };
+        shape_type s = {1};
 
         auto a1 = adapt(p_data1, size, no_ownership(), s);
         auto a2 = adapt(p_data2, size, no_ownership(), s);
@@ -296,7 +444,7 @@ namespace xt
         data2[0] = 1;
         int* data3 = nullptr;
         using shape_type = std::array<vec_type::size_type, 1>;
-        shape_type s = { 1 };
+        shape_type s = {1};
 
         auto a1 = adapt(data1, size, acquire_ownership(), s);
         auto a2 = adapt(data2, size, acquire_ownership(), s);
@@ -311,7 +459,7 @@ namespace xt
         int* data = new int[size];
 
         using shape_type = std::array<vec_type::size_type, 1>;
-        shape_type s = { size };
+        shape_type s = {size};
 
         auto a0 = adapt<layout_type::dynamic>(data, size, no_ownership(), s, layout_type::column_major);
         a0(3) = 3;
@@ -322,7 +470,7 @@ namespace xt
 
     TEST(xarray_adaptor, short_syntax)
     {
-        std::vector<int> a({1,2,3,4,5,6,7,8});
+        std::vector<int> a({1, 2, 3, 4, 5, 6, 7, 8});
         auto xa = adapt(&a[1], std::vector<std::size_t>({3}));
         xa(1) = 123;
 
@@ -332,16 +480,12 @@ namespace xt
 
     TEST(xtensor_adaptor, nice_syntax)
     {
-        std::vector<int> a({1,2,3,4,5,6,7,8});
-#ifndef X_OLD_CLANG
+        std::vector<int> a({1, 2, 3, 4, 5, 6, 7, 8});
+
         auto xa = adapt(&a[0], {2, 4});
         bool truthy = std::is_same<decltype(xa)::shape_type, std::array<std::size_t, 2>>::value;
         EXPECT_TRUE(truthy);
-#else
-        auto xa = adapt(&a[0], {2, 4});
-        bool truthy = std::is_same<decltype(xa)::shape_type, xt::dynamic_shape<size_t>>::value;
-        EXPECT_TRUE(truthy);
-#endif
+
         xa(0, 0) = 100;
         xa(1, 3) = 1000;
         EXPECT_EQ(a[0], 100);
@@ -350,7 +494,7 @@ namespace xt
 
     TEST(xtensor_fixed_adaptor, adapt)
     {
-        std::vector<int> a({1,2,3,4,5,6,7,8});
+        std::vector<int> a({1, 2, 3, 4, 5, 6, 7, 8});
         auto xa = adapt(&a[0], xshape<2, 4>());
         xa(0, 0) = 100;
         xa(1, 3) = 1000;
@@ -358,15 +502,116 @@ namespace xt
         EXPECT_EQ(a[7], 1000);
         bool truthy = std::is_same<decltype(xa)::shape_type, xshape<2, 4>>::value;
         EXPECT_TRUE(truthy);
-        const std::vector<int> b({5,5,19,5});
+        const std::vector<int> b({5, 5, 19, 5});
         auto xb = adapt(&b[0], xshape<2, 2>());
         if (XTENSOR_DEFAULT_LAYOUT == layout_type::row_major)
         {
-            EXPECT_EQ(xb(1,0), 19);
+            EXPECT_EQ(xb(1, 0), 19);
+        }
+        else
+        {
+            EXPECT_EQ(xb(1, 0), 5);
+        }
+    }
+
+    namespace xadapt_test
+    {
+        struct Buffer
+        {
+            std::vector<double> buf;
+
+            Buffer(std::vector<double>& ibuf)
+                : buf(ibuf)
+            {
+            }
+        };
+    }
+
+    TEST(xarray_adaptor, smart_ptr)
+    {
+        auto data = std::vector<double>{1, 2, 3, 4, 5, 6, 7, 8};
+        auto shared_buf = std::make_shared<xadapt_test::Buffer>(data);
+        auto unique_buf = std::make_unique<xadapt_test::Buffer>(data);
+        std::vector<size_t> shape = {4, 2};
+
+        std::shared_ptr<double> dptr(new double[8], std::default_delete<double[]>());
+        dptr.get()[2] = 2.1;
+        auto xdptr = adapt_smart_ptr(dptr, shape);
+
+        if (XTENSOR_DEFAULT_LAYOUT == layout_type::row_major)
+        {
+            EXPECT_EQ(xdptr(1, 0), 2.1);
+            xdptr(3, 1) = 123.;
+            EXPECT_EQ(dptr.get()[7], 123.);
         }
         else
         {
-            EXPECT_EQ(xb(1,0), 5);
+            EXPECT_EQ(xdptr(2, 0), 2.1);
+            xdptr(3, 1) = 123.;
+            EXPECT_EQ(dptr.get()[7], 123.);
+        }
+
+        EXPECT_EQ(shared_buf.use_count(), 1);
+        {
+            auto obj = adapt_smart_ptr(shared_buf.get()->buf.data(), shape, shared_buf);
+            EXPECT_EQ(shared_buf.use_count(), 2);
+        }
+        EXPECT_EQ(shared_buf.use_count(), 1);
+
+        {
+            auto obj = adapt_smart_ptr(unique_buf.get()->buf.data(), shape, std::move(unique_buf));
+        }
+    }
+
+    TEST(xtensor_adaptor, pointer_strided_fill)
+    {
+        auto data = std::vector<double>{1, 2, 3, 4, 5, 6, 7, 8};
+        auto adapter = xt::adapt(
+            data.data(),
+            4,
+            xt::no_ownership(),
+            std::vector<size_t>{4, 1},
+            std::vector<size_t>{2, 1}
+        );
+        adapter.fill(0);
+        EXPECT_EQ(data[0], 0);
+        EXPECT_EQ(data[3], 4);
+        EXPECT_EQ(data[4], 0);
+        EXPECT_EQ(data[5], 6);
+    }
+
+    TEST(xtensor_adaptor, smart_ptr)
+    {
+        auto data = std::vector<double>{1, 2, 3, 4, 5, 6, 7, 8};
+        auto shared_buf = std::make_shared<xadapt_test::Buffer>(data);
+        auto unique_buf = std::make_unique<xadapt_test::Buffer>(data);
+
+        std::shared_ptr<double> dptr(new double[8], std::default_delete<double[]>());
+        dptr.get()[2] = 2.1;
+        auto xdptr = adapt_smart_ptr(dptr, {4, 2});
+
+        if (XTENSOR_DEFAULT_LAYOUT == layout_type::row_major)
+        {
+            EXPECT_EQ(xdptr(1, 0), 2.1);
+            xdptr(3, 1) = 123.;
+            EXPECT_EQ(dptr.get()[7], 123.);
+        }
+        else
+        {
+            EXPECT_EQ(xdptr(2, 0), 2.1);
+            xdptr(3, 1) = 123.;
+            EXPECT_EQ(dptr.get()[7], 123.);
+        }
+
+        EXPECT_EQ(shared_buf.use_count(), 1);
+        {
+            auto obj = adapt_smart_ptr(shared_buf.get()->buf.data(), {2, 4}, shared_buf);
+            EXPECT_EQ(shared_buf.use_count(), 2);
+        }
+        EXPECT_EQ(shared_buf.use_count(), 1);
+
+        {
+            auto obj = adapt_smart_ptr(unique_buf.get()->buf.data(), {2, 4}, std::move(unique_buf));
         }
     }
 }
diff --git a/test/test_xadaptor_semantic.cpp b/test/test_xadaptor_semantic.cpp
index 5f8a6c13a..245d690b4 100644
--- a/test/test_xadaptor_semantic.cpp
+++ b/test/test_xadaptor_semantic.cpp
@@ -1,14 +1,17 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
+
+#include "test_common.hpp"
 #include "test_xsemantic.hpp"
 
+TEST_SUITE_BEGIN("adaptor_semantic");
+
 namespace xt
 {
     using vector_type = std::vector<int>;
@@ -34,46 +37,56 @@ namespace xt
     using get_test_adaptor_t = typename get_test_adaptor<C>::type;
 
     template <class C>
-    class adaptor_semantic : public ::testing::Test
+    class adaptor_semantic
     {
     public:
+
         using container_type = C;
         using adaptor_type = get_test_adaptor_t<C>;
     };
 
-    using testing_types = ::testing::Types<xarray_dynamic, xtensor_dynamic>;
-    TYPED_TEST_CASE(adaptor_semantic, testing_types);
+#define ADAPTOR_SEMANTIC_TYPES xarray_dynamic, xtensor_dynamic
 
-    TYPED_TEST(adaptor_semantic, a_plus_b)
+    TEST_CASE_TEMPLATE("xsimd_info", TypeParam, ADAPTOR_SEMANTIC_TYPES)
+    {
+#if defined(XTENSOR_USE_XSIMD)
+        std::cout << "Built with XSIMD" << std::endl;
+        std::cout << " arch " << xsimd::default_arch::name() << std::endl;
+#else
+        std::cout << "Built without XSIMD" << std::endl;
+#endif
+    }
+
+    TEST_CASE_TEMPLATE("a_plus_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::plus<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
+        SUBCASE("row_major + row_major")
         {
-            SCOPED_TRACE("row_major + row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a + tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major + column_major")
         {
-            SCOPED_TRACE("row_major + column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a + tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major + central_major")
         {
-            SCOPED_TRACE("row_major + central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a + tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major + unit_major")
         {
-            SCOPED_TRACE("row_major + unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a + tester.ua;
@@ -81,37 +94,37 @@ namespace xt
         }
     }
 
-    TYPED_TEST(adaptor_semantic, a_minus_b)
+    TEST_CASE_TEMPLATE("a_minus_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::minus<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
 
+        SUBCASE("row_major - row_major")
         {
-            SCOPED_TRACE("row_major - row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a - tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major - column_major")
         {
-            SCOPED_TRACE("row_major - column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a - tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major - central_major")
         {
-            SCOPED_TRACE("row_major - central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a - tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major - unit_major")
         {
-            SCOPED_TRACE("row_major - unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a - tester.ua;
@@ -119,37 +132,37 @@ namespace xt
         }
     }
 
-    TYPED_TEST(adaptor_semantic, a_times_b)
+    TEST_CASE_TEMPLATE("a_times_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::multiplies<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
 
+        SUBCASE("row_major * row_major")
         {
-            SCOPED_TRACE("row_major * row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a * tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major * column_major")
         {
-            SCOPED_TRACE("row_major * column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a * tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major * central_major")
         {
-            SCOPED_TRACE("row_major * central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a * tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major * unit_major")
         {
-            SCOPED_TRACE("row_major * unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a * tester.ua;
@@ -157,37 +170,37 @@ namespace xt
         }
     }
 
-    TYPED_TEST(adaptor_semantic, a_divide_by_b)
+    TEST_CASE_TEMPLATE("a_divide_by_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::divides<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
 
+        SUBCASE("row_major / row_major")
         {
-            SCOPED_TRACE("row_major / row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a / tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major / column_major")
         {
-            SCOPED_TRACE("row_major / column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a / tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major / central_major")
         {
-            SCOPED_TRACE("row_major / central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a / tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major / unit_major")
         {
-            SCOPED_TRACE("row_major / unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a / tester.ua;
@@ -195,13 +208,13 @@ namespace xt
         }
     }
 
-    TYPED_TEST(adaptor_semantic, a_plus_equal_b)
+    TEST_CASE_TEMPLATE("a_plus_equal_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::plus<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
 
+        SUBCASE("row_major += row_major")
         {
-            SCOPED_TRACE("row_major += row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -209,8 +222,8 @@ namespace xt
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major += column_major")
         {
-            SCOPED_TRACE("row_major += column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -218,8 +231,8 @@ namespace xt
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major += central_major")
         {
-            SCOPED_TRACE("row_major += central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -227,8 +240,8 @@ namespace xt
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major += unit_major")
         {
-            SCOPED_TRACE("row_major += unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -237,13 +250,13 @@ namespace xt
         }
     }
 
-    TYPED_TEST(adaptor_semantic, a_minus_equal_b)
+    TEST_CASE_TEMPLATE("a_minus_equal_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::minus<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
 
+        SUBCASE("row_major -= row_major")
         {
-            SCOPED_TRACE("row_major -= row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -251,8 +264,8 @@ namespace xt
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major -= column_major")
         {
-            SCOPED_TRACE("row_major -= column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -260,8 +273,8 @@ namespace xt
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major -= central_major")
         {
-            SCOPED_TRACE("row_major -= central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -269,8 +282,8 @@ namespace xt
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major -= unit_major")
         {
-            SCOPED_TRACE("row_major -= unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -279,13 +292,13 @@ namespace xt
         }
     }
 
-    TYPED_TEST(adaptor_semantic, a_times_equal_b)
+    TEST_CASE_TEMPLATE("a_times_equal_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::multiplies<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
 
+        SUBCASE("row_major *= row_major")
         {
-            SCOPED_TRACE("row_major *= row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -293,8 +306,8 @@ namespace xt
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major *= column_major")
         {
-            SCOPED_TRACE("row_major *= column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -302,8 +315,8 @@ namespace xt
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major *= central_major")
         {
-            SCOPED_TRACE("row_major *= central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -311,8 +324,8 @@ namespace xt
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major *= unit_major")
         {
-            SCOPED_TRACE("row_major *= unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -321,13 +334,13 @@ namespace xt
         }
     }
 
-    TYPED_TEST(adaptor_semantic, a_divide_by_equal_b)
+    TEST_CASE_TEMPLATE("a_divide_by_equal_b", TypeParam, ADAPTOR_SEMANTIC_TYPES)
     {
         operation_tester<std::divides<>, TypeParam> tester;
-        using adaptor_type = typename TestFixture::adaptor_type;
+        using adaptor_type = typename adaptor_semantic<TypeParam>::adaptor_type;
 
+        SUBCASE("row_major /= row_major")
         {
-            SCOPED_TRACE("row_major /= row_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -335,8 +348,8 @@ namespace xt
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major /= column_major")
         {
-            SCOPED_TRACE("row_major /= column_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -344,8 +357,8 @@ namespace xt
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major /= central_major")
         {
-            SCOPED_TRACE("row_major /= central_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -353,8 +366,8 @@ namespace xt
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major /= unit_major")
         {
-            SCOPED_TRACE("row_major /= unit_major");
             vector_type v;
             adaptor_type b(v);
             b = tester.a;
@@ -362,4 +375,8 @@ namespace xt
             EXPECT_EQ(tester.res_ru, b);
         }
     }
+
+#undef ADAPTOR_SEMANTIC_TYPES
 }
+
+TEST_SUITE_END();
diff --git a/test/test_xarray.cpp b/test/test_xarray.cpp
index d2b15a3ab..41fe4fec8 100644
--- a/test/test_xarray.cpp
+++ b/test/test_xarray.cpp
@@ -1,16 +1,20 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xmanipulation.hpp"
-#include "xtensor/xio.hpp"
+ * 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. *
+ ****************************************************************************/
+
+
+#include <type_traits>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+
 #include "test_common.hpp"
 
 namespace xt
@@ -19,22 +23,22 @@ namespace xt
 
     TEST(xarray, shaped_constructor)
     {
+        SUBCASE("row_major constructor")
         {
-            SCOPED_TRACE("row_major constructor");
             row_major_result<> rm;
             xarray_dynamic ra(rm.m_shape, layout_type::row_major);
             compare_shape(ra, rm);
         }
 
+        SUBCASE("column_major constructor")
         {
-            SCOPED_TRACE("column_major constructor");
             column_major_result<> cm;
             xarray<int, layout_type::column_major> ca(cm.m_shape);
             compare_shape(ca, cm);
         }
 
+        SUBCASE("from shape")
         {
-            SCOPED_TRACE("from shape");
             std::array<std::size_t, 3> shp = {5, 4, 2};
             std::vector<std::size_t> shp_as_vec = {5, 4, 2};
             auto ca = xarray<int, layout_type::column_major>::from_shape({3, 2, 1});
@@ -54,8 +58,8 @@ namespace xt
 
     TEST(xarray, valued_constructor)
     {
+        SUBCASE("row_major valued constructor")
         {
-            SCOPED_TRACE("row_major valued constructor");
             row_major_result<> rm;
             int value = 2;
             xarray_dynamic ra(rm.m_shape, value, layout_type::row_major);
@@ -64,8 +68,8 @@ namespace xt
             EXPECT_EQ(ra.storage(), vec);
         }
 
+        SUBCASE("column_major valued constructor")
         {
-            SCOPED_TRACE("column_major valued constructor");
             column_major_result<> cm;
             int value = 2;
             xarray<int, layout_type::column_major> ca(cm.m_shape, value);
@@ -98,15 +102,15 @@ namespace xt
         int value = 2;
         xarray_dynamic a(res.m_shape, res.m_strides, value);
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             xarray_dynamic b(a);
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("assignment operator")
         {
-            SCOPED_TRACE("assignment operator");
             row_major_result<> r;
             xarray_dynamic c(r.m_shape, 0);
             EXPECT_NE(a.storage(), c.storage());
@@ -122,16 +126,16 @@ namespace xt
         int value = 2;
         xarray_dynamic a(res.m_shape, res.m_strides, value);
 
+        SUBCASE("move constructor")
         {
-            SCOPED_TRACE("move constructor");
             xarray_dynamic tmp(a);
             xarray_dynamic b(std::move(tmp));
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("move assignment")
         {
-            SCOPED_TRACE("move assignment");
             row_major_result<> r;
             xarray_dynamic c(r.m_shape, 0);
             EXPECT_NE(a.storage(), c.storage());
@@ -145,13 +149,21 @@ namespace xt
     TEST(xarray, resize)
     {
         xarray_dynamic a;
+        std::vector<size_t> shape = {2, 2};
+        xarray_dynamic::strides_type strides = {2, 1};
         test_resize(a);
+#ifdef XTENSOR_ENABLE_ASSERT
+        EXPECT_NO_THROW(a.resize(shape));
+        EXPECT_NO_THROW(a.resize(shape, layout_type::row_major));
+        EXPECT_NO_THROW(a.resize(shape, strides));
+#endif
     }
 
     TEST(xarray, reshape)
     {
         xarray_dynamic a;
         test_reshape(a);
+        test_throwing_reshape(a);
     }
 
     TEST(xarray, transpose)
@@ -173,11 +185,13 @@ namespace xt
         EXPECT_EQ(res(3, 0), 1.f);
     }
 
+#if !(defined(XTENSOR_ENABLE_ASSERT) && defined(XTENSOR_DISABLE_EXCEPTIONS))
     TEST(xarray, access)
     {
         xarray_dynamic a;
         test_access(a);
     }
+#endif
 
     TEST(xarray, unchecked)
     {
@@ -191,11 +205,13 @@ namespace xt
         test_at(a);
     }
 
+#if !(defined(XTENSOR_ENABLE_ASSERT) && defined(XTENSOR_DISABLE_EXCEPTIONS))
     TEST(xarray, element)
     {
         xarray_dynamic a;
         test_element(a);
     }
+#endif
 
     TEST(xarray, indexed_access)
     {
@@ -236,11 +252,16 @@ namespace xt
     TEST(xarray, zerod)
     {
         xarray_dynamic a;
+        EXPECT_EQ(0u, a.dimension());
         EXPECT_EQ(0, a());
 
         xarray_dynamic b = {1, 2, 3};
         xarray_dynamic c(2 + xt::sum(b));
         EXPECT_EQ(8, c());
+
+        EXPECT_EQ(8, c(1, 2));
+        xindex idx = {1, 2};
+        EXPECT_EQ(8, c.element(idx.cbegin(), idx.cend()));
     }
 
     TEST(xarray, xiterator)
@@ -257,10 +278,8 @@ namespace xt
 
     TEST(xarray, cross_layout_assign)
     {
-        xarray<int, layout_type::row_major> a = {{1, 2, 3, 4},
-                                                 {5, 6, 7, 8}};
-        xarray<int, layout_type::column_major> b = {{1, 2, 3, 4},
-                                                    {5, 6, 7, 8}};
+        xarray<int, layout_type::row_major> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<int, layout_type::column_major> b = {{1, 2, 3, 4}, {5, 6, 7, 8}};
 
         xarray<int, layout_type::column_major> ra = a;
         EXPECT_EQ(b, ra);
@@ -277,12 +296,18 @@ namespace xt
 
     TEST(xarray, move_from_xtensor)
     {
-        xtensor<double, 3> a = {{{1,2,3}, {4,5,6}}, {{10, 10, 10}, {1,5,10}}};
+        xtensor<double, 3> a = {{{1, 2, 3}, {4, 5, 6}}, {{10, 10, 10}, {1, 5, 10}}};
         xtensor<double, 3> a1 = a;
         xarray<double> b(std::move(a1));
         EXPECT_EQ(a, b);
-        EXPECT_TRUE(std::equal(a.strides().begin(), a.strides().end(), b.strides().begin()) && a.strides().size() == b.strides().size());
-        EXPECT_TRUE(std::equal(a.backstrides().begin(), a.backstrides().end(), b.backstrides().begin()) && a.backstrides().size() == b.backstrides().size());
+        EXPECT_TRUE(
+            std::equal(a.strides().begin(), a.strides().end(), b.strides().begin())
+            && a.strides().size() == b.strides().size()
+        );
+        EXPECT_TRUE(
+            std::equal(a.backstrides().begin(), a.backstrides().end(), b.backstrides().begin())
+            && a.backstrides().size() == b.backstrides().size()
+        );
         EXPECT_EQ(a.layout(), b.layout());
 
         xtensor<double, 3> a2 = a;
@@ -290,8 +315,138 @@ namespace xt
         c = std::move(a2);
 
         EXPECT_EQ(a, c);
-        EXPECT_TRUE(std::equal(a.strides().begin(), a.strides().end(), c.strides().begin()) && a.strides().size() == c.strides().size());
-        EXPECT_TRUE(std::equal(a.backstrides().begin(), a.backstrides().end(), c.backstrides().begin()) && a.backstrides().size() == c.backstrides().size());
+        EXPECT_TRUE(
+            std::equal(a.strides().begin(), a.strides().end(), c.strides().begin())
+            && a.strides().size() == c.strides().size()
+        );
+        EXPECT_TRUE(
+            std::equal(a.backstrides().begin(), a.backstrides().end(), c.backstrides().begin())
+            && a.backstrides().size() == c.backstrides().size()
+        );
         EXPECT_EQ(a.layout(), c.layout());
     }
+
+    TEST(xarray, operator_brace)
+    {
+#ifdef XTENSOR_ENABLE_ASSERT
+        xt::xarray<size_t> a = {{0, 1, 2}, {3, 4, 5}};
+        EXPECT_THROW(a(2, 0), std::runtime_error);
+        EXPECT_THROW(a(0, 3), std::runtime_error);
+
+        xt::xarray<size_t> b = {{0, 1, 2}};
+        EXPECT_THROW(a(0, 3), std::runtime_error);
+        EXPECT_THROW(a(1, 3), std::runtime_error);
+#endif
+    }
+
+    TEST(xarray, periodic)
+    {
+        xt::xarray<size_t> a = {{0, 1, 2}, {3, 4, 5}};
+        xt::xarray<size_t> b = {{0, 1, 2}, {30, 40, 50}};
+        a.periodic(-1, 3) = 30;
+        a.periodic(-1, 4) = 40;
+        a.periodic(-1, 5) = 50;
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xarray, front)
+    {
+        xt::xarray<size_t> a = {{1, 2, 3}, {4, 5, 6}};
+        EXPECT_EQ(a.front(), 1);
+    }
+
+    TEST(xarray, back)
+    {
+        xt::xarray<size_t> a = {{1, 2, 3}, {4, 5, 6}};
+        EXPECT_EQ(a.back(), 6);
+    }
+
+    TEST(xarray, flat)
+    {
+        {
+            xt::xarray<size_t, xt::layout_type::row_major> a = {{0, 1, 2}, {3, 4, 5}};
+            xt::xarray<size_t, xt::layout_type::row_major> b = {{0, 1, 2}, {30, 40, 50}};
+            a.flat(3) = 30;
+            a.flat(4) = 40;
+            a.flat(5) = 50;
+            EXPECT_EQ(a, b);
+#ifdef XTENSOR_ENABLE_ASSERT
+            EXPECT_THROW(a.flat(6), std::runtime_error);
+#endif
+        }
+        {
+            xt::xarray<size_t, xt::layout_type::column_major> a = {{0, 1, 2}, {3, 4, 5}};
+            xt::xarray<size_t, xt::layout_type::column_major> b = {{0, 1, 2}, {30, 40, 50}};
+            a.flat(1) = 30;
+            a.flat(3) = 40;
+            a.flat(5) = 50;
+            EXPECT_EQ(a, b);
+#ifdef XTENSOR_ENABLE_ASSERT
+            EXPECT_THROW(a.flat(6), std::runtime_error);
+#endif
+        }
+    }
+
+    TEST(xarray, in_bounds)
+    {
+        xt::xarray<size_t> a = {{0, 1, 2}, {3, 4, 5}};
+        EXPECT_TRUE(a.in_bounds(0, 0) == true);
+        EXPECT_TRUE(a.in_bounds(2, 0) == false);
+    }
+
+    TEST(xarray, iterator_types)
+    {
+        using array_type = xarray<int>;
+        test_iterator_types<array_type, int*, const int*>();
+    }
+
+    auto test_reshape_compile()
+    {
+        xt::xarray<double> a = xt::zeros<double>({5, 5});
+        return a.reshape({1, 25});
+    }
+
+    TEST(xarray, reshape_return)
+    {
+        auto a = test_reshape_compile();
+        EXPECT_EQ(a.shape(), std::vector<std::size_t>({1, 25}));
+    }
+
+    TEST(xarray, type_traits)
+    {
+        using array_type = xt::xarray<double>;
+        EXPECT_TRUE(std::is_constructible<array_type>::value);
+
+        EXPECT_TRUE(std::is_default_constructible<array_type>::value);
+
+        EXPECT_TRUE(std::is_copy_constructible<array_type>::value);
+
+        EXPECT_TRUE(std::is_move_constructible<array_type>::value);
+        EXPECT_TRUE(std::is_nothrow_move_constructible<array_type>::value);
+
+        EXPECT_TRUE(std::is_copy_assignable<array_type>::value);
+
+        EXPECT_TRUE(std::is_move_assignable<array_type>::value);
+        EXPECT_TRUE(std::is_nothrow_move_assignable<array_type>::value);
+
+        EXPECT_TRUE(std::is_destructible<array_type>::value);
+        EXPECT_TRUE(std::is_nothrow_destructible<array_type>::value);
+    }
+
+    TEST(xarray, bool_container)
+    {
+        xt::xarray<int> a{1, 0, 1, 0}, b{1, 1, 0, 0};
+
+        xt::xarray<bool> c = a & b;
+        EXPECT_TRUE(c(0));
+        EXPECT_FALSE(c(1));
+        EXPECT_FALSE(c(2));
+        EXPECT_FALSE(c(3));
+
+        xt::xarray<bool> d = a | b;
+        EXPECT_TRUE(d(0));
+        EXPECT_TRUE(d(1));
+        EXPECT_TRUE(d(2));
+        EXPECT_FALSE(d(3));
+    }
 }
diff --git a/test/test_xarray_adaptor.cpp b/test/test_xarray_adaptor.cpp
index db591848f..5142386f8 100644
--- a/test/test_xarray_adaptor.cpp
+++ b/test/test_xarray_adaptor.cpp
@@ -1,13 +1,14 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+
 #include "test_common.hpp"
 
 namespace xt
@@ -17,16 +18,16 @@ namespace xt
 
     TEST(xarray_adaptor, shaped_constructor)
     {
+        SUBCASE("row_major constructor")
         {
-            SCOPED_TRACE("row_major constructor");
             row_major_result<> rm;
             vec_type v;
             adaptor_type a(v, rm.shape(), layout_type::row_major);
             compare_shape(a, rm);
         }
 
+        SUBCASE("column_major constructor")
         {
-            SCOPED_TRACE("column_major constructor");
             column_major_result<> cm;
             vec_type v;
             adaptor_type a(v, cm.shape(), layout_type::column_major);
@@ -49,15 +50,15 @@ namespace xt
         vec_type v(res.size(), value);
         adaptor_type a(v, res.shape(), res.strides());
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             adaptor_type b(a);
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("assignment operator")
         {
-            SCOPED_TRACE("assignment operator");
             row_major_result<> r;
             vec_type v2(r.size(), 0);
             adaptor_type c(v2, r.shape());
@@ -75,16 +76,16 @@ namespace xt
         vec_type v(res.size(), value);
         adaptor_type a(v, res.shape(), res.strides());
 
+        SUBCASE("move constructor")
         {
-            SCOPED_TRACE("move constructor");
             adaptor_type tmp(a);
             adaptor_type b(std::move(tmp));
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("move assignment")
         {
-            SCOPED_TRACE("move assignment");
             row_major_result<> r;
             vec_type v2(r.size(), 0);
             adaptor_type c(v2, r.shape());
@@ -110,12 +111,14 @@ namespace xt
         test_reshape(a);
     }
 
+#if !(defined(XTENSOR_ENABLE_ASSERT) && defined(XTENSOR_DISABLE_EXCEPTIONS))
     TEST(xarray_adaptor, access)
     {
         vec_type v;
         adaptor_type a(v);
         test_access(a);
     }
+#endif
 
     TEST(xarray_adaptor, unchecked)
     {
@@ -185,4 +188,16 @@ namespace xt
         ad = ad * 2;
         EXPECT_EQ(ad(1, 1), 10.);
     }
+
+    TEST(xarray_adaptor, iterator_types)
+    {
+        using vec_type = std::vector<int>;
+        using array_type = xarray_adaptor<vec_type>;
+        using const_array_type = xarray_adaptor<const vec_type>;
+        using iterator = vec_type::iterator;
+        using const_iterator = vec_type::const_iterator;
+
+        test_iterator_types<array_type, iterator, const_iterator>();
+        test_iterator_types<const_array_type, const_iterator, const_iterator>();
+    }
 }
diff --git a/test/test_xassign.cpp b/test/test_xassign.cpp
new file mode 100644
index 000000000..3535b4886
--- /dev/null
+++ b/test/test_xassign.cpp
@@ -0,0 +1,177 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <iterator>
+#include <type_traits>
+#include <vector>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xassign.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+
+#include "test_common.hpp"
+#include "test_common_macros.hpp"
+
+// a dummy shape *not derived* from std::vector but compatible
+template <class T>
+class my_vector
+{
+private:
+
+    using vector_type = std::vector<T>;
+
+public:
+
+    using value_type = T;
+    using size_type = typename vector_type::size_type;
+
+    template <class U>
+    my_vector(std::initializer_list<U> vals)
+        : m_data(vals.begin(), vals.end())
+    {
+    }
+
+    my_vector(const std::size_t size = 0, const T& val = T())
+        : m_data(size, val)
+    {
+    }
+
+    auto resize(const std::size_t size)
+    {
+        return m_data.resize(size);
+    }
+
+    auto size() const
+    {
+        return m_data.size();
+    }
+
+    auto cend() const
+    {
+        return m_data.cend();
+    }
+
+    auto cbegin() const
+    {
+        return m_data.cbegin();
+    }
+
+    auto end()
+    {
+        return m_data.end();
+    }
+
+    auto end() const
+    {
+        return m_data.end();
+    }
+
+    auto begin()
+    {
+        return m_data.begin();
+    }
+
+    auto begin() const
+    {
+        return m_data.begin();
+    }
+
+    auto rbegin() const
+    {
+        return std::make_reverse_iterator(end());
+    }
+
+    auto rend() const
+    {
+        return std::make_reverse_iterator(begin());
+    }
+
+    auto empty() const
+    {
+        return m_data.empty();
+    }
+
+    auto& back()
+    {
+        return m_data.back();
+    }
+
+    const auto& back() const
+    {
+        return m_data.back();
+    }
+
+    auto& front()
+    {
+        return m_data.front();
+    }
+
+    const auto& front() const
+    {
+        return m_data.front();
+    }
+
+    auto& operator[](const std::size_t i)
+    {
+        return m_data[i];
+    }
+
+    const auto& operator[](const std::size_t i) const
+    {
+        return m_data[i];
+    }
+
+private:
+
+    std::vector<T> m_data;
+};
+
+namespace xt
+{
+
+    template <class T, class C_T>
+    struct rebind_container<T, my_vector<C_T>>
+    {
+        using type = my_vector<T>;
+    };
+
+    TEST(xassign, mix_shape_types)
+    {
+        {
+            // xarray like with custom shape
+            using my_xarray = xt::xarray_container<std::vector<int>, xt::layout_type::row_major, my_vector<std::size_t>>;
+
+            auto a = my_xarray::from_shape({1, 3});
+            auto b = xt::xtensor<int, 2>::from_shape({2, 3});
+            xt::noalias(a) += b;
+            EXPECT_EQ(a.dimension(), 2);
+            EXPECT_EQ(a.shape(0), 2);
+            EXPECT_EQ(a.shape(1), 3);
+        }
+        {
+            // xarray like with custom shape
+            using my_xarray = xt::xarray_container<std::vector<int>, xt::layout_type::row_major, my_vector<std::size_t>>;
+
+            auto a = my_xarray::from_shape({3});
+            auto b = xt::xtensor<int, 2>::from_shape({2, 3});
+            xt::noalias(a) += b;
+            EXPECT_EQ(a.dimension(), 2);
+            EXPECT_EQ(a.shape(0), 2);
+            EXPECT_EQ(a.shape(1), 3);
+        }
+    }
+
+    TEST(xassign, fixed_dimension_mismatch)
+    {
+        auto a = xt::xtensor<float, 1>::from_shape({2});
+        XT_ASSERT_THROW(a = xt::expand_dims(a, 0), std::runtime_error);
+    }
+}
diff --git a/test/test_xaxis_iterator.cpp b/test/test_xaxis_iterator.cpp
index 3f066f8d6..0f52d2df7 100644
--- a/test/test_xaxis_iterator.cpp
+++ b/test/test_xaxis_iterator.cpp
@@ -1,14 +1,16 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xaxis_iterator.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/views/xaxis_iterator.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -16,12 +18,10 @@ namespace xt
 
     xarray<int> get_test_array()
     {
-        xarray<int> res = {{{1, 2, 3, 4},
-                            {5, 6, 7, 8},
-                            {9, 10, 11, 12}},
-                           {{13, 14, 15, 16},
-                            {17, 18, 19, 20},
-                            {21, 22, 23, 24}}};
+        xarray<int> res = {
+            {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}},
+            {{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}
+        };
         return res;
     }
 
@@ -56,10 +56,29 @@ namespace xt
     TEST(xaxis_iterator, end)
     {
         xarray<int> a = get_test_array();
+        auto iter_begin = axis_begin(a, 1u);
+        auto iter_end = axis_end(a, 1u);
+        auto dist = std::distance(iter_begin, iter_end);
+        EXPECT_EQ(3, dist);
+    }
+
+    TEST(xaxis_iterator, end_value)
+    {
+        xarray<int, layout_type::column_major> a = get_test_array();
         auto iter_begin = axis_begin(a);
         auto iter_end = axis_end(a);
-        auto dist = std::distance(iter_begin, iter_end);
-        EXPECT_EQ(2, dist);
+        ++iter_begin;
+        ++iter_begin;
+        EXPECT_EQ(iter_begin, iter_end);
+
+        xarray<int> b = get_test_array();
+        auto iter_begin_row = axis_begin(b, 2u);
+        auto iter_end_row = axis_end(b, 2u);
+        ++iter_begin_row;
+        ++iter_begin_row;
+        ++iter_begin_row;
+        ++iter_begin_row;
+        EXPECT_EQ(iter_begin_row, iter_end_row);
     }
 
     TEST(xaxis_iterator, nested)
@@ -91,4 +110,103 @@ namespace xt
         EXPECT_EQ(a(1, 1, 1), (*iter)(1, 1));
         EXPECT_EQ(a(1, 2, 3), (*iter)(2, 3));
     }
+
+    TEST(xaxis_iterator, axis_0)
+    {
+        xarray<int> a = get_test_array();
+        auto iter = axis_begin(a, 0);
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 0, 2), (*iter)(0, 2));
+        EXPECT_EQ(a(0, 0, 3), (*iter)(0, 3));
+        EXPECT_EQ(a(0, 1, 0), (*iter)(1, 0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(1, 1));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(1, 2));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(1, 3));
+        EXPECT_EQ(a(0, 2, 0), (*iter)(2, 0));
+        EXPECT_EQ(a(0, 2, 1), (*iter)(2, 1));
+        EXPECT_EQ(a(0, 2, 2), (*iter)(2, 2));
+        EXPECT_EQ(a(0, 2, 3), (*iter)(2, 3));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 0), (*iter)(0, 0));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(0, 1));
+        EXPECT_EQ(a(1, 0, 2), (*iter)(0, 2));
+        EXPECT_EQ(a(1, 0, 3), (*iter)(0, 3));
+        EXPECT_EQ(a(1, 1, 0), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(1, 2));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(1, 3));
+        EXPECT_EQ(a(1, 2, 0), (*iter)(2, 0));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(2, 1));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(2, 2));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(2, 3));
+    }
+
+    TEST(xaxis_iterator, axis_1)
+    {
+        xarray<int> a = get_test_array();
+        auto iter = axis_begin(a, 1u);
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 0, 2), (*iter)(0, 2));
+        EXPECT_EQ(a(0, 0, 3), (*iter)(0, 3));
+        EXPECT_EQ(a(1, 0, 0), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 0, 2), (*iter)(1, 2));
+        EXPECT_EQ(a(1, 0, 3), (*iter)(1, 3));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 0), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(0, 2));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(0, 3));
+        EXPECT_EQ(a(1, 1, 0), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(1, 2));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(1, 3));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 0), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 2, 1), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 2, 2), (*iter)(0, 2));
+        EXPECT_EQ(a(0, 2, 3), (*iter)(0, 3));
+        EXPECT_EQ(a(1, 2, 0), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(1, 2));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(1, 3));
+    }
+
+    TEST(xaxis_iterator, axis_2)
+    {
+        xarray<int> a = get_test_array();
+        auto iter = axis_begin(a, 2u);
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 1, 0), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 2, 0), (*iter)(0, 2));
+        EXPECT_EQ(a(1, 0, 0), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 1, 0), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 2, 0), (*iter)(1, 2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 2, 1), (*iter)(0, 2));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(1, 2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 2), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 2, 2), (*iter)(0, 2));
+        EXPECT_EQ(a(1, 0, 2), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(1, 2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 3), (*iter)(0, 0));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(0, 1));
+        EXPECT_EQ(a(0, 2, 3), (*iter)(0, 2));
+        EXPECT_EQ(a(1, 0, 3), (*iter)(1, 0));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(1, 1));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(1, 2));
+    }
 }
diff --git a/test/test_xaxis_slice_iterator.cpp b/test/test_xaxis_slice_iterator.cpp
new file mode 100644
index 000000000..fa0888e2d
--- /dev/null
+++ b/test/test_xaxis_slice_iterator.cpp
@@ -0,0 +1,321 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/views/xaxis_slice_iterator.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    using std::size_t;
+
+    xarray<int> get_slice_test_array()
+    {
+        xarray<int> res = {
+            {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}},
+            {{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}
+        };
+        return res;
+    }
+
+    TEST(xaxis_slice_iterator, begin)
+    {
+        xarray<int> a = get_slice_test_array();
+        auto iter_begin = axis_slice_begin(a, 0);
+        EXPECT_EQ(size_t(1), iter_begin->dimension());
+        EXPECT_EQ(a.shape()[0], iter_begin->shape()[0]);
+        EXPECT_EQ(a(0, 0, 0), (*iter_begin)(0));
+        EXPECT_EQ(a(1, 0, 0), (*iter_begin)(1));
+    }
+
+    TEST(xaxis_slice_iterator, end)
+    {
+        xarray<int> a = get_slice_test_array();
+        xarray<int, layout_type::column_major> a_col = get_slice_test_array();
+
+        auto dist = std::distance(axis_slice_begin(a, 0), axis_slice_end(a, 0));
+        EXPECT_EQ(12, dist);
+
+        dist = std::distance(axis_slice_begin(a_col), axis_slice_end(a_col));
+        EXPECT_EQ(12, dist);
+
+        dist = std::distance(axis_slice_begin(a, 1), axis_slice_end(a, 1));
+        EXPECT_EQ(8, dist);
+
+        dist = std::distance(axis_slice_begin(a_col, 1), axis_slice_end(a_col, 1));
+        EXPECT_EQ(8, dist);
+
+        dist = std::distance(axis_slice_begin(a, 2), axis_slice_end(a, 2));
+        EXPECT_EQ(6, dist);
+
+        dist = std::distance(axis_slice_begin(a_col, 2), axis_slice_end(a_col, 2));
+        EXPECT_EQ(6, dist);
+    }
+
+    TEST(xaxis_slice_iterator, increment)
+    {
+        xarray<int, layout_type::row_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, 0);
+        ++iter;
+
+        EXPECT_EQ(size_t(1), iter->dimension());
+        EXPECT_EQ(a.shape()[0], iter->shape()[0]);
+
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(1));
+    }
+
+    TEST(xaxis_slice_iterator, const_array)
+    {
+        const xarray<int, layout_type::row_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, 2);
+        ++iter;
+
+        EXPECT_EQ(size_t(1), iter->dimension());
+        EXPECT_EQ(a.shape()[2], iter->shape()[0]);
+
+        EXPECT_EQ(a(0, 1, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(2));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(3));
+    }
+
+    TEST(xaxis_slice_iterator, axis_0)
+    {
+        xarray<int, layout_type::row_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, size_t(0));
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 0), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 2), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 3), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 0), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 0), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(1));
+    }
+
+    TEST(xaxis_slice_iterator, axis_0_col)
+    {
+        xarray<int, layout_type::column_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, size_t(0));
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 0), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 0), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 0), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 2), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 3), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(1));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(1));
+    }
+
+    TEST(xaxis_slice_iterator, axis_1)
+    {
+        xarray<int, layout_type::row_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, size_t(1));
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 0), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 0), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 1), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 2), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 2), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 3), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 3), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 0), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 0), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(2));
+    }
+
+    TEST(xaxis_slice_iterator, axis_1_col)
+    {
+        xarray<int, layout_type::column_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, size_t(1));
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 0), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 0), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 0), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 0), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 1), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 1), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 1), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 2), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 2), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 2), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(0, 0, 3), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 3), (*iter)(2));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 3), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(2));
+    }
+
+    TEST(xaxis_slice_iterator, axis_2)
+    {
+        xarray<int, layout_type::row_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, size_t(2));
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 0, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 0, 2), (*iter)(2));
+        EXPECT_EQ(a(0, 0, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(2));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 2, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 2), (*iter)(2));
+        EXPECT_EQ(a(0, 2, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 0, 2), (*iter)(2));
+        EXPECT_EQ(a(1, 0, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(1, 1, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(2));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(1, 2, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(2));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(3));
+    }
+
+    TEST(xaxis_slice_iterator, axis_2_col)
+    {
+        xarray<int, layout_type::column_major> a = get_slice_test_array();
+        auto iter = axis_slice_begin(a, size_t(2));
+
+        EXPECT_EQ(a(0, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 0, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 0, 2), (*iter)(2));
+        EXPECT_EQ(a(0, 0, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(1, 0, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 0, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 0, 2), (*iter)(2));
+        EXPECT_EQ(a(1, 0, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(0, 1, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 1, 2), (*iter)(2));
+        EXPECT_EQ(a(0, 1, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(1, 1, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 1, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 1, 2), (*iter)(2));
+        EXPECT_EQ(a(1, 1, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(0, 2, 0), (*iter)(0));
+        EXPECT_EQ(a(0, 2, 1), (*iter)(1));
+        EXPECT_EQ(a(0, 2, 2), (*iter)(2));
+        EXPECT_EQ(a(0, 2, 3), (*iter)(3));
+        ++iter;
+        EXPECT_EQ(a(1, 2, 0), (*iter)(0));
+        EXPECT_EQ(a(1, 2, 1), (*iter)(1));
+        EXPECT_EQ(a(1, 2, 2), (*iter)(2));
+        EXPECT_EQ(a(1, 2, 3), (*iter)(3));
+    }
+}
diff --git a/test/test_xblockwise_reducer.cpp b/test/test_xblockwise_reducer.cpp
new file mode 100644
index 000000000..d888ec396
--- /dev/null
+++ b/test/test_xblockwise_reducer.cpp
@@ -0,0 +1,319 @@
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <typeinfo>
+#include <vector>
+
+#include "xtensor/io/xio.hpp"
+#include "xtensor/reducers/xblockwise_reducer.hpp"
+#include "xtensor/reducers/xnorm.hpp"
+
+#include "test_common.hpp"
+
+#define XTENSOR_REDUCER_TESTER(FNAME)                                           \
+    struct FNAME##_tester                                                       \
+    {                                                                           \
+        template <class T = void, class... ARGS>                                \
+        static auto op(ARGS&&... args)                                          \
+        {                                                                       \
+            return xt::blockwise::FNAME<T>(std::forward<ARGS>(args)...);        \
+        }                                                                       \
+        template <class T = void, class... ARGS>                                \
+        static auto should_op(ARGS&&... args)                                   \
+        {                                                                       \
+            return xt::FNAME<T>(std::forward<ARGS>(args)...);                   \
+        }                                                                       \
+    };                                                                          \
+    TYPE_TO_STRING(FNAME##_tester);                                             \
+    TYPE_TO_STRING(std::tuple<FNAME##_tester, std::tuple<xt::keep_dims_type>>); \
+    TYPE_TO_STRING(std::tuple<FNAME##_tester, std::tuple<xt::evaluation_strategy::immediate_type>>)
+
+XTENSOR_REDUCER_TESTER(sum);
+XTENSOR_REDUCER_TESTER(prod);
+XTENSOR_REDUCER_TESTER(amin);
+XTENSOR_REDUCER_TESTER(amax);
+XTENSOR_REDUCER_TESTER(mean);
+XTENSOR_REDUCER_TESTER(variance);
+XTENSOR_REDUCER_TESTER(stddev);
+
+#undef XTENSOR_REDUCER_TESTER
+
+#define XTENSOR_NORM_REDUCER_TESTER(FNAME)                                      \
+    struct FNAME##_tester                                                       \
+    {                                                                           \
+        template <class T = void, class... ARGS>                                \
+        static auto op(ARGS&&... args)                                          \
+        {                                                                       \
+            return xt::blockwise::FNAME(std::forward<ARGS>(args)...);           \
+        }                                                                       \
+        template <class T = void, class... ARGS>                                \
+        static auto should_op(ARGS&&... args)                                   \
+        {                                                                       \
+            return xt::FNAME(std::forward<ARGS>(args)...);                      \
+        }                                                                       \
+    };                                                                          \
+    TYPE_TO_STRING(FNAME##_tester);                                             \
+    TYPE_TO_STRING(std::tuple<FNAME##_tester, std::tuple<xt::keep_dims_type>>); \
+    TYPE_TO_STRING(std::tuple<FNAME##_tester, std::tuple<xt::evaluation_strategy::immediate_type>>)
+
+XTENSOR_NORM_REDUCER_TESTER(norm_l0);
+XTENSOR_NORM_REDUCER_TESTER(norm_l1);
+XTENSOR_NORM_REDUCER_TESTER(norm_l2);
+XTENSOR_NORM_REDUCER_TESTER(norm_sq);
+XTENSOR_NORM_REDUCER_TESTER(norm_linf);
+XTENSOR_NORM_REDUCER_TESTER(norm_lp_to_p);
+XTENSOR_NORM_REDUCER_TESTER(norm_lp);
+#undef XTENSOR_NORM_REDUCER_TESTER
+
+namespace xt
+{
+
+    using test_values_test_types = std::tuple<
+        std::tuple<sum_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<sum_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<prod_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<prod_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<amin_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<amin_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<amax_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<amax_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<mean_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<mean_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<variance_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<variance_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<stddev_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<stddev_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<norm_l0_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<norm_l0_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<norm_l1_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<norm_l1_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<norm_l2_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<norm_l2_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<norm_sq_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<norm_sq_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<norm_linf_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<norm_linf_tester, std::tuple<xt::evaluation_strategy::immediate_type>>>;
+
+    using test_p_norm_values_test_types = std::tuple<
+        std::tuple<norm_lp_to_p_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<norm_lp_to_p_tester, std::tuple<xt::evaluation_strategy::immediate_type>>,
+        std::tuple<norm_lp_tester, std::tuple<xt::keep_dims_type>>,
+        std::tuple<norm_lp_tester, std::tuple<xt::evaluation_strategy::immediate_type>>>;
+
+    TEST_SUITE("xblockwise_reducer")
+    {
+        TEST_CASE_TEMPLATE_DEFINE("test_values", TesterTuple, test_values_id)
+        {
+            using tester_type = std::tuple_element_t<0, TesterTuple>;
+            using options_type = std::tuple_element_t<1, TesterTuple>;
+
+            dynamic_shape<std::size_t> shape({21, 10, 5});
+            dynamic_shape<std::size_t> chunk_shape({5, 4, 2});
+            xarray<int> input_exp(shape);
+
+            if (std::is_same<tester_type, prod_tester>::value)
+            {
+                for (std::size_t i = 0; i < input_exp.size(); ++i)
+                {
+                    input_exp.flat(i) = (i % 2 == 0) ? 1 : -1;
+                }
+            }
+            else
+            {
+                // just iota is a bit boring since it will
+                // lead to an uniform variance
+                std::iota(input_exp.begin(), input_exp.end(), -5);
+                for (std::size_t i = 0; i < input_exp.size(); ++i)
+                {
+                    if (i % 2)
+                    {
+                        input_exp.flat(i) += 10;
+                    }
+                }
+            }
+
+            std::vector<dynamic_shape<std::size_t>> axes_vec = {
+                dynamic_shape<std::size_t>({0}),
+                dynamic_shape<std::size_t>({1}),
+                dynamic_shape<std::size_t>({2}),
+                dynamic_shape<std::size_t>({0, 1}),
+                dynamic_shape<std::size_t>({0, 2}),
+                dynamic_shape<std::size_t>({0, 1, 2})
+            };
+
+            for (const auto& axes : axes_vec)
+            {
+                SUBCASE((std::string("axes = ") + stringify(axes)).c_str())
+                {
+                    auto reducer = tester_type::op(input_exp, chunk_shape, axes, options_type{});
+                    auto should_reducer = tester_type::should_op(input_exp, axes, options_type{});
+
+                    using should_result_value_type = typename std::decay_t<decltype(should_reducer)>::value_type;
+                    using result_value_type = typename std::decay_t<decltype(reducer)>::value_type;
+
+                    SUBCASE("result_value_type")
+                    {
+                        CHECK_UNARY(std::is_same<result_value_type, should_result_value_type>::value);
+                    }
+
+                    SUBCASE("shape")
+                    {
+                        CHECK_EQ(reducer.dimension(), should_reducer.dimension());
+                        CHECK_EQ(reducer.shape(), should_reducer.shape());
+                    }
+
+                    SUBCASE("assign")
+                    {
+                        auto result = xarray<result_value_type>::from_shape(reducer.shape());
+                        reducer.assign_to(result);
+
+                        auto should_result = xt::eval(should_reducer);
+                        if (std::is_same<tester_type, variance_tester>::value
+                            || std::is_same<tester_type, stddev_tester>::value)
+                        {
+                            CHECK_UNARY(xt::allclose(result, should_result));
+                        }
+                        else
+                        {
+                            CHECK_EQ(result, should_result);
+                        }
+                    }
+                }
+            }
+        }
+        TEST_CASE_TEMPLATE_APPLY(test_values_id, test_values_test_types);
+
+
+        TEST_CASE_TEMPLATE_DEFINE("test_p_norm_values", TesterTuple, test_p_norm_values_id)
+        {
+            using tester_type = std::tuple_element_t<0, TesterTuple>;
+            using options_type = std::tuple_element_t<1, TesterTuple>;
+
+            dynamic_shape<std::size_t> shape({21, 10, 5});
+            dynamic_shape<std::size_t> chunk_shape({5, 4, 2});
+            xarray<int> input_exp(shape);
+
+            // just iota is a bit boring since it will
+            // lead to an uniform variance
+            std::iota(input_exp.begin(), input_exp.end(), -5);
+            for (std::size_t i = 0; i < input_exp.size(); ++i)
+            {
+                if (i % 2)
+                {
+                    input_exp.flat(i) += 10;
+                }
+            }
+
+            std::vector<dynamic_shape<std::size_t>> axes_vec = {
+                dynamic_shape<std::size_t>({0}),
+                dynamic_shape<std::size_t>({1}),
+                dynamic_shape<std::size_t>({2}),
+                dynamic_shape<std::size_t>({0, 1}),
+                dynamic_shape<std::size_t>({0, 2}),
+                dynamic_shape<std::size_t>({0, 1, 2})
+            };
+
+            for (const auto& axes : axes_vec)
+            {
+                SUBCASE((std::string("axes = ") + stringify(axes)).c_str())
+                {
+                    auto reducer = tester_type::op(input_exp, chunk_shape, 2.0, axes, options_type{});
+                    auto should_reducer = tester_type::should_op(input_exp, 2.0, axes, options_type{});
+                    auto should_result = xt::eval(should_reducer);
+
+                    using should_result_value_type = typename std::decay_t<decltype(should_reducer)>::value_type;
+                    using result_value_type = typename std::decay_t<decltype(reducer)>::value_type;
+
+                    SUBCASE("result_value_type")
+                    {
+                        CHECK_UNARY(std::is_same<result_value_type, should_result_value_type>::value);
+                    }
+
+
+                    SUBCASE("shape")
+                    {
+                        CHECK_EQ(reducer.dimension(), should_reducer.dimension());
+                        CHECK_EQ(reducer.shape(), should_reducer.shape());
+                    }
+
+                    SUBCASE("assign")
+                    {
+                        auto result = xarray<result_value_type>::from_shape(reducer.shape());
+                        reducer.assign_to(result);
+                        CHECK_UNARY(xt::allclose(result, should_result));
+                    }
+                }
+            }
+        }
+        TEST_CASE_TEMPLATE_APPLY(test_p_norm_values_id, test_p_norm_values_test_types);
+
+        TEST_CASE("test_api")
+        {
+            SUBCASE("sum")
+            {
+                dynamic_shape<std::size_t> shape({21, 10, 5});
+                dynamic_shape<std::size_t> chunk_shape({5, 4, 2});
+                xarray<int> input_exp(shape);
+
+                SUBCASE("integral_axis")
+                {
+                    xt::blockwise::sum(input_exp, chunk_shape, 1);
+                }
+                SUBCASE("initalizer_list_axis")
+                {
+                    xt::blockwise::sum(input_exp, chunk_shape, {1});
+                }
+                SUBCASE("array")
+                {
+                    const int axes[2] = {0, 1};
+                    xt::blockwise::sum(input_exp, chunk_shape, axes);
+                }
+                SUBCASE("no options")
+                {
+                    xt::blockwise::sum(input_exp, chunk_shape);
+                }
+                SUBCASE("templated")
+                {
+                    SUBCASE("integral_axis")
+                    {
+                        xt::blockwise::sum<double>(input_exp, chunk_shape, 1);
+                    }
+                    SUBCASE("initalizer_list_axis")
+                    {
+                        xt::blockwise::sum<double>(input_exp, chunk_shape, {1});
+                    }
+                    SUBCASE("array")
+                    {
+                        const int axes[2] = {0, 1};
+                        xt::blockwise::sum<double>(input_exp, chunk_shape, axes);
+                    }
+                    SUBCASE("no options")
+                    {
+                        xt::blockwise::sum<double>(input_exp, chunk_shape);
+                    }
+                }
+            }
+            SUBCASE("l2_norm")
+            {
+                dynamic_shape<std::size_t> shape({21, 10, 5});
+                dynamic_shape<std::size_t> chunk_shape({5, 4, 2});
+                xarray<int> input_exp(shape);
+
+                SUBCASE("integral_axis")
+                {
+                    xt::blockwise::norm_l2(input_exp, chunk_shape, 1);
+                }
+                SUBCASE("initalizer_list_axis")
+                {
+                    xt::blockwise::norm_l2(input_exp, chunk_shape, {1});
+                }
+                SUBCASE("array")
+                {
+                    const int axes[2] = {0, 1};
+                    xt::blockwise::norm_l2(input_exp, chunk_shape, axes);
+                }
+            }
+        }
+    }
+
+}
diff --git a/test/test_xbroadcast.cpp b/test/test_xbroadcast.cpp
index 7f8f5971c..fcc3fdbde 100644
--- a/test/test_xbroadcast.cpp
+++ b/test/test_xbroadcast.cpp
@@ -1,30 +1,31 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
-#include "xtensor/xbroadcast.hpp"
-#include "xtensor/xarray.hpp"
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/views/xbroadcast.hpp"
+
+#include "test_common.hpp"
 
 namespace xt
 {
     TEST(xbroadcast, broadcast)
     {
-        xarray<double> m1
-          {{1, 2, 3},
-           {4, 5, 6}};
+        xarray<double> m1{{1, 2, 3}, {4, 5, 6}};
 
         auto m1_broadcast = broadcast(m1, {1, 2, 3});
         ASSERT_EQ(1.0, m1_broadcast(0, 0, 0));
         ASSERT_EQ(4.0, m1_broadcast(0, 1, 0));
         ASSERT_EQ(5.0, m1_broadcast(0, 1, 1));
         ASSERT_EQ(m1_broadcast.layout(), m1.layout());
-        EXPECT_ANY_THROW(m1_broadcast.at(0, 0, 0, 0));
-        EXPECT_ANY_THROW(m1_broadcast.at(10, 10, 10));
+        XT_EXPECT_ANY_THROW(m1_broadcast.at(0, 0, 0, 0));
+        XT_EXPECT_ANY_THROW(m1_broadcast.at(10, 10, 10));
 
         auto shape = std::vector<std::size_t>{1, 2, 3};
         auto m1_broadcast2 = broadcast(m1, shape);
@@ -36,11 +37,21 @@ namespace xt
         ASSERT_EQ(5.0, m1_assigned(0, 1, 1));
     }
 
+    TEST(xbroadcast, fixed_shape)
+    {
+        xarray<double> m = {{1, 2, 3}, {4, 5, 6}};
+        auto m_br = broadcast(m, xt::fixed_shape<1, 2, 3>());
+        ASSERT_EQ(1.0, m_br(0, 0, 0));
+        ASSERT_EQ(4.0, m_br(0, 1, 0));
+        ASSERT_EQ(5.0, m_br(0, 1, 1));
+        ASSERT_EQ(m_br.layout(), m.layout());
+        XT_EXPECT_ANY_THROW(m_br.at(0, 0, 0, 0));
+        XT_EXPECT_ANY_THROW(m_br.at(10, 10, 10));
+    }
+
     TEST(xbroadcast, element)
     {
-        xarray<double> m1
-          {{1, 2, 3},
-           {4, 5, 6}};
+        xarray<double> m1{{1, 2, 3}, {4, 5, 6}};
 
         auto m1_broadcast = broadcast(m1, {4, 2, 3});
 
@@ -54,15 +65,13 @@ namespace xt
 
     TEST(xbroadcast, indexed_access)
     {
-        xarray<double> m1
-          {{ 1, 2, 3 },
-           { 4, 5, 6 }};
+        xarray<double> m1{{1, 2, 3}, {4, 5, 6}};
 
-        auto m1_broadcast = broadcast(m1, { 4, 2, 3 });
-        std::array<std::size_t, 3> index1 = { 0, 1, 1 };
+        auto m1_broadcast = broadcast(m1, {4, 2, 3});
+        std::array<std::size_t, 3> index1 = {0, 1, 1};
         ASSERT_EQ(5.0, m1_broadcast[index1]);
         ASSERT_EQ(5.0, (m1_broadcast[{0, 1, 1}]));
-        std::array<std::size_t, 4> index3 = { 4, 0, 1, 1 };
+        std::array<std::size_t, 4> index3 = {4, 0, 1, 1};
         ASSERT_EQ(5.0, m1_broadcast[index3]);
         ASSERT_EQ(5.0, (m1_broadcast[{4, 0, 1, 1}]));
     }
@@ -155,4 +164,23 @@ namespace xt
             EXPECT_EQ(iter, iter_end);
         }
     }
+
+    TEST(xbroadcast, same_shape)
+    {
+        xt::xarray<double, xt::layout_type::column_major> arr{{0.0, 1.0, 2.0}, {10.0, 11.0, 12.0}};
+
+        auto t = xt::broadcast(arr, {2, 3});
+
+        xt::xarray<double, xt::layout_type::column_major> cm_arr = t;
+        xt::xarray<double, xt::layout_type::row_major> rm_arr = t;
+
+        EXPECT_TRUE(xt::allclose(rm_arr, cm_arr));
+
+        EXPECT_EQ(cm_arr(0, 0), 0.0);
+        EXPECT_EQ(cm_arr(0, 1), 1.0);
+        EXPECT_EQ(cm_arr(0, 2), 2.0);
+        EXPECT_EQ(cm_arr(1, 0), 10.0);
+        EXPECT_EQ(cm_arr(1, 1), 11.0);
+        EXPECT_EQ(cm_arr(1, 2), 12.0);
+    }
 }
diff --git a/test/test_xbuffer_adaptor.cpp b/test/test_xbuffer_adaptor.cpp
index 6a8f4bfe7..5b0a5fcb6 100644
--- a/test/test_xbuffer_adaptor.cpp
+++ b/test/test_xbuffer_adaptor.cpp
@@ -1,13 +1,15 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
-#include "xtensor/xbuffer_adaptor.hpp"
+#include "xtensor/containers/xbuffer_adaptor.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -61,12 +63,49 @@ namespace xt
 
         size_t size2 = 200;
         double* data2 = allocator{}.allocate(size2);
-        data2[0] = 1.2;
+        double data2_ref = 1.2;
+        data2[0] = data2_ref;
         owner_adaptor adapt2(data2, size2);
 
         adapt1 = std::move(adapt2);
         EXPECT_EQ(adapt1.size(), size2);
-        EXPECT_EQ(adapt1[0], data2[0]);
+        EXPECT_EQ(adapt1[0], data2_ref);
+    }
+
+    class size_check_allocator : public std::allocator<size_t>
+    {
+    public:
+
+        size_t* allocate(size_t n)
+        {
+            size_t* res = std::allocator<size_t>::allocate(n);
+            // store the size into the result so we can
+            // check if the size is correct when we deallocate.
+            res[0] = n;
+            return res;
+        }
+
+        void deallocate(size_t* p, size_t n)
+        {
+            EXPECT_EQ(p[0], n);
+            return std::allocator<size_t>::deallocate(p, n);
+        }
+    };
+
+    TEST(xbuffer_adaptor, owner_move_assign_check_size)
+    {
+        size_check_allocator custom_allocator;
+        using owner_adaptor = xbuffer_adaptor<size_t*&, acquire_ownership, size_check_allocator>;
+        size_t size1 = 100;
+        size_t* data1 = custom_allocator.allocate(size1);
+        owner_adaptor adapt1(data1, size1);
+
+        size_t size2 = 200;
+        size_t* data2 = custom_allocator.allocate(size2);
+        owner_adaptor adapt2(data2, size2);
+
+        adapt1 = adapt2;
+        EXPECT_EQ(adapt1.size(), size2);
     }
 
     TEST(xbuffer_adaptor, owner_resize)
@@ -160,8 +199,10 @@ namespace xt
         buffer_adaptor adapt(data1, size1);
 
         size_t size2 = 50;
-        EXPECT_THROW(adapt.resize(size2), std::runtime_error);
+        XT_EXPECT_THROW(adapt.resize(size2), std::runtime_error);
         EXPECT_EQ(adapt.size(), size1);
+
+        delete[] data1;
     }
 
     TEST(xbuffer_adaptor, no_owner_iterating)
diff --git a/test/test_xbuilder.cpp b/test/test_xbuilder.cpp
index 1a5671336..d35847a8e 100644
--- a/test/test_xbuilder.cpp
+++ b/test/test_xbuilder.cpp
@@ -1,20 +1,26 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xfixed.hpp"
-
-#include "xtensor/xio.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#ifdef _MSC_VER
+#define VS_SKIP_CONCATENATE_FIXED 1
+#endif
+
 #include <sstream>
 
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/io/xio.hpp"
+
+#include "test_common.hpp"
+
 namespace xt
 {
     using std::size_t;
@@ -37,7 +43,7 @@ namespace xt
     TEST(xbuilder, like)
     {
         bool type_equal = false;
-        auto arr = xarray<int>::from_shape({3,2,5});
+        auto arr = xarray<int>::from_shape({3, 2, 5});
         auto xfx = xtensor_fixed<int, xt::xshape<3, 3, 3>>();
 
         auto onas = ones_like(arr);
@@ -91,6 +97,28 @@ namespace xt
         ASSERT_EQ(50, res(1, 49));
     }
 
+    TEST(xbuilder, arange_reshape)
+    {
+        auto rs0 = arange<double>(50).reshape({std::size_t(5), std::size_t(10)});
+        auto rs1 = arange<double>(50).reshape({-1, 10});
+
+        auto gen0 = arange<double>(50);
+        auto ls0 = gen0.reshape({std::size_t(5), std::size_t(10)});
+        auto gen1 = arange<double>(50);
+        auto ls1 = gen1.reshape({-1, 10});
+
+        decltype(ls0)::shape_type expected_shape = {5, 10};
+        EXPECT_EQ(rs0.shape(), expected_shape);
+        EXPECT_EQ(rs1.shape(), expected_shape);
+        EXPECT_EQ(ls0.shape(), expected_shape);
+        EXPECT_EQ(ls1.shape(), expected_shape);
+
+        EXPECT_EQ(rs0(4, 9), 49);
+        EXPECT_EQ(rs1(4, 9), 49);
+        EXPECT_EQ(ls0(4, 9), 49);
+        EXPECT_EQ(ls1(4, 9), 49);
+    }
+
     TEST(xbuilder, arange_min_max)
     {
         auto ls = arange<unsigned int>(10u, 20u);
@@ -106,6 +134,13 @@ namespace xt
         ASSERT_EQ(m_assigned[{0}], 10u);
         ASSERT_EQ(m_assigned[{9}], 19u);
         ASSERT_EQ(m_assigned[{2}], 12u);
+
+        auto lc = arange<char>('a', 'd');
+        decltype(lc)::shape_type expected_shape_2 = {3};
+        ASSERT_EQ(lc.shape(), expected_shape_2);
+        ASSERT_EQ(lc[{0}], 'a');
+        ASSERT_EQ(lc[{1}], 'b');
+        ASSERT_EQ(lc[{2}], 'c');
     }
 
     TEST(xbuilder, arange_min_max_step)
@@ -124,11 +159,45 @@ namespace xt
         ASSERT_EQ(m_assigned(10), 15.f);
         ASSERT_EQ(m_assigned(3), 11.5f);
 
-        auto l3 = arange<float>(0, 1, 0.3f);
+        auto l3 = arange<float>(0, 0.99f, 0.25f);
         decltype(l3)::shape_type expected_shape_2 = {4};
         ASSERT_EQ(l3.shape(), expected_shape_2);
         ASSERT_EQ(l3[{0}], 0.f);
-        ASSERT_EQ(3.f * 0.3f, l3[{3}]);
+        ASSERT_EQ(0.25f * 3.f, l3[{3}]);
+
+        auto l4 = arange<int>(0, 10, 3);
+        ASSERT_EQ(l4.shape(), expected_shape_2);
+        ASSERT_EQ(l4[{0}], 0);
+        ASSERT_EQ(l4[{1}], 3);
+        ASSERT_EQ(l4[{2}], 6);
+        ASSERT_EQ(l4[{3}], 9);
+    }
+
+    TEST(xbuilder, arange_reverse)
+    {
+        auto a0 = arange(6, 5, -1);
+        EXPECT_EQ(a0.dimension(), size_t(1));
+        decltype(a0)::shape_type expected_shape0 = {1};
+        EXPECT_EQ(a0.shape(), expected_shape0);
+        EXPECT_EQ(a0(0), 6);
+
+        auto a1 = arange(8, 5, -1);
+        EXPECT_EQ(a1.dimension(), size_t(1));
+        decltype(a1)::shape_type expected_shape1 = {3};
+        EXPECT_EQ(a1.shape(), expected_shape1);
+        EXPECT_EQ(a1(0), 8);
+        EXPECT_EQ(a1(1), 7);
+        EXPECT_EQ(a1(2), 6);
+
+        auto a2 = arange(5, 6, -1);
+        EXPECT_EQ(a2.dimension(), size_t(1));
+        decltype(a2)::shape_type expected_shape2 = {0};
+        EXPECT_EQ(a2.shape(), expected_shape2);
+
+        auto a3 = arange(8, 5, 1);
+        EXPECT_EQ(a3.dimension(), size_t(1));
+        decltype(a3)::shape_type expected_shape3 = {0};
+        EXPECT_EQ(a3.shape(), expected_shape3);
     }
 
     TEST(xbuilder, linspace)
@@ -151,6 +220,38 @@ namespace xt
         ASSERT_EQ(m_assigned(3), at_3);
     }
 
+    TEST(xbuilder, linspace_reshape)
+    {
+        xarray<double> a = linspace<double>(20., 50.).reshape({5, 10});
+        EXPECT_EQ(a.dimension(), size_t(2));
+        decltype(a)::shape_type expected_shape = {5, 10};
+        EXPECT_EQ(a.shape(), expected_shape);
+        EXPECT_EQ(a(0, 0), 20.);
+        EXPECT_EQ(a(4, 9), 50.);
+    }
+
+    TEST(xbuilder, linspace_1_point)
+    {
+        xt::xarray<double> a = linspace<double>(0., 0., 1, false);
+        decltype(a)::shape_type expected_shape = {1};
+        EXPECT_EQ(a.dimension(), size_t(1));
+        EXPECT_EQ(a.shape(), expected_shape);
+        EXPECT_EQ(0., a(0));
+
+        xt::xarray<double> b = linspace<double>(0., 0., 1, true);
+        EXPECT_EQ(b.dimension(), size_t(1));
+        EXPECT_EQ(b.shape(), expected_shape);
+        EXPECT_EQ(0., b(0));
+
+        xt::xarray<double> c = linspace<double>(0., 2., 1, true);
+        EXPECT_EQ(c.dimension(), size_t(1));
+        EXPECT_EQ(c.shape(), expected_shape);
+        EXPECT_EQ(0., c(0));
+
+        auto d = linspace<double>(0., 2., 1, true);
+        EXPECT_EQ(c, d);
+    }
+
     TEST(xbuilder, linspace_n_samples_endpoint)
     {
         auto ls = linspace<float>(20.f, 50.f, 100, false);
@@ -173,6 +274,13 @@ namespace xt
         ASSERT_EQ(m_assigned(3), at_3);
     }
 
+    TEST(xbuilder, linspace_endpoint)
+    {
+        double at_end = 99.78730976641236;
+        xt::xtensor<double, 1> ls = linspace<double>(0., at_end, 100);
+        ASSERT_EQ(ls(99), at_end);
+    }
+
     TEST(xbuilder, linspace_integer)
     {
         xarray<int> ls = linspace<int>(0, 10, 13);
@@ -181,6 +289,15 @@ namespace xt
         ASSERT_TRUE(all(equal(ls, expected)));
     }
 
+    TEST(xbuilder, linspace_double)
+    {
+        // access_imp will also be tested here
+        double at_end = 99.78730976641236;
+        xt::xarray<double> a = xt::linspace(0., at_end, 100);
+        auto b = xt::linspace(0., at_end, 100);
+        EXPECT_TENSOR_EQ(a, b);
+    }
+
     TEST(xbuilder, logspace)
     {
         auto ls = logspace<double>(2., 3., 4);
@@ -221,6 +338,10 @@ namespace xt
 
         ASSERT_TRUE(e[idx2]);
         ASSERT_TRUE((e[{2, 2}]));
+
+        auto e2 = eye(5, -1);
+        EXPECT_TRUE(e2(1, 0));
+        EXPECT_FALSE(e2(0, 0));
     }
 
     TEST(xbuilder, concatenate)
@@ -250,11 +371,79 @@ namespace xt
 
         auto t = concatenate(xtuple(arange(2), arange(2, 5), arange(5, 8)));
         ASSERT_TRUE(arange(8) == t);
+
+        xt::xarray<double> fa = xt::ones<double>({3, 4, 5, 0});
+        xt::xarray<double> sa = xt::ones<double>({3, 4, 5});
+        xt::xarray<double> ta = xt::ones<double>({3, 4, 5, 3});
+
+        XT_EXPECT_ANY_THROW(xt::concatenate(xt::xtuple(fa, sa)));
+        XT_EXPECT_ANY_THROW(xt::concatenate(xt::xtuple(fa, ta)));
     }
 
+    template <std::size_t... I, std::size_t... J>
+    bool operator==(fixed_shape<I...>, fixed_shape<J...>)
+    {
+        std::array<std::size_t, sizeof...(I)> ix = {I...};
+        std::array<std::size_t, sizeof...(J)> jx = {J...};
+        return sizeof...(J) == sizeof...(I) && std::equal(ix.begin(), ix.end(), jx.begin());
+    }
+
+#ifndef VS_SKIP_CONCATENATE_FIXED
+    // This test mimics the relevant parts of `TEST(xbuilder, concatenate)`
+    TEST(xbuilder, concatenate_fixed)
+    {
+        xtensor_fixed<double, fixed_shape<2, 2, 3>> a = {{{0, 1, 2}, {3, 4, 5}}, {{6, 7, 8}, {9, 10, 11}}};
+
+        auto c = concatenate<2>(xtuple(a, a, a));
+
+        using expected_shape_c_t = fixed_shape<2, 2, 9>;
+        ASSERT_EQ(expected_shape_c_t{}, c.shape());
+        ASSERT_EQ(c(1, 1, 2), c(1, 1, 5));
+        ASSERT_EQ(11, c(1, 1, 2));
+        ASSERT_EQ(11, c(1, 1, 5));
+
+        xtensor_fixed<double, fixed_shape<1, 3>> e = {{1, 2, 3}}, f = {{2, 3, 4}};
+        auto k = concatenate<0>(xtuple(e, f));
+        auto l = concatenate<1>(xtuple(e, f));
+
+        using expected_shape_k_t = fixed_shape<2, 3>;
+        using expected_shape_l_t = fixed_shape<1, 6>;
+        ASSERT_EQ(expected_shape_k_t{}, k.shape());
+        ASSERT_EQ(expected_shape_l_t{}, l.shape());
+        ASSERT_EQ(4, k(1, 2));
+        ASSERT_EQ(3, l(0, 2));
+        ASSERT_EQ(3, l(0, 4));
+
+        xtensor_fixed<double, fixed_shape<2>> x = arange(2);
+        xtensor_fixed<double, fixed_shape<3>> y = arange(2, 5);
+        xtensor_fixed<double, fixed_shape<3>> z = arange(5, 8);
+
+        auto w1 = concatenate<0>(xtuple(x, y, z));
+        auto w2 = concatenate(xtuple(x, y, z), 0);
+
+        ASSERT_TRUE(arange(8) == w1);
+        ASSERT_TRUE(w1 == w2);
+    }
+
+    TEST(xbuilder, vstack_fixed)
+    {
+        xtensor_fixed<float, fixed_shape<1, 2>> a = {{1.f, 2.f}};
+        xtensor_fixed<float, fixed_shape<2, 2>> b = {{3.f, 4.f}, {5.f, 6.f}};
+
+        auto c = vstack(xtuple(a, b));
+
+        using expected_shape_t = fixed_shape<3, 2>;
+        ASSERT_EQ(expected_shape_t{}, c.shape());
+        EXPECT_EQ(1.f, c(0, 0));
+        EXPECT_EQ(2.f, c(0, 1));
+        EXPECT_EQ(3.f, c(1, 0));
+        EXPECT_EQ(6.f, c(2, 1));
+    }
+#endif
+
     TEST(xbuilder, access)
     {
-        xarray<double> a = { { { 0, 1, 2 },{ 3, 4, 5 } },{ { 6, 7, 8 },{ 9, 10, 11 } } };
+        xarray<double> a = {{{0, 1, 2}, {3, 4, 5}}, {{6, 7, 8}, {9, 10, 11}}};
         auto c = concatenate(xtuple(a, a, a), 2);
         EXPECT_EQ(c(2, 3, 1, 1, 2), c(1, 1, 2));
     }
@@ -279,7 +468,7 @@ namespace xt
         ASSERT_EQ(11, c(1, 1, 1, 2));
         ASSERT_EQ(11, c(1, 1, 2, 2));
 
-        auto e = arange(1, 4);
+        xarray<double> e = arange(1, 4);
         xarray<double> f = {2, 3, 4};
         xarray<double> k = stack(xtuple(e, f));
         xarray<double> l = stack(xtuple(e, f), 1);
@@ -297,6 +486,52 @@ namespace xt
         ASSERT_TRUE(t == ar);
     }
 
+    TEST(xbuilder, hstack)
+    {
+        xarray<int> a0 = {1, 2, 3};
+        xarray<int> b0 = {2, 3, 4};
+        xarray<int> e0 = {1, 2, 3, 2, 3, 4};
+        auto c0 = hstack(xtuple(a0, b0));
+        EXPECT_EQ(c0, e0);
+
+        xarray<int> a1 = a0;
+        a1.reshape({3, 1});
+        xarray<int> b1 = b0;
+        b1.reshape({3, 1});
+        xarray<int> e1 = {{1, 2}, {2, 3}, {3, 4}};
+        auto c1 = hstack(xtuple(a1, b1));
+        EXPECT_EQ(c1, e1);
+
+        xarray<int> a2 = {{1, 2, 3}, {4, 5, 6}};
+        xarray<int> b2 = {{7, 8}, {9, 10}};
+        xarray<int> e2 = {{1, 2, 3, 7, 8}, {4, 5, 6, 9, 10}};
+        auto c2 = hstack(xtuple(a2, b2));
+    }
+
+    TEST(xbuilder, vstack)
+    {
+        xarray<int> a0 = {1, 2, 3};
+        xarray<int> b0 = {2, 3, 4};
+        xarray<int> e0 = {{1, 2, 3}, {2, 3, 4}};
+        auto c0 = vstack(xtuple(a0, b0));
+        EXPECT_EQ(c0, e0);
+
+        xarray<int> a1 = a0;
+        a1.reshape({3, 1});
+        xarray<int> b1 = b0;
+        b1.reshape({3, 1});
+        xarray<int> e1 = {1, 2, 3, 2, 3, 4};
+        e1.reshape({6, 1});
+        auto c1 = vstack(xtuple(a1, b1));
+        EXPECT_EQ(c1, e1);
+
+        xarray<int> a2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+        xarray<int> b2 = {{10, 11, 12}};
+        xarray<int> e2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
+        auto c2 = vstack(xtuple(a2, b2));
+        EXPECT_EQ(c2, e2);
+    }
+
     TEST(xbuilder, meshgrid)
     {
         auto mesh = meshgrid(linspace<double>(0.0, 1.0, 3), linspace<double>(0.0, 1.0, 2));
@@ -320,17 +555,11 @@ namespace xt
         xarray<double> e = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
         xarray<double> t = xt::triu(e);
 
-        xarray<double> expected = {{1, 2, 3},
-                                   {0, 5, 6},
-                                   {0, 0, 9}};
+        xarray<double> expected = {{1, 2, 3}, {0, 5, 6}, {0, 0, 9}};
 
-        xarray<double> expected_2 = {{1, 2, 3},
-                                     {4, 5, 6},
-                                     {0, 8, 9}};
+        xarray<double> expected_2 = {{1, 2, 3}, {4, 5, 6}, {0, 8, 9}};
 
-        xarray<double> expected_3 = {{0, 2, 3},
-                                     {0, 0, 6},
-                                     {0, 0, 0}};
+        xarray<double> expected_3 = {{0, 2, 3}, {0, 0, 6}, {0, 0, 0}};
 
         ASSERT_EQ(size_t(2), t.dimension());
         shape_t expected_shape = {3, 3};
@@ -350,17 +579,11 @@ namespace xt
         xarray<double> e = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
         xarray<double> t = xt::tril(e);
 
-        xarray<double> expected = {{1, 0, 0},
-                                   {4, 5, 0},
-                                   {7, 8, 9}};
+        xarray<double> expected = {{1, 0, 0}, {4, 5, 0}, {7, 8, 9}};
 
-        xarray<double> expected_2 = {{1, 2, 0},
-                                     {4, 5, 6},
-                                     {7, 8, 9}};
+        xarray<double> expected_2 = {{1, 2, 0}, {4, 5, 6}, {7, 8, 9}};
 
-        xarray<double> expected_3 = {{0, 0, 0},
-                                     {4, 0, 0},
-                                     {7, 8, 0}};
+        xarray<double> expected_3 = {{0, 0, 0}, {4, 0, 0}, {7, 8, 0}};
 
         ASSERT_EQ(size_t(2), t.dimension());
         shape_t expected_shape = {3, 3};
@@ -398,19 +621,14 @@ namespace xt
 
     TEST(xbuilder, diagonal_advanced)
     {
-        xarray<double> e = {{{{0, 1, 2}, {3, 4, 5}},
-                             {{6, 7, 8}, {9, 10, 11}}},
-                            {{{12, 13, 14}, {15, 16, 17}},
-                             {{18, 19, 20}, {21, 22, 23}}}};
+        xarray<double> e = {
+            {{{0, 1, 2}, {3, 4, 5}}, {{6, 7, 8}, {9, 10, 11}}},
+            {{{12, 13, 14}, {15, 16, 17}}, {{18, 19, 20}, {21, 22, 23}}}
+        };
 
         xarray<double> d1 = xt::diagonal(e);
 
-        xarray<double> expected = {{{0, 18},
-                                    {1, 19},
-                                    {2, 20}},
-                                   {{3, 21},
-                                    {4, 22},
-                                    {5, 23}}};
+        xarray<double> expected = {{{0, 18}, {1, 19}, {2, 20}}, {{3, 21}, {4, 22}, {5, 23}}};
         ASSERT_EQ(expected, d1);
 
         std::vector<double> d2 = {6, 7, 8, 9, 10, 11};
@@ -441,23 +659,22 @@ namespace xt
     TEST(xbuilder, arange_broadcast)
     {
         auto a = arange<int>(1);
-        xarray<int> b = { 1, 2, 3 };
+        xarray<int> b = {1, 2, 3};
         xarray<int> res = a + b;
         EXPECT_EQ(res, b);
     }
 
     TEST(xbuilder, empty)
     {
-
         bool b = false;
-    #ifndef X_OLD_CLANG
+
         auto e1 = empty<double>({3, 4, 1});
         b = std::is_same<decltype(e1), xtensor<double, 3>>::value;
         EXPECT_TRUE(b);
-        b = std::is_same<decltype(empty<int, layout_type::column_major>({3,3,3})),
-                         xtensor<int, 3, layout_type::column_major>>::value;
+        b = std::is_same<
+            decltype(empty<int, layout_type::column_major>({3, 3, 3})),
+            xtensor<int, 3, layout_type::column_major>>::value;
         EXPECT_TRUE(b);
-    #endif
 
         auto es = empty<double>(std::array<std::size_t, 3>{3, 4, 1});
         b = std::is_same<decltype(es), xtensor<double, 3>>::value;
@@ -474,7 +691,13 @@ namespace xt
 
         xt::dynamic_shape<std::size_t> sd = {3, 2, 1};
         auto ed1 = empty<double>(sd);
-        auto ed2 = empty<double, layout_type::column_major>(dynamic_shape<std::size_t>({3, 3, 3}));
+// TODO : The ed2 expression do not work on MSVC due to bad deduction since cpp20. We need to fix it for MSVC.
+#if defined(_MSVC_LANG)
+        using ShapeType = xt::dynamic_shape<std::size_t>;
+        auto ed2 = empty<double, xt::layout_type::column_major, ShapeType>(ShapeType({3, 3, 3}));
+#else
+        auto ed2 = empty<double, xt::layout_type::column_major>(xt::dynamic_shape<std::size_t>({3, 3, 3}));
+#endif
         auto ed3 = empty<double>(std::vector<std::size_t>({3, 3, 3}));
         b = std::is_same<decltype(ed1), xarray<double>>::value;
         EXPECT_TRUE(b);
diff --git a/test/test_xchunked_array.cpp b/test/test_xchunked_array.cpp
new file mode 100644
index 000000000..8be647c8e
--- /dev/null
+++ b/test/test_xchunked_array.cpp
@@ -0,0 +1,170 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/chunk/xchunked_array.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/io/xcsv.hpp"
+#include "xtensor/views/xbroadcast.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    using in_memory_chunked_array = xchunked_array<xarray<xarray<double>>>;
+
+    TEST(xchunked_array, indexed_access)
+    {
+        auto a = chunked_array<double>({10, 10, 10}, {2, 3, 4});
+
+        std::vector<size_t> idx = {3, 9, 8};
+        double val;
+
+        val = 1.;
+        a[idx] = val;
+        ASSERT_EQ(a[idx], val);
+        ASSERT_EQ(a(3, 9, 8), val);
+
+        val = 2.;
+        a(3, 9, 8) = val;
+        ASSERT_EQ(a(3, 9, 8), val);
+        ASSERT_EQ(a[idx], val);
+
+        val = 3.;
+        for (auto& it : a)
+        {
+            it = val;
+        }
+        for (auto it : a)
+        {
+            ASSERT_EQ(it, val);
+        }
+    }
+
+    TEST(xchunked_array, assign_expression)
+    {
+        std::vector<size_t> shape1 = {2, 2, 2};
+        std::vector<size_t> chunk_shape1 = {2, 3, 4};
+        auto a1 = chunked_array<double>(shape1, chunk_shape1);
+        double val;
+
+        val = 3.;
+        a1 = broadcast(val, a1.shape());
+        for (const auto& v : a1)
+        {
+            EXPECT_EQ(v, val);
+        }
+
+        std::vector<size_t> shape2 = {32, 10, 10};
+        auto a2 = chunked_array<double>(shape2, chunk_shape1);
+
+        a2 = broadcast(val, a2.shape());
+        for (const auto& v : a2)
+        {
+            EXPECT_EQ(v, val);
+        }
+
+        a2 += a2;
+        for (const auto& v : a2)
+        {
+            EXPECT_EQ(v, 2. * val);
+        }
+
+        a2 += 2.;
+        for (const auto& v : a2)
+        {
+            EXPECT_EQ(v, 2. * val + 2.);
+        }
+
+        xarray<double> a3{{1., 2., 3.}, {4., 5., 6.}, {7., 8., 9.}};
+
+        EXPECT_EQ(is_chunked(a3), false);
+
+        std::vector<size_t> chunk_shape4 = {2, 2};
+        auto a4 = chunked_array(a3, chunk_shape4);
+
+        EXPECT_EQ(is_chunked(a4), true);
+
+        double i = 1.;
+        for (const auto& v : a4)
+        {
+            EXPECT_EQ(v, i);
+            i += 1.;
+        }
+
+        auto a5 = in_memory_chunked_array(a4);
+        EXPECT_EQ(is_chunked(a5), true);
+        for (const auto& v : a5.chunk_shape())
+        {
+            EXPECT_EQ(v, 2);
+        }
+
+        auto a6 = chunked_array(a3);
+        EXPECT_EQ(is_chunked(a6), true);
+        for (const auto& v : a6.chunk_shape())
+        {
+            EXPECT_EQ(v, 3);
+        }
+
+        std::vector<size_t> shape3 = {3, 3};
+        std::vector<size_t> chunk_shape3 = {1, 2};
+        auto a7 = chunked_array<double>(shape3, chunk_shape3);
+        for (auto it = a7.chunks().begin(); it != a7.chunks().end(); ++it)
+        {
+            it->resize(chunk_shape3);
+        }
+
+        a7 = a3;
+        for (auto it = a7.chunks().begin(); it != a7.chunks().end(); ++it)
+        {
+            EXPECT_EQ(it->shape(), chunk_shape3);
+        }
+    }
+
+    TEST(xchunked_array, noalias)
+    {
+        std::vector<std::size_t> shape = {10, 10, 10};
+        std::vector<std::size_t> chunk_shape = {2, 2, 2};
+        auto a = chunked_array<double>(shape, chunk_shape);
+        xt::xarray<double> b = arange(1000).reshape({10, 10, 10});
+
+        noalias(a) = b;
+
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xchunked_array, chunk_iterator)
+    {
+        std::vector<std::size_t> shape = {10, 10, 10};
+        std::vector<std::size_t> chunk_shape = {2, 2, 2};
+        auto a = chunked_array<double>(shape, chunk_shape);
+        xt::xarray<double> b = arange(1000).reshape({10, 10, 10});
+        noalias(a) = b;
+
+        auto it = a.chunk_begin();
+        auto cit = a.chunk_cbegin();
+
+        for (size_t i = 0; i < 5; ++i)
+        {
+            for (size_t j = 0; j < 5; ++j)
+            {
+                for (size_t k = 0; k < 5; ++k)
+                {
+                    EXPECT_EQ(*((*it).begin()), a(2 * i, 2 * j, 2 * k));
+                    EXPECT_EQ(*((*cit).cbegin()), a(2 * i, 2 * j, 2 * k));
+                    ++it;
+                    ++cit;
+                }
+            }
+        }
+
+        it = a.chunk_begin();
+        std::advance(it, 2);
+        EXPECT_EQ(*((*it).begin()), a(0, 0, 4));
+    }
+}
diff --git a/test/test_xchunked_view.cpp b/test/test_xchunked_view.cpp
new file mode 100644
index 000000000..a16b8b401
--- /dev/null
+++ b/test/test_xchunked_view.cpp
@@ -0,0 +1,63 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/chunk/xchunked_array.hpp"
+#include "xtensor/chunk/xchunked_view.hpp"
+#include "xtensor/containers/xarray.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    TEST(xchunked_view, iterate)
+    {
+        std::vector<std::size_t> shape = {3, 4};
+        std::vector<std::size_t> chunk_shape = {1, 2};
+        xarray<double> a(shape);
+        std::size_t chunk_nb = 0;
+        auto chunked_view = xchunked_view<xarray<double>>(a, chunk_shape);
+        for (auto it = chunked_view.chunk_begin(); it != chunked_view.chunk_end(); it++)
+        {
+            chunk_nb++;
+        }
+
+        std::size_t expected_chunk_nb = (shape[0] / chunk_shape[0]) * (shape[1] / chunk_shape[1]);
+
+        EXPECT_EQ(chunk_nb, expected_chunk_nb);
+    }
+
+    TEST(xchunked_view, assign)
+    {
+        std::vector<std::size_t> shape = {3, 4};
+        std::vector<std::size_t> chunk_shape = {1, 2};
+        xarray<double> a(shape);
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        std::copy(data.cbegin(), data.cend(), a.begin());
+        xarray<double> b(shape);
+
+        as_chunked(b, chunk_shape) = a;
+
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xchunked_view, assign_chunked_array)
+    {
+        std::vector<std::size_t> shape = {10, 10, 10};
+        std::vector<std::size_t> chunk_shape = {2, 3, 4};
+        auto a = chunked_array<double>(shape, chunk_shape);
+        xarray<double> b(shape);
+        auto ref = arange(0, 1000).reshape(shape);
+
+        as_chunked(a, chunk_shape) = ref;
+        as_chunked(b, chunk_shape) = a;
+
+        EXPECT_EQ(ref, a);
+        EXPECT_EQ(ref, b);
+    }
+}
diff --git a/test/test_xcomplex.cpp b/test/test_xcomplex.cpp
index 766a9361e..920d21b8e 100644
--- a/test/test_xcomplex.cpp
+++ b/test/test_xcomplex.cpp
@@ -1,18 +1,24 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
 
 #include <complex>
-#include "xtensor/xarray.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xcomplex.hpp"
-#include "xtensor/xio.hpp"
+
+#include <xtl/xcomplex.hpp>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xcomplex.hpp"
+#include "xtensor/reducers/xnorm.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -20,9 +26,7 @@ namespace xt
 
     TEST(xcomplex, expression)
     {
-        xarray<std::complex<double>> e =
-            {{1.0       , 1.0 + 1.0i},
-             {1.0 - 1.0i, 1.0       }};
+        xarray<std::complex<double>> e = {{1.0, 1.0 + 1.0i}, {1.0 - 1.0i, 1.0}};
 
         // Test real expression
         auto r = real(e);
@@ -48,15 +52,11 @@ namespace xt
 
     TEST(xcomplex, lvalue)
     {
-        xarray<std::complex<double>> e =
-            {{1.0       , 1.0 + 1.0i},
-             {1.0 - 1.0i, 1.0       }};
+        xarray<std::complex<double>> e = {{1.0, 1.0 + 1.0i}, {1.0 - 1.0i, 1.0}};
 
         // Test assigning an expression to the complex view
         real(e) = zeros<double>({2, 2});
-        xarray<std::complex<double>> expect1 =
-            {{0.0       , 0.0 + 1.0i},
-             {0.0 - 1.0i, 0.0       }};
+        xarray<std::complex<double>> expect1 = {{0.0, 0.0 + 1.0i}, {0.0 - 1.0i, 0.0}};
         EXPECT_TRUE(all(equal(e, expect1)));
 
         imag(e) = zeros<double>({2, 2});
@@ -65,15 +65,11 @@ namespace xt
 
     TEST(xcomplex, scalar_assignmnent)
     {
-        xarray<std::complex<double>> e =
-            {{1.0       , 1.0 + 1.0i},
-             {1.0 - 1.0i, 1.0       }};
+        xarray<std::complex<double>> e = {{1.0, 1.0 + 1.0i}, {1.0 - 1.0i, 1.0}};
 
         // Test assigning an expression to the complex view
         real(e) = 0.0;
-        xarray<std::complex<double>> expect1 =
-            {{0.0       , 0.0 + 1.0i},
-             {0.0 - 1.0i, 0.0       }};
+        xarray<std::complex<double>> expect1 = {{0.0, 0.0 + 1.0i}, {0.0 - 1.0i, 0.0}};
         EXPECT_TRUE(all(equal(e, expect1)));
     }
 
@@ -97,45 +93,58 @@ namespace xt
 
     TEST(xcomplex, pointer)
     {
-        xarray<std::complex<double>> e =
-            {{1.0       , 1.0 + 1.0i},
-             {1.0 - 1.0i, 1.0       }};
+        xarray<std::complex<double>> e = {{1.0, 1.0 + 1.0i}, {1.0 - 1.0i, 1.0}};
         auto r = real(e);
         auto it = r.begin();
         EXPECT_EQ(*(it.operator->()), 1.0);
     }
 
+    TEST(xcomplex, arg)
+    {
+        xarray<std::complex<double>> cmplarg_0 = {
+            {0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
+            {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
+            {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}
+        };
+        xarray<double> res = xt::arg(cmplarg_0);
+    }
+
     TEST(xcomplex, abs_angle_conj)
     {
-        xarray<std::complex<double>> cmplarg_0 = {{0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
-                                                  {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
-                                                  {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}};
+        xarray<std::complex<double>> cmplarg_0 = {
+            {0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
+            {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
+            {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}
+        };
         auto cmplres = xt::abs(cmplarg_0);
-        xarray<double> cmplexpected = {{0.81745298, 0.75933774, 0.44016704},
-                                       {0.54959488, 1.01524554, 0.69331814},
-                                       {0.75711643, 0.78897806, 0.38306348}};
+        xarray<double> cmplexpected = {
+            {0.81745298, 0.75933774, 0.44016704},
+            {0.54959488, 1.01524554, 0.69331814},
+            {0.75711643, 0.78897806, 0.38306348}
+        };
 
         EXPECT_TRUE(allclose(cmplexpected, cmplres));
 
         auto cmplres_angle = xt::angle(cmplarg_0);
-        xarray<double> cmplexpected_angle = {{1.05805307, 0.59857922, 0.74302273},
-                                             {1.10923689, 0.81712241, 0.54213553},
-                                             {0.58362348, 0.97881125, 1.35044673}};
+        xarray<double> cmplexpected_angle = {
+            {1.05805307, 0.59857922, 0.74302273},
+            {1.10923689, 0.81712241, 0.54213553},
+            {0.58362348, 0.97881125, 1.35044673}
+        };
         EXPECT_TRUE(allclose(cmplexpected_angle, cmplres_angle));
 
         using assign_t_angle = xassign_traits<xarray<double>, decltype(cmplres_angle)>;
 
 #if XTENSOR_USE_XSIMD
-        EXPECT_TRUE(assign_t_angle::convertible_types());
-        EXPECT_TRUE(assign_t_angle::simd_size());
-        EXPECT_FALSE(assign_t_angle::forbid_simd());
-        EXPECT_TRUE(assign_t_angle::simd_assign());
+        EXPECT_TRUE(assign_t_angle::simd_linear_assign());
 #endif
 
         auto cmplres_conj = xt::conj(cmplarg_0);
-        xarray<std::complex<double>> cmplexpected_conj = {{0.40101756 - 0.71233018i, 0.62731701 - 0.42786349i, 0.32415089 - 0.2977805i},
-                                                          {0.24475928 - 0.49208478i, 0.69475518 - 0.74029639i, 0.59390240 - 0.35772892i},
-                                                          {0.63179202 - 0.41720995i, 0.44025718 - 0.65472131i, 0.08372648 - 0.37380143i}};
+        xarray<std::complex<double>> cmplexpected_conj = {
+            {0.40101756 - 0.71233018i, 0.62731701 - 0.42786349i, 0.32415089 - 0.2977805i},
+            {0.24475928 - 0.49208478i, 0.69475518 - 0.74029639i, 0.59390240 - 0.35772892i},
+            {0.63179202 - 0.41720995i, 0.44025718 - 0.65472131i, 0.08372648 - 0.37380143i}
+        };
         EXPECT_TRUE(allclose(cmplexpected_conj, cmplres_conj));
 
         using assign_t_conj = xassign_traits<xarray<std::complex<double>>, decltype(cmplres_conj)>;
@@ -145,24 +154,20 @@ namespace xt
         auto b2 = cmplres_conj.template load_simd<xsimd::aligned_mode>(0);
         static_cast<void>(b1);
         static_cast<void>(b2);
-        EXPECT_TRUE(assign_t_conj::convertible_types());
-        EXPECT_TRUE(assign_t_conj::simd_size());
-        EXPECT_FALSE(assign_t_conj::forbid_simd());
-        EXPECT_TRUE(assign_t_conj::simd_assign());
+        EXPECT_TRUE(assign_t_conj::simd_linear_assign());
 #endif
 
         auto cmplres_norm = xt::norm(cmplarg_0);
-        xarray<double> fieldnorm = {{0.66822937, 0.5765938, 0.19374703},
-                                    {0.30205453, 1.0307235, 0.48069004},
-                                    {0.57322529, 0.62248637, 0.14673763}};
+        xarray<double> fieldnorm = {
+            {0.66822937, 0.5765938, 0.19374703},
+            {0.30205453, 1.0307235, 0.48069004},
+            {0.57322529, 0.62248637, 0.14673763}
+        };
 
         using assign_t_norm = xassign_traits<xarray<double>, decltype(cmplres_norm)>;
 
 #if XTENSOR_USE_XSIMD
-        EXPECT_TRUE(assign_t_norm::convertible_types());
-        EXPECT_TRUE(assign_t_norm::simd_size());
-        EXPECT_FALSE(assign_t_norm::forbid_simd());
-        EXPECT_TRUE(assign_t_norm::simd_assign());
+        EXPECT_TRUE(assign_t_norm::simd_linear_assign());
 #endif
 
         EXPECT_TRUE(allclose(fieldnorm, cmplres_norm));
@@ -170,9 +175,11 @@ namespace xt
 
     TEST(xcomplex, arg)
     {
-        xarray<std::complex<double>> cmplarg_0 = {{0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
-                                                  {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
-                                                  {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}};
+        xarray<std::complex<double>> cmplarg_0 = {
+            {0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
+            {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
+            {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}
+        };
         auto cmplres = xt::arg(cmplarg_0);
 
         auto evc = xt::eval(cmplres);
@@ -188,20 +195,18 @@ namespace xt
         using assign_t_arg = xassign_traits<xarray<double>, decltype(cmplres)>;
 
 #if XTENSOR_USE_XSIMD
-        EXPECT_TRUE(assign_t_arg::convertible_types());
-        EXPECT_TRUE(assign_t_arg::simd_size());
-        EXPECT_FALSE(assign_t_arg::forbid_simd());
-        EXPECT_TRUE(assign_t_arg::simd_assign());
+        EXPECT_TRUE(assign_t_arg::simd_linear_assign());
 #endif
-
     }
 
     TEST(xcomplex, conj_real)
     {
-        xarray<double> A = {{0.81745298, 0.75933774, 0.44016704},
-                            {0.54959488, 1.01524554, 0.69331814},
-                            {0.75711643, 0.78897806, 0.38306348}};
-        xarray<double> B = xt::conj(A);
+        xarray<double> A = {
+            {0.81745298, 0.75933774, 0.44016704},
+            {0.54959488, 1.01524554, 0.69331814},
+            {0.75711643, 0.78897806, 0.38306348}
+        };
+        xarray<double> B = xt::real(xt::conj(A));
         EXPECT_EQ(A, B);
     }
 
@@ -229,13 +234,17 @@ namespace xt
 
     TEST(xcomplex, isclose)
     {
-        xarray<std::complex<double>> arg = {{0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
-                                            {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
-                                            {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}};
-
-        xarray<std::complex<double>> compare = {{0.401 + 0.712i, 0.627 + 0.427i, 0.324 + 0.297i},
-                                                {0.244 + 0.492i, 0.694 + 0.740i, 0.593 + 0.357i},
-                                                {0.631 + 0.417i, 0.440 + 0.654i, 0.083 + 0.373i}};
+        xarray<std::complex<double>> arg = {
+            {0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
+            {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
+            {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}
+        };
+
+        xarray<std::complex<double>> compare = {
+            {0.401 + 0.712i, 0.627 + 0.427i, 0.324 + 0.297i},
+            {0.244 + 0.492i, 0.694 + 0.740i, 0.593 + 0.357i},
+            {0.631 + 0.417i, 0.440 + 0.654i, 0.083 + 0.373i}
+        };
 
         auto veryclose = isclose(arg, compare, 1e-5);
         auto looselyclose = isclose(arg, compare, 1e-1);
@@ -254,6 +263,97 @@ namespace xt
 
         EXPECT_TRUE(isclose(c_t(inf, -inf), c_t(0, inf))() == false);
         EXPECT_TRUE(isclose(c_t(5, 5), c_t(5, -5))() == false);
+    }
+
+    TEST(xcomplex, real_expression)
+    {
+        using cpx = std::complex<double>;
+        xtensor<cpx, 2> a = {{cpx(1, 1), cpx(-1, 1), cpx(-2, -2)}, {cpx(-1, 0), cpx(0, 1), cpx(2, 2)}};
+
+        xtensor<double, 2> exp = {{2, -2, -4}, {-2, 0, 4}};
+        xtensor<double, 2> res = real(a + a);
+        EXPECT_EQ(res, exp);
+    }
+
+    TEST(xcomplex, conj)
+    {
+        using cpx = std::complex<double>;
+        xtensor<cpx, 2> a = {{cpx(1, 1), cpx(-1, 1), cpx(-2, -2)}, {cpx(-1, 0), cpx(0, 1), cpx(2, 2)}};
+        xtensor<cpx, 2> res = conj(a);
+        xtensor<cpx, 2> exp = {{cpx(1, -1), cpx(-1, -1), cpx(-2, 2)}, {cpx(-1, 0), cpx(0, -1), cpx(2, -2)}};
+
+        EXPECT_EQ(res, exp);
+    }
+
+    TEST(xcomplex, exp)
+    {
+        xt::xarray<float> ph =
+            {274.7323f, 276.3974f, 274.7323f, 276.3974f, 274.7323f, 276.3974f, 274.7323f, 276.3974f};
+        xt::xarray<std::complex<float>> input = ph * std::complex<float>(0, 1.f);
+        xt::xarray<std::complex<float>> res = xt::exp(input);
+        auto expected = xt::xarray<std::complex<float>>::from_shape({size_t(8)});
+        std::transform(
+            input.cbegin(),
+            input.cend(),
+            expected.begin(),
+            [](const std::complex<float>& arg)
+            {
+                return std::exp(arg);
+            }
+        );
+        EXPECT_EQ(expected, res);
+    }
+
+    TEST(xcomplex, longdouble)
+    {
+        using cmplx = std::complex<long double>;
+        xt::xtensor<cmplx, 2> a = xt::empty<cmplx>({5, 5});
+        xt::real(a) = 123.321L;
+        xt::imag(a) = -123.321L;
+
+        EXPECT_EQ(a(4, 4), cmplx(123.321L, -123.321L));
+
+        xt::real(a) = xt::imag(a);
+
+        EXPECT_EQ(a(0, 0), cmplx(-123.321L, -123.321L));
+        EXPECT_EQ(a(4, 4), cmplx(-123.321L, -123.321L));
+    }
+
+    TEST(xcomplex, build_from_double)
+    {
+        xt::xarray<double> r = {1., 2., 3.};
+        xt::xarray<std::complex<double>> rc(r);
+        EXPECT_EQ(rc(0).real(), r(0));
+        EXPECT_EQ(rc(1).real(), r(1));
+        EXPECT_EQ(rc(2).real(), r(2));
+    }
+
+    TEST(xcomplex, xcomplex)
+    {
+        using complex_type = xtl::xcomplex<double>;
+        xt::xarray<complex_type> a = xt::ones<complex_type>(std::vector<size_t>(3, 7));
+
+        auto simd_loaded = a.template load_simd<xt_simd::aligned_mode, complex_type, xt_simd::simd_traits<complex_type>::size>(
+            0
+        );
+        (void) simd_loaded;
+    }
+
+    TEST(xcomplex, view)
+    {
+        using cpx = std::complex<double>;
+        xt::xtensor<cpx, 2> a = {{cpx(1, 1), cpx(-1, 1), cpx(-2, -2)}, {cpx(-1, 0), cpx(0, 1), cpx(2, 2)}};
+
+        xtensor<cpx, 1> c = conj(view(a, 0, xt::all()));
+        xtensor<cpx, 1> exp_conj = {cpx(1, -1), cpx(-1, -1), cpx(-2, 2)};
+        EXPECT_EQ(c, exp_conj);
+
+        xtensor<double, 1> r = real(view(a, 0, xt::all()));
+        xtensor<double, 1> exp_real = {double(1), double(-1), double(-2)};
+        EXPECT_EQ(r, exp_real);
 
+        xtensor<double, 1> im = imag(view(a, 0, xt::all()));
+        xtensor<double, 1> exp_im = {double(1), double(1), double(-2)};
+        EXPECT_EQ(im, exp_im);
     }
-}
\ No newline at end of file
+}
diff --git a/test/test_xconcepts.cpp b/test/test_xconcepts.cpp
deleted file mode 100644
index ab93e7715..000000000
--- a/test/test_xconcepts.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/***************************************************************************
-* Copyright (c) 2017, Ullrich Koethe                                       *
-*                                                                          *
-* Distributed under the terms of the BSD 3-Clause License.                 *
-*                                                                          *
-* The full license is in the file LICENSE, distributed with this software. *
-****************************************************************************/
-
-#include "gtest/gtest.h"
-#include "xtensor/xconcepts.hpp"
-
-namespace xt
-{
-    template <class T,
-              XTENSOR_REQUIRE<std::is_integral<T>::value>>
-    int test_concept_check(T);
-
-    template <class T,
-              XTENSOR_REQUIRE<!std::is_integral<T>::value>>
-    void test_concept_check(T);
-
-    TEST(concepts, concept_check)
-    {
-        EXPECT_TRUE((std::is_same<decltype(test_concept_check(1)), int>::value));
-        EXPECT_TRUE((std::is_same<decltype(test_concept_check(1.0)), void>::value));
-    }
-
-    TEST(concepts, iterator_concept)
-    {
-        {
-            bool is_iter = iterator_concept<int>::value;
-            EXPECT_FALSE(is_iter);
-        }
-        {
-            bool is_iter = iterator_concept<int[3]>::value;
-            EXPECT_TRUE(is_iter);
-        }
-        {
-            bool is_iter = iterator_concept<int*>::value;
-            EXPECT_TRUE(is_iter);
-        }
-        {
-            bool is_iter = iterator_concept<decltype(std::vector<int>().begin())>::value;
-            EXPECT_TRUE(is_iter);
-        }
-    }
-
-    TEST(concepts, is_narrowing_conversion)
-    {
-        {
-            bool is_narrowing = is_narrowing_conversion<int32_t, uint8_t>::value;
-            EXPECT_TRUE(is_narrowing);
-        }
-        {
-            bool is_narrowing = is_narrowing_conversion<double, uint32_t>::value;
-            EXPECT_TRUE(is_narrowing);
-        }
-        {
-            bool is_narrowing = is_narrowing_conversion<uint8_t, int32_t>::value;
-            EXPECT_FALSE(is_narrowing);
-        }
-        {
-            bool is_narrowing = is_narrowing_conversion<uint32_t, double>::value;
-            EXPECT_FALSE(is_narrowing);
-        }
-    }
-
-}  // namespace xt
diff --git a/test/test_xcontainer_semantic.cpp b/test/test_xcontainer_semantic.cpp
index d46e75076..05dc26e30 100644
--- a/test/test_xcontainer_semantic.cpp
+++ b/test/test_xcontainer_semantic.cpp
@@ -1,14 +1,16 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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 "test_common_macros.hpp"
 #include "test_xsemantic.hpp"
 
+TEST_SUITE_BEGIN("container_semantic");
+
 namespace xt
 {
     template <class C>
@@ -19,671 +21,674 @@ namespace xt
         using storage_type = C;
     };
 
-    using testing_types = ::testing::Types<xarray_dynamic, xtensor_dynamic>;
-    TYPED_TEST_CASE(container_semantic, testing_types);
+#define CONTAINER_SEMANTIC_TYPES xarray_dynamic, xtensor_dynamic
 
-    TYPED_TEST(container_semantic, a_plus_b)
+    TEST_CASE_TEMPLATE("a_plus_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::plus<>, TypeParam> tester;
 
+        SUBCASE("row_major + row_major")
         {
-            SCOPED_TRACE("row_major + row_major");
             TypeParam b = tester.a + tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major + column_major")
         {
-            SCOPED_TRACE("row_major + column_major");
             TypeParam b = tester.a + tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major + central_major")
         {
-            SCOPED_TRACE("row_major + central_major");
             TypeParam b = tester.a + tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major + unit_major")
         {
-            SCOPED_TRACE("row_major + unit_major");
             TypeParam b = tester.a + tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_minus_b)
+    TEST_CASE_TEMPLATE("a_minus_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::minus<>, TypeParam> tester;
 
+        SUBCASE("row_major - row_major")
         {
-            SCOPED_TRACE("row_major - row_major");
             TypeParam b = tester.a - tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major - column_major")
         {
-            SCOPED_TRACE("row_major - column_major");
             TypeParam b = tester.a - tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major - central_major")
         {
-            SCOPED_TRACE("row_major - central_major");
             TypeParam b = tester.a - tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major - unit_major")
         {
-            SCOPED_TRACE("row_major - unit_major");
             TypeParam b = tester.a - tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_times_b)
+    TEST_CASE_TEMPLATE("a_times_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::multiplies<>, TypeParam> tester;
 
+        SUBCASE("row_major * row_major")
         {
-            SCOPED_TRACE("row_major * row_major");
             TypeParam b = tester.a * tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major * column_major")
         {
-            SCOPED_TRACE("row_major * column_major");
             TypeParam b = tester.a * tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major * central_major")
         {
-            SCOPED_TRACE("row_major * central_major");
             TypeParam b = tester.a * tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major * unit_major")
         {
-            SCOPED_TRACE("row_major * unit_major");
             TypeParam b = tester.a * tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_divide_by_b)
+    TEST_CASE_TEMPLATE("a_divide_by_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::divides<>, TypeParam> tester;
 
+        SUBCASE("row_major / row_major")
         {
-            SCOPED_TRACE("row_major / row_major");
             TypeParam b = tester.a / tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major / column_major")
         {
-            SCOPED_TRACE("row_major / column_major");
             TypeParam b = tester.a / tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major / central_major")
         {
-            SCOPED_TRACE("row_major / central_major");
             TypeParam b = tester.a / tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major / unit_major")
         {
-            SCOPED_TRACE("row_major / unit_major");
             TypeParam b = tester.a / tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_bitwise_and_b)
+    TEST_CASE_TEMPLATE("a_bitwise_and_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_and<>, TypeParam> tester;
 
+        SUBCASE("row_major & row_major")
         {
-            SCOPED_TRACE("row_major & row_major");
             TypeParam b = tester.a & tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major & column_major")
         {
-            SCOPED_TRACE("row_major & column_major");
             TypeParam b = tester.a & tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major & central_major")
         {
-            SCOPED_TRACE("row_major & central_major");
             TypeParam b = tester.a & tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major & unit_major")
         {
-            SCOPED_TRACE("row_major & unit_major");
             TypeParam b = tester.a & tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_bitwise_or_b)
+    TEST_CASE_TEMPLATE("a_bitwise_or_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_or<>, TypeParam> tester;
 
+        SUBCASE("row_major | row_major")
         {
-            SCOPED_TRACE("row_major | row_major");
             TypeParam b = tester.a | tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major | column_major")
         {
-            SCOPED_TRACE("row_major | column_major");
             TypeParam b = tester.a | tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major | central_major")
         {
-            SCOPED_TRACE("row_major | central_major");
             TypeParam b = tester.a | tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major | unit_major")
         {
-            SCOPED_TRACE("row_major | unit_major");
             TypeParam b = tester.a | tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_bitwise_xor_b)
+    TEST_CASE_TEMPLATE("a_bitwise_xor_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_xor<>, TypeParam> tester;
 
+        SUBCASE("row_major ^ row_major")
         {
-            SCOPED_TRACE("row_major ^ row_major");
             TypeParam b = tester.a ^ tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major ^ column_major")
         {
-            SCOPED_TRACE("row_major ^ column_major");
             TypeParam b = tester.a ^ tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major ^ central_major")
         {
-            SCOPED_TRACE("row_major ^ central_major");
             TypeParam b = tester.a ^ tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major ^ unit_major")
         {
-            SCOPED_TRACE("row_major ^ unit_major");
             TypeParam b = tester.a ^ tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_plus_equal_b)
+    TEST_CASE_TEMPLATE("a_plus_equal_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::plus<>, TypeParam> tester;
 
+        SUBCASE("row_major += row_major")
         {
-            SCOPED_TRACE("row_major += row_major");
             TypeParam b = tester.a;
             b += tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major += column_major")
         {
-            SCOPED_TRACE("row_major += column_major");
             TypeParam b = tester.a;
             b += tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major += central_major")
         {
-            SCOPED_TRACE("row_major += central_major");
             TypeParam b = tester.a;
             b += tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major += unit_major")
         {
-            SCOPED_TRACE("row_major += unit_major");
             TypeParam b = tester.a;
             b += tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_minus_equal_b)
+    TEST_CASE_TEMPLATE("a_minus_equal_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::minus<>, TypeParam> tester;
 
+        SUBCASE("row_major -= row_major")
         {
-            SCOPED_TRACE("row_major -= row_major");
             TypeParam b = tester.a;
             b -= tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major -= column_major")
         {
-            SCOPED_TRACE("row_major -= column_major");
             TypeParam b = tester.a;
             b -= tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major -= central_major")
         {
-            SCOPED_TRACE("row_major -= central_major");
             TypeParam b = tester.a;
             b -= tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major -= unit_major")
         {
-            SCOPED_TRACE("row_major -= unit_major");
             TypeParam b = tester.a;
             b -= tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_times_equal_b)
+    TEST_CASE_TEMPLATE("a_times_equal_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::multiplies<>, TypeParam> tester;
 
+        SUBCASE("row_major *= row_major")
         {
-            SCOPED_TRACE("row_major *= row_major");
             TypeParam b = tester.a;
             b *= tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major *= column_major")
         {
-            SCOPED_TRACE("row_major *= column_major");
             TypeParam b = tester.a;
             b *= tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major *= central_major")
         {
-            SCOPED_TRACE("row_major *= central_major");
             TypeParam b = tester.a;
             b *= tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major *= unit_major")
         {
-            SCOPED_TRACE("row_major *= unit_major");
             TypeParam b = tester.a;
             b *= tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_divide_by_equal_b)
+    TEST_CASE_TEMPLATE("a_divide_by_equal_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::divides<>, TypeParam> tester;
 
+        SUBCASE("row_major /= row_major")
         {
-            SCOPED_TRACE("row_major /= row_major");
             TypeParam b = tester.a;
             b /= tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major /= column_major")
         {
-            SCOPED_TRACE("row_major /= column_major");
             TypeParam b = tester.a;
             b /= tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major /= central_major")
         {
-            SCOPED_TRACE("row_major /= central_major");
             TypeParam b = tester.a;
             b /= tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major /= unit_major")
         {
-            SCOPED_TRACE("row_major /= unit_major");
             TypeParam b = tester.a;
             b /= tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_bitwise_and_equal_b)
+    TEST_CASE_TEMPLATE("a_bitwise_and_equal_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_and<>, TypeParam> tester;
 
+        SUBCASE("row_major &= row_major")
         {
-            SCOPED_TRACE("row_major &= row_major");
             TypeParam b = tester.a;
             b &= tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major &= column_major")
         {
-            SCOPED_TRACE("row_major &= column_major");
             TypeParam b = tester.a;
             b &= tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major &= central_major")
         {
-            SCOPED_TRACE("row_major &= central_major");
             TypeParam b = tester.a;
             b &= tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major &= unit_major")
         {
-            SCOPED_TRACE("row_major &= unit_major");
             TypeParam b = tester.a;
             b &= tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_bitwise_or_equal_b)
+    TEST_CASE_TEMPLATE("a_bitwise_or_equal_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_or<>, TypeParam> tester;
 
+        SUBCASE("row_major |= row_major")
         {
-            SCOPED_TRACE("row_major |= row_major");
             TypeParam b = tester.a;
             b |= tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major |= column_major")
         {
-            SCOPED_TRACE("row_major |= column_major");
             TypeParam b = tester.a;
             b |= tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major |= central_major")
         {
-            SCOPED_TRACE("row_major |= central_major");
             TypeParam b = tester.a;
             b |= tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major |= unit_major")
         {
-            SCOPED_TRACE("row_major |= unit_major");
             TypeParam b = tester.a;
             b |= tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, a_bitwise_xor_equal_b)
+    TEST_CASE_TEMPLATE("a_bitwise_xor_equal_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_xor<>, TypeParam> tester;
 
+        SUBCASE("row_major ^= row_major")
         {
-            SCOPED_TRACE("row_major ^= row_major");
             TypeParam b = tester.a;
             b ^= tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major ^= column_major")
         {
-            SCOPED_TRACE("row_major ^= column_major");
             TypeParam b = tester.a;
             b ^= tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major ^= central_major")
         {
-            SCOPED_TRACE("row_major ^= central_major");
             TypeParam b = tester.a;
             b ^= tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major ^= unit_major")
         {
-            SCOPED_TRACE("row_major ^= unit_major");
             TypeParam b = tester.a;
             b ^= tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, assign_a_plus_b)
+    TEST_CASE_TEMPLATE("assign_a_plus_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::plus<>, TypeParam> tester;
 
+        SUBCASE("row_major + row_major")
         {
-            SCOPED_TRACE("row_major + row_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a + tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major + column_major")
         {
-            SCOPED_TRACE("row_major + column_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a + tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major + central_major")
         {
-            SCOPED_TRACE("row_major + central_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a + tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major + unit_major")
         {
-            SCOPED_TRACE("row_major + unit_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a + tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, assign_a_minus_b)
+    TEST_CASE_TEMPLATE("assign_a_minus_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::minus<>, TypeParam> tester;
 
+        SUBCASE("row_major - row_major")
         {
-            SCOPED_TRACE("row_major - row_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a - tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major - column_major")
         {
-            SCOPED_TRACE("row_major - column_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a - tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major - central_major")
         {
-            SCOPED_TRACE("row_major - central_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a - tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major - unit_major")
         {
-            SCOPED_TRACE("row_major - unit_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a - tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, assign_a_multiplies_b)
+    TEST_CASE_TEMPLATE("assign_a_multiplies_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::multiplies<>, TypeParam> tester;
 
+        SUBCASE("row_major * row_major")
         {
-            SCOPED_TRACE("row_major * row_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a * tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major * column_major")
         {
-            SCOPED_TRACE("row_major * column_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a * tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major * central_major")
         {
-            SCOPED_TRACE("row_major * central_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a * tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major * unit_major")
         {
-            SCOPED_TRACE("row_major * unit_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a * tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, assign_a_divides_by_b)
+    TEST_CASE_TEMPLATE("assign_a_divides_by_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::divides<>, TypeParam> tester;
 
+        SUBCASE("row_major / row_major")
         {
-            SCOPED_TRACE("row_major / row_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a / tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major / column_major")
         {
-            SCOPED_TRACE("row_major / column_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a / tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major / central_major")
         {
-            SCOPED_TRACE("row_major / central_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a / tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major / unit_major")
         {
-            SCOPED_TRACE("row_major / unit_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a / tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, assign_a_bitwise_and_b)
+    TEST_CASE_TEMPLATE("assign_a_bitwise_and_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_and<>, TypeParam> tester;
 
+        SUBCASE("row_major & row_major")
         {
-            SCOPED_TRACE("row_major & row_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a & tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major & column_major")
         {
-            SCOPED_TRACE("row_major & column_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a & tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major & central_major")
         {
-            SCOPED_TRACE("row_major & central_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a & tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major & unit_major")
         {
-            SCOPED_TRACE("row_major & unit_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a & tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, assign_a_bitwise_or_b)
+    TEST_CASE_TEMPLATE("assign_a_bitwise_or_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_or<>, TypeParam> tester;
 
+        SUBCASE("row_major | row_major")
         {
-            SCOPED_TRACE("row_major | row_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a | tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major | column_major")
         {
-            SCOPED_TRACE("row_major | column_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a | tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major | central_major")
         {
-            SCOPED_TRACE("row_major | central_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a | tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major | unit_major")
         {
-            SCOPED_TRACE("row_major | unit_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a | tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
 
-    TYPED_TEST(container_semantic, assign_a_bitwise_xor_b)
+    TEST_CASE_TEMPLATE("assign_a_bitwise_xor_b", TypeParam, xarray_dynamic, xtensor_dynamic)
     {
         operation_tester<std::bit_xor<>, TypeParam> tester;
 
+        SUBCASE("row_major ^ row_major")
         {
-            SCOPED_TRACE("row_major ^ row_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a ^ tester.ra;
             EXPECT_EQ(tester.res_rr, b);
         }
 
+        SUBCASE("row_major ^ column_major")
         {
-            SCOPED_TRACE("row_major ^ column_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a ^ tester.ca;
             EXPECT_EQ(tester.res_rc, b);
         }
 
+        SUBCASE("row_major ^ central_major")
         {
-            SCOPED_TRACE("row_major ^ central_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a ^ tester.cta;
             EXPECT_EQ(tester.res_rct, b);
         }
 
+        SUBCASE("row_major ^ unit_major")
         {
-            SCOPED_TRACE("row_major ^ unit_major");
             TypeParam b(tester.ca.shape(), 0);
             b = tester.a ^ tester.ua;
             EXPECT_EQ(tester.res_ru, b);
         }
     }
+
+#undef CONTAINER_SEMANTIC_TYPES
 }
+
+TEST_SUITE_END();
diff --git a/test/test_xcsv.cpp b/test/test_xcsv.cpp
index c30b675e3..00fcd4519 100644
--- a/test/test_xcsv.cpp
+++ b/test/test_xcsv.cpp
@@ -1,48 +1,189 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
 
 #include <sstream>
-#include <iostream>
 
-#include "xtensor/xcsv.hpp"
-#include "xtensor/xmath.hpp" 
-#include "xtensor/xio.hpp" 
+#include "xtensor/io/xcsv.hpp"
+#include "xtensor/io/xio.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
+    TEST(xcsv, load_1D)
+    {
+        const std::string source = "1, 2, 3, 4";
+
+        std::stringstream source_stream(source);
+
+        const xtensor<int, 2> res = load_csv<int>(source_stream);
+
+        const xtensor<int, 2> exp{{1, 2, 3, 4}};
+
+        ASSERT_TRUE(all(equal(res, exp)));
+    }
+
     TEST(xcsv, load_double)
     {
-        std::string source =
-            "1.0, 2.0, 3.0, 4.0\n"
-            "10.0, 12.0, 15.0, 18.0";
+        std::string source = "1.0, 2.0, 3.0, 4.0\n"
+                             "10.0, 12.0, 15.0, 18.0";
 
         std::stringstream source_stream(source);
 
         xtensor<double, 2> res = load_csv<double>(source_stream);
 
-        xtensor<double, 2> exp
-            {{ 1.0,  2.0,  3.0,  4.0},
-             {10.0, 12.0, 15.0, 18.0}};
+        xtensor<double, 2> exp{{1.0, 2.0, 3.0, 4.0}, {10.0, 12.0, 15.0, 18.0}};
 
         ASSERT_TRUE(all(equal(res, exp)));
     }
 
+    TEST(xcsv, load_binary_matrix)
+    {
+        const std::string source = "1,0,1\n"
+                                   "0,1,1";
+
+        std::stringstream source_stream(source);
+
+        const xtensor<uint8_t, 2> res = load_csv<uint8_t>(source_stream);
+
+        const xtensor<uint8_t, 2> exp{{1, 0, 1}, {0, 1, 1}};
+
+        ASSERT_TRUE(all(equal(res, exp)));
+    }
+
+    TEST(xcsv, load_double_with_options)
+    {
+        std::string source = "A B C D\n"
+                             "#0.0 1.0 1.1 1.2\n"
+                             "1.0 2.0 3.0 4.0\n"
+                             "10.0 12.0 15.0 18.0\n"
+                             "9.0, 8.0, 7.0, 6.";
+
+        std::stringstream source_stream(source);
+
+        auto res = load_csv<double>(source_stream, ' ', 1, 2, "#");
+
+        xtensor<double, 2> exp{{1.0, 2.0, 3.0, 4.0}, {10.0, 12.0, 15.0, 18.0}};
+
+        ASSERT_TRUE(all(equal(res, exp)));
+    }
+
+    TEST(xcsv, load_string_trims_cells)
+    {
+        const std::string source = "  alpha  , beta,gamma   \n delta,  epsilon , zeta  ";
+
+        std::stringstream source_stream(source);
+
+        const xtensor<std::string, 2> res = load_csv<std::string>(source_stream);
+
+        ASSERT_EQ(res.shape()[0], std::size_t(2));
+        ASSERT_EQ(res.shape()[1], std::size_t(3));
+        ASSERT_EQ(res(0, 0), "alpha");
+        ASSERT_EQ(res(0, 1), "beta");
+        ASSERT_EQ(res(0, 2), "gamma");
+        ASSERT_EQ(res(1, 0), "delta");
+        ASSERT_EQ(res(1, 1), "epsilon");
+        ASSERT_EQ(res(1, 2), "zeta");
+    }
+
+    TEST(xcsv, load_file_uses_config)
+    {
+        const std::string source = "metadata\n"
+                                   "//ignore this row\n"
+                                   "1;2;3\n"
+                                   "4;5;6\n"
+                                   "7;8;9";
+
+        std::stringstream source_stream(source);
+        xcsv_config config;
+        config.delimiter = ';';
+        config.skip_rows = 1;
+        config.max_rows = 2;
+        config.comments = "//";
+
+        xtensor<int, 2> res = {{0, 0, 0}};
+        load_file(source_stream, res, config);
+
+        const xtensor<int, 2> exp{{1, 2, 3}, {4, 5, 6}};
+
+        ASSERT_TRUE(all(equal(res, exp)));
+    }
+
+    TEST(xcsv, load_inconsistent_rows_throws)
+    {
+        const std::string source = "1,2,3\n4,5";
+
+        std::stringstream source_stream(source);
+
+        XT_EXPECT_THROW(load_csv<int>(source_stream), std::runtime_error);
+    }
+
+    TEST(xcsv, dump_1D)
+    {
+        xtensor<double, 1> data{{1.0, 2.0, 3.0, 4.0}};
+
+        std::stringstream res;
+
+        dump_csv(res, data);
+        ASSERT_EQ("1,2,3,4\n", res.str());
+    }
+
     TEST(xcsv, dump_double)
     {
-        xtensor<double, 2> data
-            {{ 1.0,  2.0,  3.0,  4.0},
-             {10.0, 12.0, 15.0, 18.0}};
+        xtensor<double, 2> data{{1.0, 2.0, 3.0, 4.0}, {10.0, 12.0, 15.0, 18.0}};
 
         std::stringstream res;
 
         dump_csv(res, data);
         ASSERT_EQ("1,2,3,4\n10,12,15,18\n", res.str());
     }
+
+    TEST(xcsv, dump_file_matches_dump_csv)
+    {
+        xtensor<int, 2> data{{1, 2}, {3, 4}};
+        std::stringstream res;
+        xcsv_config config;
+
+        dump_file(res, data, config);
+
+        ASSERT_EQ("1,2\n3,4\n", res.str());
+    }
+
+    TEST(xcsv, dump_higher_dimension_throws)
+    {
+        xtensor<double, 3> data{{{1.0, 2.0}, {3.0, 4.0}}};
+        std::stringstream res;
+
+        XT_EXPECT_THROW(dump_csv(res, data), std::runtime_error);
+    }
+
+    TEST(xcsv, dump_with_config)
+    {
+        xtensor<double, 2> data{{1.0, 2.0, 3.0, 4.0}, {10.0, 12.0, 15.0, 18.0}};
+
+        std::stringstream res;
+
+        xcsv_config config;
+        config.delimiter = ' ';
+        dump_csv(res, data, config);
+        ASSERT_EQ("1 2 3 4\n10 12 15 18\n", res.str());
+    }
+
+    TEST(xcsv, dump_file_with_config)
+    {
+        xtensor<double, 2> data{{1.0, 2.0, 3.0, 4.0}, {10.0, 12.0, 15.0, 18.0}};
+
+        std::stringstream res;
+
+        xcsv_config config;
+        config.delimiter = ';';
+        dump_file(res, data, config);
+        ASSERT_EQ("1;2;3;4\n10;12;15;18\n", res.str());
+    }
 }
diff --git a/test/test_xdatesupport.cpp b/test/test_xdatesupport.cpp
index 1885d3210..33cd7ee46 100644
--- a/test/test_xdatesupport.cpp
+++ b/test/test_xdatesupport.cpp
@@ -1,25 +1,31 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
+#if defined(__GNUC__) && (__GNUC__ == 7) && (__cplusplus == 201703L)
+#warning "test_xdatesupport.cpp has been deactivated because it leads to internal compiler error"
+#else
 
 #include <chrono>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xmath.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xtensor.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/io/xio.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
-    using days            = std::chrono::duration<long long, std::ratio<3600 * 24>>;
+    using days = std::chrono::duration<long long, std::ratio<3600 * 24>>;
     using days_time_point = std::chrono::time_point<std::chrono::system_clock, days>;
+    using tp = std::chrono::system_clock::time_point;
 
     std::ostream& operator<<(std::ostream& os, const days_time_point& /*rhs*/)
     {
@@ -33,15 +39,14 @@ namespace xt
     TEST(xdate, xarray_of_dates)
     {
         xt::xarray<days_time_point> dates(
-            {
-                days_time_point{days{300}},
-                days_time_point{days{400}},
-                days_time_point{days{600}},
-                days_time_point{days{10000}}
-            });
+            {days_time_point{days{300}},
+             days_time_point{days{400}},
+             days_time_point{days{600}},
+             days_time_point{days{10000}}}
+        );
 
         xt::xarray<days> durations({days{300}, days{400}, days{600}, days{10000}});
-        
+
         xt::xarray<days_time_point> result = dates + durations;
         xt::xarray<days_time_point> result2 = dates + days{500};
 
@@ -49,4 +54,39 @@ namespace xt
 
         EXPECT_EQ((result < result2), expected);
     }
+
+    TEST(xdate, date_arange)
+    {
+        xarray<tp> tarr = xt::arange<tp>(
+            std::chrono::system_clock::now(),
+            std::chrono::system_clock::now() + std::chrono::hours(15),
+            std::chrono::hours(1)
+        );
+        EXPECT_TRUE(tarr.storage().back() > tarr.storage().front());
+    }
+
+    TEST(xdate, xfunction)
+    {
+        xarray<tp> tarr = {
+            std::chrono::system_clock::now(),
+            std::chrono::system_clock::now(),
+            std::chrono::system_clock::now()
+        };
+
+        auto hours = std::chrono::hours(15);
+
+        auto func = tarr + hours;
+        xarray<tp> arrpf = func;
+
+        arrpf(0) -= std::chrono::hours(200);
+
+        EXPECT_TRUE(all(equal(tarr, tarr)));
+        xarray<bool> cmp_res = {true, false, false};
+        EXPECT_EQ(cmp_res, (arrpf < tarr));
+        EXPECT_EQ(!cmp_res, (arrpf > tarr));
+        cmp_res = {false, false, false};
+        EXPECT_EQ(cmp_res, equal(tarr, arrpf));
+    }
 }
+
+#endif  // defined(__GNUC__) && (__GNUC__ == 7) && (__cplusplus == 201703L)
diff --git a/test/test_xdynamic_view.cpp b/test/test_xdynamic_view.cpp
index a9e9c0cd6..dff43d80d 100644
--- a/test/test_xdynamic_view.cpp
+++ b/test/test_xdynamic_view.cpp
@@ -1,21 +1,23 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xdynamic_view.hpp"
-#include "xtensor/xtensor.hpp"
-
-#include "xtensor/xview.hpp"
-#include "xtensor/xindex_view.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/views/xdynamic_view.hpp"
+#include "xtensor/views/xindex_view.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -24,14 +26,12 @@ namespace xt
 
     TEST(xdynamic_view, keep)
     {
-        xarray<int> a = { {{0, 1, 2, 3},
-                           {4, 5, 6, 7},
-                           {8, 9, 10, 11}},
-                          {{12, 13, 14, 15},
-                           {16, 17, 18, 19},
-                           {20, 21, 22, 23}} };
-
-        auto view0 = dynamic_view(a, xdynamic_slice_vector({ 1, keep(0, 2), range(1, 4) }));
+        xarray<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
+
+        auto view0 = dynamic_view(a, xdynamic_slice_vector({1, keep(0, 2), range(1, 4)}));
         EXPECT_EQ(view0.dimension(), size_t(2));
         EXPECT_EQ(view0.shape()[0], size_t(2));
         EXPECT_EQ(view0.shape()[1], size_t(3));
@@ -42,7 +42,7 @@ namespace xt
         EXPECT_EQ(view0(1, 1), a(1, 2, 2));
         EXPECT_EQ(view0(1, 2), a(1, 2, 3));
 
-        auto view1 = dynamic_view(a, xdynamic_slice_vector({ all(), 1, keep(0, 2, 3) }));
+        auto view1 = dynamic_view(a, xdynamic_slice_vector({all(), 1, keep(0, 2, 3)}));
         EXPECT_EQ(view1.dimension(), size_t(2));
         EXPECT_EQ(view1.shape()[0], size_t(2));
         EXPECT_EQ(view1.shape()[1], size_t(3));
@@ -53,10 +53,10 @@ namespace xt
         EXPECT_EQ(view1(1, 1), a(1, 1, 2));
         EXPECT_EQ(view1(1, 2), a(1, 1, 3));
 
-        auto view2 = dynamic_view(a, { all(), 1, keep(0, 2, 3) });
+        auto view2 = dynamic_view(a, {all(), 1, keep(0, 2, 3)});
         EXPECT_EQ(view1, view2);
 
-        auto view3 = dynamic_view(a, { all(), 1, newaxis(), keep(0, 2, 3) });
+        auto view3 = dynamic_view(a, {all(), 1, newaxis(), keep(0, 2, 3)});
         EXPECT_EQ(view3.dimension(), size_t(3));
         EXPECT_EQ(view3.shape()[0], size_t(2));
         EXPECT_EQ(view3.shape()[1], size_t(1));
@@ -68,23 +68,21 @@ namespace xt
         EXPECT_EQ(view3(1, 0, 1), a(1, 1, 2));
         EXPECT_EQ(view3(1, 0, 2), a(1, 1, 3));
 
-        auto view4 = dynamic_view(a, { 1, keep(0, 2), xrange<std::ptrdiff_t>(1, 4) });
+        auto view4 = dynamic_view(a, {1, keep(0, 2), xrange<std::ptrdiff_t>(1, 4)});
         EXPECT_EQ(view0, view4);
 
-        auto view5 = dynamic_view(a, { 1, keep(0, 2), xstepped_range<std::ptrdiff_t>(1, 4, 1) });
+        auto view5 = dynamic_view(a, {1, keep(0, 2), xstepped_range<std::ptrdiff_t>(1, 4, 1)});
         EXPECT_EQ(view0, view5);
     }
 
     TEST(xdynamic_view, keep_iterator)
     {
-        xarray<int> a = { {{0, 1, 2, 3},
-                           {4, 5, 6, 7},
-                           {8, 9, 10, 11}},
-                          {{12, 13, 14, 15},
-                           {16, 17, 18, 19},
-                           {20, 21, 22, 23}} };
-
-        auto view0 = dynamic_view(a, xdynamic_slice_vector({ 1, keep(0, 2), range(1, 4) }));
+        xarray<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
+
+        auto view0 = dynamic_view(a, xdynamic_slice_vector({1, keep(0, 2), range(1, 4)}));
         auto iter = view0.template begin<layout_type::row_major>();
         auto iter_end = view0.template end<layout_type::row_major>();
 
@@ -105,14 +103,12 @@ namespace xt
 
     TEST(xdynamic_view, drop)
     {
-        xarray<int> a = { {{0, 1, 2, 3},
-                           {4, 5, 6, 7},
-                           {8, 9, 10, 11}},
-                          {{12, 13, 14, 15},
-                           {16, 17, 18, 19},
-                           {20, 21, 22, 23}} };
-
-        auto view0 = dynamic_view(a, xdynamic_slice_vector({ 1, drop(1), range(1, 4) }));
+        xarray<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
+
+        auto view0 = dynamic_view(a, xdynamic_slice_vector({1, drop(1), range(1, 4)}));
         EXPECT_EQ(view0.dimension(), size_t(2));
         EXPECT_EQ(view0.shape()[0], size_t(2));
         EXPECT_EQ(view0.shape()[1], size_t(3));
@@ -123,7 +119,7 @@ namespace xt
         EXPECT_EQ(view0(1, 1), a(1, 2, 2));
         EXPECT_EQ(view0(1, 2), a(1, 2, 3));
 
-        auto view1 = dynamic_view(a, xdynamic_slice_vector({ all(), 1, drop(1, 2) }));
+        auto view1 = dynamic_view(a, xdynamic_slice_vector({all(), 1, drop(1, 2)}));
         EXPECT_EQ(view1.dimension(), size_t(2));
         EXPECT_EQ(view1.shape()[0], size_t(2));
         EXPECT_EQ(view1.shape()[1], size_t(2));
@@ -132,7 +128,7 @@ namespace xt
         EXPECT_EQ(view1(1, 0), a(1, 1, 0));
         EXPECT_EQ(view1(1, 1), a(1, 1, 3));
 
-        auto view3 = dynamic_view(a, { all(), 1, newaxis(), drop(1, 2) });
+        auto view3 = dynamic_view(a, {all(), 1, newaxis(), drop(1, 2)});
         EXPECT_EQ(view3.dimension(), size_t(3));
         EXPECT_EQ(view3.shape()[0], size_t(2));
         EXPECT_EQ(view3.shape()[1], size_t(1));
@@ -145,14 +141,12 @@ namespace xt
 
     TEST(xdynamic_view, drop_iterator)
     {
-        xarray<int> a = { {{0, 1, 2, 3},
-                           {4, 5, 6, 7},
-                           {8, 9, 10, 11}},
-                          {{12, 13, 14, 15},
-                           {16, 17, 18, 19},
-                           {20, 21, 22, 23}} };
-
-        auto view0 = dynamic_view(a, xdynamic_slice_vector({ 1, drop(1), range(1, 4) }));
+        xarray<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
+
+        auto view0 = dynamic_view(a, xdynamic_slice_vector({1, drop(1), range(1, 4)}));
         auto iter = view0.template begin<layout_type::row_major>();
         auto iter_end = view0.template end<layout_type::row_major>();
 
@@ -173,17 +167,15 @@ namespace xt
 
     TEST(xdynamic_view, semantic)
     {
-        xarray<int> a = { {{0, 1, 2, 3},
-                           {4, 5, 6, 7},
-                           {8, 9, 10, 11}},
-                          {{12, 13, 14, 15},
-                           {16, 17, 18, 19},
-                           {20, 21, 22, 23}} };
-
-        xarray<int> b1 = { {13, 14, 15}, {21, 22, 23} };
-        xarray<int> b2 = { {0, 1, 2}, {3, 4, 5} };
+        xarray<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
+
+        xarray<int> b1 = {{13, 14, 15}, {21, 22, 23}};
+        xarray<int> b2 = {{0, 1, 2}, {3, 4, 5}};
         xarray<int> exp = b1 + b2;
-        auto view0 = dynamic_view(a, { 1, keep(0, 2), range(1, 4) });
+        auto view0 = dynamic_view(a, {1, keep(0, 2), range(1, 4)});
         view0 += b2;
         EXPECT_EQ(view0, exp);
     }
@@ -212,7 +204,7 @@ namespace xt
         EXPECT_EQ(as.size(), 11);
         EXPECT_EQ(as(0), 0);
 
-        auto as2  = au.convert<std::ptrdiff_t>();
+        auto as2 = au.convert<std::ptrdiff_t>();
         EXPECT_EQ(as2, as);
 
         xnewaxis<std::size_t> nau;
@@ -223,7 +215,7 @@ namespace xt
         auto nas2 = nau.convert<std::ptrdiff_t>();
         EXPECT_EQ(nas2, nas);
 
-        xkeep_slice<std::ptrdiff_t> ks({ 2, 3, -1 });
+        xkeep_slice<std::ptrdiff_t> ks({2, 3, -1});
         ks.normalize(6);
         xkeep_slice<std::size_t> ku(ks);
         EXPECT_EQ(ku.size(), std::size_t(3));
@@ -237,7 +229,7 @@ namespace xt
         auto ks2 = ku.convert<std::size_t>();
         EXPECT_EQ(ks2, ks);
 
-        xdrop_slice<std::ptrdiff_t> ds({ 2, 3, -1 });
+        xdrop_slice<std::ptrdiff_t> ds({2, 3, -1});
         ds.normalize(6);
         xdrop_slice<std::size_t> du(ds);
         EXPECT_EQ(du.size(), std::size_t(3));
@@ -251,4 +243,26 @@ namespace xt
         auto ds2 = du.convert<std::size_t>();
         EXPECT_EQ(ds2, ds);
     }
-}
\ No newline at end of file
+
+    TEST(xdynamic_view, compilation_linux_issue_1349)
+    {
+        xt::xarray<float> array(xt::random::rand<float>({5, 4}));
+        auto v = xt::view(array, xt::keep(2), xt::all());
+        auto res = xt::xarray<float>(xt::dynamic_view(v, {xt::keep(0)}));
+        EXPECT_EQ(res(1), array(2, 1));
+    }
+
+    TEST(xdynamic_view, assignment)
+    {
+        xt::xarray<double, xt::layout_type::column_major> x = {{1, 4}, {2, 5}, {3, 6}};
+
+        xt::xdynamic_slice_vector sv({});
+        sv.push_back(xt::all());
+        sv.push_back(xt::all());
+
+        auto res = xt::dynamic_view(x, sv);
+        xt::xarray<double, xt::layout_type::column_major> xrs = res;
+        EXPECT_EQ(x, res);
+    }
+
+}
diff --git a/test/test_xeval.cpp b/test/test_xeval.cpp
index 74c600d36..18c454425 100644
--- a/test/test_xeval.cpp
+++ b/test/test_xeval.cpp
@@ -1,18 +1,19 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xeval.hpp"
+#include "xtensor/core/xtensor_config.hpp"
+#include "xtensor/generators/xbuilder.hpp"
 
-#include "xtensor/xtensor_config.hpp"
-#include "xtensor/xeval.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
+#include "test_common.hpp"
 
 namespace xt
 {
@@ -53,10 +54,240 @@ namespace xt
         bool type_eq_3 = std::is_same<decltype(n), xtensor<int, 2>&&>::value;
         EXPECT_TRUE(type_eq_3);
 
-#ifndef X_OLD_CLANG
         auto&& i = eval(linspace(0, 100));
         bool type_eq_2 = std::is_same<decltype(i), xtensor<int, 1>&&>::value;
         EXPECT_TRUE(type_eq_2);
-#endif
+    }
+
+#define EXPECT_LAYOUT(EXPRESSION, LAYOUT) EXPECT_TRUE((decltype(EXPRESSION)::static_layout == LAYOUT))
+
+#define HAS_DATA_INTERFACE(EXPRESSION) data_interface_expression<std::decay_t<decltype(EXPRESSION)>>
+
+#define EXPECT_XARRAY(EXPRESSION) \
+    EXPECT_TRUE(!detail::is_array<typename std::decay_t<decltype(EXPRESSION)>::shape_type>::value)
+
+#define EXPECT_XTENSOR(EXPRESSION) \
+    EXPECT_TRUE(detail::is_array<typename std::decay_t<decltype(EXPRESSION)>::shape_type>::value == true)
+
+    TEST(utils, has_same_layout)
+    {
+        xt::xtensor<double, 1, layout_type::row_major> ten1{1., 2., 3.2};
+        EXPECT_TRUE(detail::has_same_layout<layout_type::row_major>(ten1));
+        EXPECT_FALSE(detail::has_same_layout<layout_type::column_major>(ten1));
+        EXPECT_TRUE(detail::has_same_layout<layout_type::any>(ten1));
+
+        xt::xtensor<double, 1, layout_type::column_major> ten2{1., 2., 3.2};
+        EXPECT_TRUE(detail::has_same_layout<layout_type::column_major>(ten2));
+        EXPECT_FALSE(detail::has_same_layout<layout_type::row_major>(ten2));
+        EXPECT_TRUE(detail::has_same_layout<layout_type::any>(ten2));
+
+        EXPECT_FALSE((detail::has_same_layout(ten1, ten2)));
+        EXPECT_TRUE(
+            (detail::has_same_layout(ten1, xt::xtensor<double, 1, layout_type::row_major>({1., 2., 3.2})))
+        );
+        EXPECT_TRUE(
+            (detail::has_same_layout(ten2, xt::xtensor<double, 1, layout_type::column_major>({1., 2., 3.2})))
+        );
+    }
+
+    TEST(utils, has_fixed_dims)
+    {
+        xt::xtensor<double, 1> ten{1., 2., 3.2};
+        EXPECT_TRUE((detail::has_fixed_dims<xt::xtensor<double, 1>>()));
+        EXPECT_TRUE(detail::has_fixed_dims(ten));
+
+        xt::xarray<double> arr{1., 2., 3.2};
+        EXPECT_FALSE((detail::has_fixed_dims<xt::xarray<double>>()));
+        EXPECT_FALSE(detail::has_fixed_dims(arr));
+    }
+
+    TEST(utils, as_xarray_container_t)
+    {
+        using array_type = xt::xarray<double, layout_type::row_major>;
+
+        detail::as_xarray_container_t<array_type, layout_type::column_major> arr;
+        EXPECT_XARRAY(arr);
+        EXPECT_LAYOUT(arr, layout_type::column_major);
+    }
+
+    TEST(utils, as_xtensor_container_t)
+    {
+        using tensor_type = xt::xtensor<double, 1, layout_type::row_major>;
+
+        detail::as_xtensor_container_t<tensor_type, layout_type::column_major> ten;
+        EXPECT_XTENSOR(ten);
+        EXPECT_LAYOUT(ten, layout_type::column_major);
+    }
+
+    namespace testing
+    {  // avoid collision with fixture class
+
+        class as_strided : public ::testing::Test
+        {
+        protected:
+
+            xt::xtensor<double, 1, layout_type::row_major> ten{1., 2., 3.2};
+            xt::xarray<double, layout_type::row_major> arr{1., 2., 3.2};
+        };
+
+        TEST_F(as_strided, array_reference)
+        {
+            EXPECT_LAYOUT(arr, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(arr));
+            EXPECT_XARRAY(arr);
+            EXPECT_EQ(arr(2), 3.2);
+        }
+
+        TEST_F(as_strided, tensor_reference)
+        {
+            EXPECT_LAYOUT(ten, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(ten));
+            EXPECT_XTENSOR(ten);
+            EXPECT_EQ(ten(2), 3.2);
+        }
+
+        TEST_F(as_strided, array_layout_unchanged)
+        {
+            auto res_lvalue = xt::as_strided<layout_type::row_major>(arr);
+            EXPECT_LAYOUT(res_lvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XARRAY(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3.2);
+
+            auto res_rvalue = xt::as_strided<layout_type::row_major>(
+                xt::xarray<double, layout_type::row_major>({1., 2., 3.2})
+            );
+            EXPECT_LAYOUT(res_rvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XARRAY(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3.2);
+        }
+
+        TEST_F(as_strided, tensor_layout_unchanged)
+        {
+            auto res_lvalue = xt::as_strided<layout_type::row_major>(ten);
+            EXPECT_LAYOUT(res_lvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XTENSOR(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3.2);
+
+            auto res_rvalue = xt::as_strided<layout_type::row_major>(
+                xt::xtensor<double, 1, layout_type::row_major>({1., 2., 3.2})
+            );
+            EXPECT_LAYOUT(res_rvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XTENSOR(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3.2);
+        }
+
+        TEST_F(as_strided, array_layout_change)
+        {
+            auto res_lvalue = xt::as_strided<layout_type::column_major>(arr);
+            EXPECT_LAYOUT(res_lvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XARRAY(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3.2);
+
+            auto res_rvalue = xt::as_strided<layout_type::column_major>(
+                xt::xarray<double, layout_type::row_major>({1., 2., 3.2})
+            );
+            EXPECT_LAYOUT(res_rvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XARRAY(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3.2);
+        }
+
+        TEST_F(as_strided, tensor_layout_changed)
+        {
+            auto res_lvalue = xt::as_strided<layout_type::column_major>(ten);
+            EXPECT_LAYOUT(res_lvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XTENSOR(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3.2);
+
+            auto res_rvalue = xt::as_strided<layout_type::column_major>(
+                xt::xtensor<double, 1, layout_type::row_major>({1., 2., 3.2})
+            );
+            EXPECT_LAYOUT(res_rvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XTENSOR(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3.2);
+        }
+
+        TEST_F(as_strided, array_no_data_interface_layout_unchanged)
+        {
+            auto array_cast = xt::cast<int>(arr);
+            EXPECT_FALSE(HAS_DATA_INTERFACE(array_cast));
+            EXPECT_XARRAY(array_cast);
+
+            auto res_lvalue = xt::as_strided<layout_type::row_major>(array_cast);
+            EXPECT_LAYOUT(res_lvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XARRAY(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3);
+
+            auto res_rvalue = xt::as_strided<layout_type::row_major>(xt::cast<int>(arr));
+            EXPECT_LAYOUT(res_rvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XARRAY(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3);
+        }
+
+        TEST_F(as_strided, tensor_no_data_interface_layout_unchanged)
+        {
+            auto tensor_cast = xt::cast<int>(ten);
+            EXPECT_FALSE(HAS_DATA_INTERFACE(tensor_cast));
+            EXPECT_XTENSOR(tensor_cast);
+
+            auto res_lvalue = xt::as_strided<layout_type::row_major>(tensor_cast);
+            EXPECT_LAYOUT(res_lvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XTENSOR(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3);
+
+            auto res_rvalue = xt::as_strided<layout_type::row_major>(xt::cast<int>(ten));
+            EXPECT_LAYOUT(res_rvalue, layout_type::row_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XTENSOR(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3);
+        }
+
+        TEST_F(as_strided, array_no_data_interface_layout_changed)
+        {
+            auto array_cast = xt::cast<int>(arr);
+            EXPECT_FALSE(HAS_DATA_INTERFACE(array_cast));
+            EXPECT_XARRAY(array_cast);
+
+            auto res_lvalue = xt::as_strided<layout_type::column_major>(array_cast);
+            EXPECT_LAYOUT(res_lvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XARRAY(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3);
+
+            auto res_rvalue = xt::as_strided<layout_type::column_major>(xt::cast<int>(arr));
+            EXPECT_LAYOUT(res_rvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XARRAY(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3);
+        }
+
+        TEST_F(as_strided, tensor_no_data_interface_layout_changed)
+        {
+            auto tensor_cast = xt::cast<int>(ten);
+            EXPECT_FALSE(HAS_DATA_INTERFACE(tensor_cast));
+            EXPECT_XTENSOR(tensor_cast);
+
+            auto res_lvalue = xt::as_strided<layout_type::column_major>(tensor_cast);
+            EXPECT_LAYOUT(res_lvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_lvalue));
+            EXPECT_XTENSOR(res_lvalue);
+            EXPECT_EQ(res_lvalue(2), 3);
+
+            auto res_rvalue = xt::as_strided<layout_type::column_major>(xt::cast<int>(ten));
+            EXPECT_LAYOUT(res_rvalue, layout_type::column_major);
+            EXPECT_TRUE(HAS_DATA_INTERFACE(res_rvalue));
+            EXPECT_XTENSOR(res_rvalue);
+            EXPECT_EQ(res_rvalue(2), 3);
+        }
     }
 }
diff --git a/test/test_xexception.cpp b/test/test_xexception.cpp
index fc1f5cde7..cbb3330b9 100644
--- a/test/test_xexception.cpp
+++ b/test/test_xexception.cpp
@@ -1,10 +1,11 @@
 /***************************************************************************
-* Copyright (c) 2017, Ullrich Koethe                                       *
-*                                                                          *
-* Distributed under the terms of the BSD 3-Clause License.                 *
-*                                                                          *
-* The full license is in the file LICENSE, distributed with this software. *
-****************************************************************************/
+ * 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_ENABLE_ASSERT
 #define XTENSOR_ENABLE_ASSERT
@@ -12,17 +13,27 @@
 
 #include <string>
 
-#include "gtest/gtest.h"
-#include "xtensor/xexception.hpp"
+#include "xtensor/utils/xexception.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
+
+    TEST(xexception, macros)
+    {
+        XT_EXPECT_THROW(XTENSOR_ASSERT_MSG(false, "Intentional error"), std::runtime_error);
+        XT_EXPECT_THROW(XTENSOR_PRECONDITION(false, "Intentional error"), std::runtime_error);
+    }
+
+
+#if !defined(XTENSOR_DISABLE_EXCEPTIONS)
     TEST(xexception, assert)
     {
         try
         {
             XTENSOR_ASSERT_MSG(false, "Intentional error");
-            FAIL() << "No exception thrown.";
+            CHECK_MESSAGE(false, "no exception thrown");
         }
         catch (std::runtime_error& e)
         {
@@ -33,7 +44,7 @@ namespace xt
         try
         {
             XTENSOR_PRECONDITION(false, "Intentional error");
-            FAIL() << "No exception thrown.";
+            CHECK_MESSAGE(false, "no exception thrown");
         }
         catch (std::runtime_error& e)
         {
@@ -42,4 +53,6 @@ namespace xt
             EXPECT_TRUE(0 == expected.compare(message.substr(0, expected.size())));
         }
     }
+#endif
+
 }  // namespace xt
diff --git a/test/test_xexpression.cpp b/test/test_xexpression.cpp
index 14b7eef74..75eba3edb 100644
--- a/test/test_xexpression.cpp
+++ b/test/test_xexpression.cpp
@@ -1,31 +1,35 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
+
 #include <sstream>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xexpression.hpp"
-#include "xtensor/xmath.hpp"
-#include "xtensor/xio.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xexpression.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/io/xio.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     auto fun()
     {
-        auto sa = make_xshared(xarray<double>({{1,2,3,4}, {5,6,7,8}}));
+        auto sa = make_xshared(xarray<double>({{1, 2, 3, 4}, {5, 6, 7, 8}}));
         return sa + sa * sa - sa;
     }
 
     TEST(xexpression, shared_basic)
     {
-        xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
-        xarray<double> ca = {{1,2,3,4}, {5,6,7,8}};
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<double> ca = {{1, 2, 3, 4}, {5, 6, 7, 8}};
 
         auto sa = make_xshared(std::move(a));
 
@@ -41,27 +45,59 @@ namespace xt
         EXPECT_EQ(L, XTENSOR_DEFAULT_LAYOUT);
         EXPECT_EQ(contig, true);
 
-        EXPECT_EQ(sa.use_count(), 1);
-        auto cpysa = sa;
         EXPECT_EQ(sa.use_count(), 2);
-        
+        auto cpysa = sa;
+        EXPECT_EQ(sa.use_count(), 3);
+
         std::stringstream buffer;
         buffer << sa;
         EXPECT_EQ(buffer.str(), "{{ 1.,  2.,  3.,  4.},\n { 5.,  6.,  7.,  8.}}");
     }
 
+    TEST(xexpression, shared_iterator)
+    {
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<double> ca = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+
+        auto sa = make_xshared(std::move(a));
+
+        EXPECT_EQ(*(sa.begin()), *(ca.begin()));
+        EXPECT_EQ(*(sa.cbegin()), *(ca.cbegin()));
+        EXPECT_EQ(*(sa.rbegin()), *(ca.rbegin()));
+        EXPECT_EQ(*(sa.crbegin()), *(ca.crbegin()));
+
+        auto it = sa.begin() + 8;
+        EXPECT_EQ(it, sa.end());
+        auto cit = sa.cbegin() + 8;
+        EXPECT_EQ(cit, sa.cend());
+
+        auto rit = sa.rbegin() + 8;
+        EXPECT_EQ(rit, sa.rend());
+        auto crit = sa.crbegin() + 8;
+        EXPECT_EQ(crit, sa.crend());
+    }
+
+    template <class E>
+    auto test_sum(E&& e)
+    {
+        return share(e) + share(e);
+    }
+
     TEST(xexpression, shared_xfunctions)
     {
-        xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
-        xarray<double> ca = {{1,2,3,4}, {5,6,7,8}};
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<double> ca = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<double> acopy(a);
 
         auto sa = make_xshared(std::move(a));
 
         auto expr1 = sa + sa;
         auto expr2 = a + a;
+        auto expr3 = test_sum(std::move(acopy));
 
-        EXPECT_EQ(sa.use_count(), 3);
+        EXPECT_EQ(sa.use_count(), 4);
         EXPECT_TRUE(all(equal(expr1, expr2)));
+        EXPECT_TRUE(all(equal(expr1, expr3)));
         std::stringstream buffer;
         buffer << expr1;
         EXPECT_EQ(buffer.str(), "{{  2.,   4.,   6.,   8.},\n { 10.,  12.,  14.,  16.}}");
@@ -78,7 +114,38 @@ namespace xt
     TEST(xexpression, shared_expr_return)
     {
         auto expr = fun();
-        xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
         EXPECT_EQ(expr, a * a);
     }
+
+    TEST(xexpression, shared_reducer_result)
+    {
+        std::size_t n = 1000;
+        std::size_t m = 9;
+        std::size_t o = 12;
+
+        xtensor<double, 3> tensor = random::rand({n, m, o}, -20., 20.);
+        auto result = make_xshared(sum(tensor, {2}));
+        auto expected = sum(tensor, {2});
+
+        EXPECT_EQ(result.dimension(), std::size_t(2));
+        EXPECT_EQ(result.shape(), expected.shape());
+        EXPECT_TRUE(all(equal(result, expected)));
+    }
+
+    TEST(xexpression, temporary_type)
+    {
+        using dyn_shape = xt::svector<std::size_t, 4, std::allocator<std::size_t>, true>;
+        using dyn_tmp = xt::detail::xtype_for_shape<dyn_shape>::type<int, XTENSOR_DEFAULT_LAYOUT>;
+        using dyn_exp = xt::xarray<int>;
+        constexpr bool dyn_res = std::is_same<dyn_tmp, dyn_exp>::value;
+        EXPECT_TRUE(dyn_res);
+
+        using sta_shape = std::array<std::size_t, 4>;
+        using sta_tmp = xt::detail::xtype_for_shape<sta_shape>::type<int, XTENSOR_DEFAULT_LAYOUT>;
+        using sta_exp = xt::xtensor<int, 4>;
+        constexpr bool sta_res = std::is_same<sta_tmp, sta_exp>::value;
+        EXPECT_TRUE(sta_res);
+    }
+
 }  // namespace xt
diff --git a/test/test_xexpression_holder.cpp b/test/test_xexpression_holder.cpp
index e9431ae2d..cff5d6fb6 100644
--- a/test/test_xexpression_holder.cpp
+++ b/test/test_xexpression_holder.cpp
@@ -1,28 +1,26 @@
 /***************************************************************************
-* Copyright (c) 2017, 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xexpression_holder.hpp"
+#include "xtensor/views/xview.hpp"
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xexpression_holder.hpp"
-
-#include "xtensor/xarray.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xview.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     TEST(xexpression_holder, ctor)
     {
-        xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
-        xarray<double> b = {{3,2,1}, {5,6,7}};
-        xarray<double> c = {{56,5,2}, {4,2,6}};
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<double> b = {{3, 2, 1}, {5, 6, 7}};
+        xarray<double> c = {{56, 5, 2}, {4, 2, 6}};
 
         xexpression_holder holder_a = xexpression_holder(a);
         xexpression_holder holder_b(b);
@@ -31,9 +29,9 @@ namespace xt
 
     TEST(xexpression_holder, assign)
     {
-        xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
-        xarray<double> b = {{3,2,1}, {5,6,7}};
-        xarray<double> c = {{56,5,2}, {4,2,6}};
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<double> b = {{3, 2, 1}, {5, 6, 7}};
+        xarray<double> c = {{56, 5, 2}, {4, 2, 6}};
 
         xexpression_holder holder_a = xexpression_holder(a);
         xexpression_holder holder_b(b);
@@ -44,7 +42,7 @@ namespace xt
 
     TEST(xexpression_holder, to_json)
     {
-        xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
         xexpression_holder holder_a = xexpression_holder(a);
 
         nlohmann::json json_out;
@@ -58,8 +56,8 @@ namespace xt
 
     TEST(xexpression_holder, from_json)
     {
-        xarray<double> a = {{1,2,3,4}, {5,6,7,8}};
-        xarray<double> b = {{5,6,7,8}, {1,2,3,4}};
+        xarray<double> a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        xarray<double> b = {{5, 6, 7, 8}, {1, 2, 3, 4}};
 
         xexpression_holder holder_a = xexpression_holder(a);
 
diff --git a/test/test_xexpression_traits.cpp b/test/test_xexpression_traits.cpp
new file mode 100644
index 000000000..7f485e38b
--- /dev/null
+++ b/test/test_xexpression_traits.cpp
@@ -0,0 +1,51 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    TEST(xexpression_traits, common_tensor_deduction)
+    {
+        xt::xarray<double> a1{0.0, 0.0, 0.0};
+        xt::xtensor<double, 1> a2{0.0, 0.0, 0.0};
+        xt::xtensor_fixed<double, xt::xshape<3>> a3({0.0, 0.0, 0.0});
+
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a1), decltype(a1)>, decltype(a1)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a2), decltype(a2)>, decltype(a2)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a3), decltype(a3)>, decltype(a3)>::value));
+
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a1), decltype(a2)>, decltype(a1)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a1), decltype(a3)>, decltype(a1)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a2), decltype(a3)>, decltype(a2)>::value));
+
+        auto sum1 = a1 + a2;
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a1), decltype(sum1)>, decltype(a1)>::value));
+        auto sum2 = a1 + a3;
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a1), decltype(sum2)>, decltype(a1)>::value));
+        auto sum3 = a2 + a3;
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(a2), decltype(sum3)>, decltype(a2)>::value));
+
+        xt::xarray<double> b1{{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
+        xt::xtensor<double, 2> b2{{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
+        xt::xtensor_fixed<double, xt::xshape<3, 3>> b3({{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}});
+
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(b1), decltype(b1)>, decltype(b1)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(b2), decltype(b2)>, decltype(b2)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(b3), decltype(b3)>, decltype(b3)>::value));
+
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(b1), decltype(b2)>, decltype(b1)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(b1), decltype(b3)>, decltype(b1)>::value));
+        EXPECT_TRUE((std::is_same<xt::common_tensor_type_t<decltype(b2), decltype(b3)>, decltype(b2)>::value));
+    }
+}
diff --git a/test/test_xfft.cpp b/test/test_xfft.cpp
new file mode 100644
index 000000000..a1b050ce4
--- /dev/null
+++ b/test/test_xfft.cpp
@@ -0,0 +1,95 @@
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/misc/xfft.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    TEST(xfft, fft_power_2)
+    {
+        size_t k = 2;
+        size_t n = 8192;
+        size_t A = 10;
+        auto x = xt::linspace<float>(0, static_cast<float>(n - 1), n);
+        xt::xarray<float> y = A * xt::sin(2 * xt::numeric_constants<float>::PI * x * k / n);
+        auto res = xt::fft::fft(y) / (n / 2);
+        REQUIRE(A == doctest::Approx(std::abs(res(k))).epsilon(.0001));
+    }
+
+    TEST(xfft, ifft_power_2)
+    {
+        size_t k = 2;
+        size_t n = 8;
+        size_t A = 10;
+        auto x = xt::linspace<float>(0, static_cast<float>(n - 1), n);
+        xt::xarray<float> y = A * xt::sin(2 * xt::numeric_constants<float>::PI * x * k / n);
+        auto res = xt::fft::ifft(y) / (n / 2);
+        REQUIRE(A == doctest::Approx(std::abs(res(k))).epsilon(.0001));
+    }
+
+    TEST(xfft, scalar_input_throws)
+    {
+        auto scalar = xt::xarray<float>::from_shape({});
+        scalar() = 1.0f;
+
+        XT_EXPECT_THROW(xt::fft::fft(scalar), std::runtime_error);
+        XT_EXPECT_THROW(xt::fft::ifft(scalar), std::runtime_error);
+    }
+
+    TEST(xfft, convolve_power_2)
+    {
+        xt::xarray<float> x = {1.0, 1.0, 1.0, 5.0};
+        xt::xarray<float> y = {5.0, 1.0, 1.0, 1.0};
+        xt::xarray<float> expected = {12, 12, 12, 28};
+
+        auto result = xt::fft::convolve(x, y);
+
+        for (size_t i = 0; i < x.size(); i++)
+        {
+            REQUIRE(expected(i) == doctest::Approx(std::abs(result(i))).epsilon(.0001));
+        }
+    }
+
+    TEST(xfft, fft_n_0_axis)
+    {
+        size_t k = 2;
+        size_t n = 10;
+        size_t A = 1;
+        size_t dim = 10;
+        auto x = xt::linspace<float>(0, n - 1, n) * xt::ones<float>({dim, n});
+        xt::xarray<float> y = A * xt::sin(2 * xt::numeric_constants<float>::PI * x * k / n);
+        y = xt::transpose(y);
+        auto res = xt::fft::fft(y, 0) / (n / 2.0);
+        REQUIRE(A == doctest::Approx(std::abs(res(k, 0))).epsilon(.0001));
+        REQUIRE(A == doctest::Approx(std::abs(res(k, 1))).epsilon(.0001));
+    }
+
+    TEST(xfft, fft_n_1_axis)
+    {
+        size_t k = 2;
+        size_t n = 15;
+        size_t A = 1;
+        size_t dim = 2;
+        auto x = xt::linspace<float>(0, n - 1, n) * xt::ones<float>({dim, n});
+        xt::xarray<float> y = A * xt::sin(2 * xt::numeric_constants<float>::PI * x * k / n);
+        auto res = xt::fft::fft(y) / (n / 2.0);
+        REQUIRE(A == doctest::Approx(std::abs(res(0, k))).epsilon(.0001));
+        REQUIRE(A == doctest::Approx(std::abs(res(1, k))).epsilon(.0001));
+    }
+
+    TEST(xfft, convolve_n)
+    {
+        xt::xarray<float> x = {1.0, 1.0, 1.0, 5.0, 1.0};
+        xt::xarray<float> y = {5.0, 1.0, 1.0, 1.0, 1.0};
+        xt::xarray<size_t> expected = {13, 13, 13, 29, 13};
+
+        auto result = xt::fft::convolve(x, y);
+
+        xt::xarray<float> abs = xt::abs(result);
+
+        for (size_t i = 0; i < abs.size(); i++)
+        {
+            REQUIRE(expected(i) == doctest::Approx(abs(i)).epsilon(.0001));
+        }
+    }
+}
diff --git a/test/test_xfixed.cpp b/test/test_xfixed.cpp
index 7a8208e6a..3a6e8181b 100644
--- a/test/test_xfixed.cpp
+++ b/test/test_xfixed.cpp
@@ -1,23 +1,30 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define VS_SKIP_XFIXED 1
+#endif
 
 // xfixed leads to ICE in debug mode, this provides
 // an easy way to prevent compilation
 #ifndef VS_SKIP_XFIXED
 
-#include "gtest/gtest.h"
+#include "xtensor/containers/xadapt.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/views/xview.hpp"
 
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xadapt.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xmanipulation.hpp"
+#include "test_common_macros.hpp"
 
 // On VS2015, when compiling in x86 mode, alignas(T) leads to C2718
 // when used for a function parameter, even indirectly. This means that
@@ -32,7 +39,7 @@
 // test_fixed removed from MSVC x86 because of recurring ICE.
 // Will be enabled again when the compiler is fixed
 
-#if (_MSC_VER < 1910 && _WIN64) || (_MSC_VER >= 1910 && !defined(DISABLE_VS2017)) || !defined(_MSC_VER)
+#if (_MSC_VER < 1910 && _WIN64) || (_MSC_VER >= 1910) || !defined(_MSC_VER)
 
 namespace xt
 {
@@ -79,19 +86,21 @@ namespace xt
 #endif
 
 #ifdef XTENSOR_ENABLE_ASSERT
-        EXPECT_THROW(a.resize({2, 2}), std::runtime_error);
+        XT_EXPECT_THROW(a.resize({2, 2}), std::runtime_error);
 #endif
         // reshaping fixed container
-        EXPECT_THROW(a.reshape({{1, 9}}), std::runtime_error);
-        EXPECT_NO_THROW(a.reshape({3, 4}));
-        EXPECT_NO_THROW(a.reshape({3, 4}, XTENSOR_DEFAULT_LAYOUT));
-        EXPECT_THROW(a.reshape({3, 4}, layout_type::any), std::runtime_error);
+        XT_EXPECT_THROW(a.reshape({{1, 9}}), std::runtime_error);
+        XT_EXPECT_NO_THROW(a.reshape({3, 4}));
+        XT_EXPECT_NO_THROW(a.reshape({3, 4}, XTENSOR_DEFAULT_LAYOUT));
+        XT_EXPECT_THROW(a.reshape({3, 4}, layout_type::any), std::runtime_error);
     }
 
     TEST(xtensor_fixed, strides)
     {
         xtensor_fixed<double, xshape<3, 7, 2, 5, 3>, layout_type::row_major> arm;
-        xtensor<double, 5, layout_type::row_major> brm = xtensor<double, 5, layout_type::row_major>::from_shape({3, 7, 2, 5, 3});
+        xtensor<double, 5, layout_type::row_major> brm = xtensor<double, 5, layout_type::row_major>::from_shape(
+            {3, 7, 2, 5, 3}
+        );
 
         EXPECT_TRUE(std::equal(arm.strides().begin(), arm.strides().end(), brm.strides().begin()));
         EXPECT_EQ(arm.strides().size(), brm.strides().size());
@@ -100,7 +109,8 @@ namespace xt
         EXPECT_EQ(arm.size(), std::size_t(3 * 7 * 2 * 5 * 3));
 
         xtensor_fixed<double, xshape<3, 7, 2, 5, 3>, layout_type::column_major> acm;
-        xtensor<double, 5, layout_type::column_major> bcm = xtensor<double, 5, layout_type::column_major>::from_shape({3, 7, 2, 5, 3});
+        xtensor<double, 5, layout_type::column_major>
+            bcm = xtensor<double, 5, layout_type::column_major>::from_shape({3, 7, 2, 5, 3});
 
         EXPECT_TRUE(std::equal(acm.strides().begin(), acm.strides().end(), bcm.strides().begin()));
         EXPECT_EQ(acm.strides().size(), bcm.strides().size());
@@ -126,7 +136,8 @@ namespace xt
         EXPECT_EQ(tt1[1], sc2[1]);
         EXPECT_EQ(tt1[2], sc2[2]);
 
-        auto sc3c = get_strides<layout_type::column_major, const_array<ptrdiff_t, 6>>(xshape<3, 1, 3, 2, 1, 3>());
+        auto sc3c = get_strides<layout_type::column_major, const_array<ptrdiff_t, 6>>(xshape<3, 1, 3, 2, 1, 3>()
+        );
         auto sc3r = get_strides<layout_type::row_major, const_array<ptrdiff_t, 6>>(xshape<3, 1, 3, 2, 1, 3>());
         std::vector<std::size_t> ts2({3, 1, 3, 2, 1, 3}), tt2(6);
 
@@ -137,7 +148,8 @@ namespace xt
 
         xtensor_fixed<double, xshape<3, 1, 3, 2, 1, 3>> saxa;
         xtensor<double, 6> saxt(std::array<std::size_t, 6>{3, 1, 3, 2, 1, 3});
-        EXPECT_TRUE(std::equal(saxa.backstrides().begin(), saxa.backstrides().end(), saxt.backstrides().begin()));
+        EXPECT_TRUE(std::equal(saxa.backstrides().begin(), saxa.backstrides().end(), saxt.backstrides().begin())
+        );
     }
 
     TEST(xtensor_fixed, adapt)
@@ -158,6 +170,14 @@ namespace xt
         EXPECT_EQ(a[0], 2);
     }
 
+    TEST(xtensor_fixed, buffer_adaptor)
+    {
+        xtensor_fixed<double, xshape<3>> a;
+        xtensor<double, 2> b = zeros<double>({3, 3});
+        auto c = adapt(&b(0, 0), xshape<3>());
+        c *= a;
+    }
+
     TEST(xtensor_fixed, layout)
     {
         xtensor_fixed<double, xshape<2, 2>, layout_type::row_major> a;
@@ -180,38 +200,38 @@ namespace xt
 
     auto check_shape_a()
     {
-        xtensor_fixed<double, xshape<3, 4>> a = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {9,10,11,12}};
+        xtensor_fixed<double, xshape<3, 4>> a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {9, 10, 11, 12}};
         return a;
     }
 
     auto check_shape_b()
     {
-        xtensor_fixed<double, xshape<3, 4>> a({{1,2}, {5,6,7,8}, {9,10,11,12}});
+        xtensor_fixed<double, xshape<3, 4>> a({{1, 2}, {5, 6, 7, 8}, {9, 10, 11, 12}});
         return a;
     }
 
     auto check_shape_c()
     {
-        xtensor_fixed<double, xshape<3, 4>> a = {{1,2,3}, {5,6,7}, {9,10,11}};
+        xtensor_fixed<double, xshape<3, 4>> a = {{1, 2, 3}, {5, 6, 7}, {9, 10, 11}};
         return a;
     }
 
     TEST(xtensor_fixed, initializer_list_constructor)
     {
         using T = xtensor_fixed<double, xshape<3, 4>>;
-        T a = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
-
-    #ifdef XTENSOR_ENABLE_ASSERT
-        EXPECT_THROW(T{{1}}, std::runtime_error);
-        EXPECT_THROW(check_shape_a(), std::runtime_error);
-        EXPECT_THROW(check_shape_b(), std::runtime_error);
-        EXPECT_THROW(check_shape_c(), std::runtime_error);
-    #endif
+        T a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+
+#ifdef XTENSOR_ENABLE_ASSERT
+        XT_EXPECT_THROW(T{{1}}, std::runtime_error);
+        XT_EXPECT_THROW(check_shape_a(), std::runtime_error);
+        XT_EXPECT_THROW(check_shape_b(), std::runtime_error);
+        XT_EXPECT_THROW(check_shape_c(), std::runtime_error);
+#endif
     }
 
     TEST(xtensor_fixed, transpose)
     {
-        xtensorf3x4 a = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
+        xtensorf3x4 a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
         xtensor_fixed<double, xshape<4, 3>> ta = xt::transpose(a);
         EXPECT_EQ(a(1, 1), ta(1, 1));
         EXPECT_EQ(a(2, 1), ta(1, 2));
@@ -243,7 +263,7 @@ namespace xt
         truth = std::is_same<decltype(e2), xtensor_fixed<double, xshape<3, 4>>>::value;
         EXPECT_TRUE(truth);
 
-        xtensor_fixed<char, xshape<   2, 1, 10, 5>> xa;
+        xtensor_fixed<char, xshape<2, 1, 10, 5>> xa;
         xtensor_fixed<char, xshape<3, 2, 4, 10, 1>> xb;
 
         auto fx1 = xa * xb;
@@ -253,7 +273,7 @@ namespace xt
         truth = std::is_same<typename decltype(fx2)::shape_type, xshape<3, 2, 4, 10, 5>>::value;
         EXPECT_TRUE(truth);
 
-        xtensor_fixed<char, xshape<   2, 1, 10, 5>> xc;
+        xtensor_fixed<char, xshape<2, 1, 10, 5>> xc;
         auto fx3 = xa * xc;
         truth = std::is_same<typename decltype(fx3)::shape_type, xshape<2, 1, 10, 5>>::value;
         EXPECT_TRUE(truth);
@@ -261,17 +281,41 @@ namespace xt
 
     TEST(xtensor_fixed, adaptor_function_assignment)
     {
-        xt::xtensor<double, 4> a_Eps  = xt::zeros<double>({2, 2, 2, 2});
+        xt::xtensor<double, 4> a_Eps = xt::zeros<double>({2, 2, 2, 2});
         xt::xtensor<double, 4> a_Epsd = xt::zeros<double>({2, 2, 2, 2});
         std::size_t e = 0, k = 1;
-        auto Eps  = xt::adapt(&a_Eps (e, k, 0, 0), xt::xshape<2, 2>());
+        auto Eps = xt::adapt(&a_Eps(e, k, 0, 0), xt::xshape<2, 2>());
         auto Epsd = xt::adapt(&a_Epsd(e, k, 0, 0), xt::xshape<2, 2>());
 
         xt::noalias(Eps) = Epsd * 123;
         // Eps = Epsd * 123; <-- Enable after XTL release!
     }
+
+    TEST(xtensor_fixed, print)
+    {
+        xtensor_fixed<char, xshape<2>> a = {0, 1};
+        xtensor_fixed<char, xshape<2>> b = {1, 1};
+
+        std::stringstream out;
+        out << a + b;
+        EXPECT_EQ("{1, 2}", out.str());
+    }
+
+    TEST(xtensor_fixed, nonsharable)
+    {
+        using fixed_tensor = xtensor_fixed<double, xshape<2>, layout_type::row_major, true>;
+        using tiny_tensor = xtensor_fixed<double, xshape<2>, layout_type::row_major, false>;
+        EXPECT_GT(sizeof(fixed_tensor), sizeof(tiny_tensor));
+    }
+
+    TEST(xtensor_fixed, iterators)
+    {
+        auto arr = xt::xtensor<double, 1>({5, 5, 5, 5, 5});
+        auto fixed_arr = xt::xtensor_fixed<double, xt::xshape<3>>{1, 2, 3};
+        xt::view(arr, xt::range(0, 3)) = fixed_arr + 1;
+    }
 }
 
 #endif
 
-#endif // VS_SKIP_XFIXED
+#endif  // VS_SKIP_XFIXED
diff --git a/test/test_xfunc_on_xexpression.cpp b/test/test_xfunc_on_xexpression.cpp
new file mode 100644
index 000000000..55c3ca5fa
--- /dev/null
+++ b/test/test_xfunc_on_xexpression.cpp
@@ -0,0 +1,134 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <cstddef>
+
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xexpression.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
+
+struct field_expression_tag
+{
+};
+
+template <class D>
+class field_expression : public xt::xexpression<D>
+{
+public:
+
+    using expression_tag = field_expression_tag;
+};
+
+template <class F, class... CT>
+class field_function : public field_expression<field_function<F, CT...>>
+{
+public:
+
+    using self_type = field_function<F, CT...>;
+    using functor_type = std::remove_reference_t<F>;
+
+    using expression_tag = field_expression_tag;
+
+    template <class Func, class... CTA, class U = std::enable_if<!std::is_base_of<Func, self_type>::value>>
+    field_function(Func&& f, CTA&&... e) noexcept
+        : m_e(std::forward<CTA>(e)...)
+        , m_f(std::forward<Func>(f))
+    {
+    }
+
+    template <class... T>
+    auto operator()(const std::size_t begin, const std::size_t end) const
+    {
+        return evaluate(std::make_index_sequence<sizeof...(CT)>(), begin, end);
+    }
+
+    template <std::size_t... I, class... T>
+    auto evaluate(std::index_sequence<I...>, T&&... t) const
+    {
+        return m_f(std::get<I>(m_e).operator()(std::forward<T>(t)...)...);
+    }
+
+private:
+
+    std::tuple<CT...> m_e;
+    functor_type m_f;
+};
+
+namespace xt
+{
+    namespace detail
+    {
+        template <class F, class... E>
+        struct select_xfunction_expression<field_expression_tag, F, E...>
+        {
+            using type = field_function<F, E...>;
+        };
+    }
+}
+
+// using xt::operator+;
+// using xt::operator-;
+// using xt::operator*;
+// using xt::operator/;
+// using xt::operator%;
+
+struct Field : public field_expression<Field>
+{
+    Field()
+        : m_data(std::array<std::size_t, 1>{10})
+    {
+    }
+
+    auto operator()(const std::size_t begin, const std::size_t end) const
+    {
+        return xt::view(m_data, xt::range(begin, end));
+    }
+
+    auto operator()(const std::size_t begin, const std::size_t end)
+    {
+        return xt::view(m_data, xt::range(begin, end));
+    }
+
+    template <class E>
+    Field& operator=(const field_expression<E>& e)
+    {
+        (*this)(0, 5) = e.derived_cast()(0, 5);
+        return *this;
+    }
+
+    xt::xtensor<double, 1> m_data;
+};
+
+TEST(xfunc_on_xexpression, field_expression)
+{
+    Field x, y;
+    xt::xtensor<double, 1> res{{20, 20, 20, 20, 20, 0, 0, 0, 0, 0}};
+    x.m_data.fill(10);
+    y.m_data.fill(0);
+
+    y = x + x;
+
+    EXPECT_EQ(y.m_data, res);
+}
+
+TEST(xfunc_on_xexpression, copy_constructor)
+{
+    // Compilation test only
+    // checks that there is no ambiguity among xfunction constructors
+    xt::xtensor<double, 1> x{{1, 2}}, y{{3, 4}};
+    xt::xtensor<double, 1> res{{4, 6}};
+
+    auto expr = x + y;
+    decltype(expr) expr2{expr};
+
+    EXPECT_EQ(xt::eval(expr2), res);
+}
diff --git a/test/test_xfunction.cpp b/test/test_xfunction.cpp
index 369bac472..ddf08758c 100644
--- a/test/test_xfunction.cpp
+++ b/test/test_xfunction.cpp
@@ -1,17 +1,21 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xview.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xvectorize.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/views/xview.hpp"
+
 #include "test_common.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xfixed.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -55,16 +59,16 @@ namespace xt
         }
     }
 
-    template<typename E>
+    template <typename E>
     auto normalize(E&& expr)
     {
-        return E{ expr } / xt::view(xt::sum(E{ expr }, { 1 }), xt::all(), xt::newaxis());
+        return E{expr} / xt::view(xt::sum(E{expr}, {1}), xt::all(), xt::newaxis());
     }
 
     TEST(xfunction, copy_constructor)
     {
-        xt::xarray<double> freqs({ 10, 5 }, 1);
-        xt::xarray<double> other_freqs({ 10, 5 }, 2);
+        xt::xarray<double> freqs({10, 5}, 1);
+        xt::xarray<double> other_freqs({10, 5}, 2);
         // Compilation test
         xarray<double> probs = normalize(freqs + other_freqs);
     }
@@ -74,31 +78,49 @@ namespace xt
         using shape_type = layout_result<>::shape_type;
         xfunction_features f;
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
-            shape_type sh(3, size_t(0));
+            shape_type sh = uninitialized_shape<shape_type>(3);
             bool trivial = (f.m_a + f.m_a).broadcast_shape(sh);
             EXPECT_EQ(sh, f.m_a.shape());
             ASSERT_TRUE(trivial);
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
-            shape_type sh(3, size_t(0));
+            shape_type sh = uninitialized_shape<shape_type>(3);
             bool trivial = (f.m_a + f.m_b).broadcast_shape(sh);
             EXPECT_EQ(sh, f.m_a.shape());
             ASSERT_FALSE(trivial);
         }
 
+        SUBCASE("different dimensions")
         {
-            SCOPED_TRACE("different dimensions");
-            shape_type sh(4, size_t(0));
+            shape_type sh = uninitialized_shape<shape_type>(4);
             bool trivial = (f.m_a + f.m_c).broadcast_shape(sh);
             EXPECT_EQ(sh, f.m_c.shape());
             ASSERT_FALSE(trivial);
         }
     }
 
+    TEST(xfunction, broadcast_shape_exception)
+    {
+        xt::xarray<double> arr1{{1.0, 2.0, 3.0}};
+        xt::xarray<double> arr2{5.0, 6.0, 7.0, 99.0};
+        XT_EXPECT_ANY_THROW(xt::xarray<double> res = arr1 * arr2);
+    }
+
+    TEST(xfunction, shape)
+    {
+        xfunction_features f;
+        auto func = f.m_a + f.m_c;
+        const auto& sh = func.shape();
+        for (std::size_t i = 0; i < sh.size(); ++i)
+        {
+            EXPECT_EQ(sh[i], func.shape(i));
+        }
+    }
+
     TEST(xfunction, layout_type)
     {
         xarray<int, layout_type::dynamic> m_d;
@@ -150,28 +172,43 @@ namespace xt
         size_t j = f.m_a.shape()[1] - 1;
         size_t k = f.m_a.shape()[2] - 1;
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             int a = (f.m_a + f.m_a)(i, j, k);
             int b = f.m_a(i, j, k) + f.m_a(i, j, k);
             EXPECT_EQ(a, b);
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             int a = (f.m_a + f.m_b)(i, j, k);
             int b = f.m_a(i, j, k) + f.m_b(i, 0, k);
             EXPECT_EQ(a, b);
         }
 
+        SUBCASE("different dimensions")
         {
-            SCOPED_TRACE("different dimensions");
             int a = (f.m_a + f.m_c)(1, i, j, k);
             int b = f.m_a(i, j, k) + f.m_c(1, i, j, k);
             EXPECT_EQ(a, b);
         }
     }
 
+    TEST(xfunction, access_dangling_reference)
+    {
+        auto values_original = xt::xtensor<double, 1>{1., 2., 3.};
+        auto indexes = xt::arange<size_t>(values_original.size());
+        auto map = [&](const size_t& index) -> auto&
+        {
+            return values_original[index];
+        };
+        auto values_mapped = xt::vectorize(map)(indexes);
+        for (size_t i = 0; i < values_original.size(); ++i)
+        {
+            EXPECT_TRUE(&(values_mapped[i]) == &(values_original[i]));
+        }
+    }
+
     TEST(xfunction, unchecked)
     {
         xfunction_features f;
@@ -179,15 +216,15 @@ namespace xt
         size_t j = f.m_a.shape()[1] - 1;
         size_t k = f.m_a.shape()[2] - 1;
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             int a = (f.m_a + f.m_a)(i, j, k);
             int b = (f.m_a + f.m_a).unchecked(i, j, k);
             EXPECT_EQ(a, b);
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             int a = (f.m_a + f.m_b)(i, j, k);
             int b = (f.m_a + f.m_b).unchecked(i, j, k);
             EXPECT_EQ(a, b);
@@ -201,31 +238,97 @@ namespace xt
         size_t j = f.m_a.shape()[1] - 1;
         size_t k = f.m_a.shape()[2] - 1;
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             int a = (f.m_a + f.m_a).at(i, j, k);
             int b = f.m_a.at(i, j, k) + f.m_a.at(i, j, k);
             EXPECT_EQ(a, b);
-            EXPECT_ANY_THROW((f.m_a + f.m_a).at(0, 0, 0, 0));
-            EXPECT_ANY_THROW((f.m_a + f.m_a).at(10, 10, 10));
+            XT_EXPECT_ANY_THROW((f.m_a + f.m_a).at(0, 0, 0, 0));
+            XT_EXPECT_ANY_THROW((f.m_a + f.m_a).at(10, 10, 10));
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             int a = (f.m_a + f.m_b).at(i, j, k);
             int b = f.m_a.at(i, j, k) + f.m_b.at(i, 0, k);
             EXPECT_EQ(a, b);
-            EXPECT_ANY_THROW((f.m_a + f.m_a).at(0, 0, 0, 0));
-            EXPECT_ANY_THROW((f.m_a + f.m_a).at(10, 10, 10));
+            XT_EXPECT_ANY_THROW((f.m_a + f.m_a).at(0, 0, 0, 0));
+            XT_EXPECT_ANY_THROW((f.m_a + f.m_a).at(10, 10, 10));
         }
 
+        SUBCASE("different dimensions")
         {
-            SCOPED_TRACE("different dimensions");
             int a = (f.m_a + f.m_c).at(1, i, j, k);
             int b = f.m_a.at(i, j, k) + f.m_c.at(1, i, j, k);
             EXPECT_EQ(a, b);
-            EXPECT_ANY_THROW((f.m_a + f.m_a).at(0, 0, 0, 0, 0));
-            EXPECT_ANY_THROW((f.m_a + f.m_a).at(10, 10, 10, 10));
+            XT_EXPECT_ANY_THROW((f.m_a + f.m_a).at(0, 0, 0, 0, 0));
+            XT_EXPECT_ANY_THROW((f.m_a + f.m_a).at(10, 10, 10, 10));
+        }
+    }
+
+    TEST(xfunction, periodic)
+    {
+        xfunction_features f;
+        size_t i = f.m_a.shape()[0];
+        size_t j = f.m_a.shape()[1];
+        size_t k = f.m_a.shape()[2];
+
+        SUBCASE("same shape")
+        {
+            int a = (f.m_a + f.m_a)(0, 0, 0);
+            int b = (f.m_a + f.m_a).periodic(i, j, k);
+            EXPECT_EQ(a, b);
+        }
+
+        SUBCASE("different shape")
+        {
+            int a = (f.m_a + f.m_b)(0, 0, 0);
+            int b = (f.m_a + f.m_b).periodic(i, j, k);
+            EXPECT_EQ(a, b);
+        }
+    }
+
+    TEST(xfunction, front)
+    {
+        xfunction_features f;
+        int a = (f.m_a + f.m_a).front();
+        int b = f.m_a.front() + f.m_a.front();
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xfunction, back)
+    {
+        xfunction_features f;
+        int a = (f.m_a + f.m_a).back();
+        int b = f.m_a.back() + f.m_a.back();
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xfunction, flat)
+    {
+        xfunction_features f;
+        int a = (f.m_a + f.m_a).flat(0);
+        int b = f.m_a.flat(0) + f.m_a.flat(0);
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xfunction, in_bounds)
+    {
+        xfunction_features f;
+        size_t i = f.m_a.shape()[0];
+        size_t j = f.m_a.shape()[1];
+        size_t k = f.m_a.shape()[2];
+
+        SUBCASE("same shape")
+        {
+            EXPECT_TRUE((f.m_a + f.m_a).in_bounds(0, 0, 0) == true);
+            EXPECT_TRUE((f.m_a + f.m_a).in_bounds(i, j, k) == false);
+        }
+
+        SUBCASE("different shape")
+        {
+            EXPECT_TRUE((f.m_a + f.m_b).in_bounds(0, 0, 0) == true);
+            EXPECT_TRUE((f.m_a + f.m_b).in_bounds(i, j, k) == false);
         }
     }
 
@@ -237,16 +340,16 @@ namespace xt
         index[1] = f.m_a.shape()[1] - 1;
         index[2] = f.m_a.shape()[2] - 1;
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             int a = (f.m_a + f.m_a)[index];
             int b = f.m_a[index] + f.m_a[index];
             EXPECT_EQ(a, b);
             EXPECT_EQ(((f.m_a + f.m_a)[{0, 0, 0}]), (f.m_a[{0, 0, 0}] + f.m_a[{0, 0, 0}]));
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             int a = (f.m_a + f.m_b)[index];
             xindex index2 = index;
             index2[1] = 0;
@@ -255,8 +358,8 @@ namespace xt
             EXPECT_EQ(((f.m_a + f.m_b)[{0, 0, 0}]), (f.m_a[{0, 0, 0}] + f.m_b[{0, 0, 0}]));
         }
 
+        SUBCASE("different dimensions")
         {
-            SCOPED_TRACE("different dimensions");
             xindex index2(f.m_c.dimension());
             index2[0] = 1;
             index2[1] = index[0];
@@ -279,6 +382,7 @@ namespace xt
         for (size_t i = 0; i < nb_iter; ++i)
         {
             ++iter, ++itera, ++iterb;
+            EXPECT_EQ(*iter, *itera + *iterb);
         }
         EXPECT_EQ(*iter, *itera + *iterb);
     }
@@ -287,18 +391,18 @@ namespace xt
     {
         xfunction_features f;
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             test_xfunction_iterator(f.m_a, f.m_a);
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             test_xfunction_iterator(f.m_a, f.m_b);
         }
 
+        SUBCASE("different dimensions")
         {
-            SCOPED_TRACE("different dimensions");
             test_xfunction_iterator(f.m_c, f.m_a);
         }
     }
@@ -320,28 +424,91 @@ namespace xt
     {
         xfunction_features f;
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             test_xfunction_iterator_end(f.m_a, f.m_a);
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             test_xfunction_iterator_end(f.m_a, f.m_b);
         }
 
+        SUBCASE("different dimensions")
         {
-            SCOPED_TRACE("different dimensions");
             test_xfunction_iterator_end(f.m_c, f.m_a);
         }
     }
 
+    template <class F>
+    void iterator_tester(const F& func)
+    {
+        auto res1 = empty_like(func);
+        auto res2 = empty_like(func);
+        auto res3 = empty_like(func);
+        auto res4 = empty_like(func);
+        auto res5 = func;
+
+        auto resit1 = res1.template begin<XTENSOR_DEFAULT_LAYOUT>();
+        for (auto it = func.template begin<XTENSOR_DEFAULT_LAYOUT>();
+             it != func.template end<XTENSOR_DEFAULT_LAYOUT>();
+             ++it)
+        {
+            *(resit1++) = *it;
+        }
+
+        auto resit3 = res3.template rbegin<XTENSOR_DEFAULT_LAYOUT>();
+        for (auto it = func.template rbegin<XTENSOR_DEFAULT_LAYOUT>();
+             it != func.template rend<XTENSOR_DEFAULT_LAYOUT>();
+             ++it)
+        {
+            *(resit3++) = *it;
+        }
+
+        if (func.has_linear_assign(res2.strides()))
+        {
+            auto resit2 = res2.template begin<XTENSOR_DEFAULT_LAYOUT>();
+            for (auto it = func.linear_begin(); it != func.linear_end(); ++it)
+            {
+                *(resit2++) = *it;
+            }
+
+            auto resit4 = res4.template rbegin<XTENSOR_DEFAULT_LAYOUT>();
+            for (auto it = func.linear_rbegin(); it != func.linear_rend(); ++it)
+            {
+                *(resit4++) = *it;
+            }
+
+            EXPECT_TENSOR_EQ(res2, res5);
+            EXPECT_TENSOR_EQ(res4, res5);
+        }
+
+        EXPECT_TENSOR_EQ(res1, res5);
+        EXPECT_TENSOR_EQ(res3, res5);
+        EXPECT_TENSOR_EQ(func, res5);
+    }
+
+    TEST(xfunction, all_iterators)
+    {
+        xt::xarray<double> x = xt::random::rand<double>({5, 5, 5});
+        xt::xarray<double> y = xt::random::rand<double>({5});
+        xt::xarray<double> z = xt::random::rand<double>({5, 5});
+        auto f1 = 2.0 * x;
+        auto f2 = x * 2.0 * x;
+        iterator_tester(f1);
+        iterator_tester(f2);
+        iterator_tester(x * y * 3.0);
+        iterator_tester(5.0 + x * y * 3.0);
+        iterator_tester(x * y * z);
+        iterator_tester(x / y / z);
+    }
+
     TEST(xfunction, xfunction_in_xfunction)
     {
         using Point3 = xt::xtensor_fixed<double, xshape<3>>;
-        Point3 a1({1.,2.,3.});
-        Point3 a2({3.,1.,3.});
-        Point3 a3({54.,5.,5.});
+        Point3 a1({1., 2., 3.});
+        Point3 a2({3., 1., 3.});
+        Point3 a3({54., 5., 5.});
         xtensor<Point3, 1> a({a1, a2, a3});
         xtensor<Point3, 1> c = a + a;
         Point3 r1({2., 4., 6.}), r2({6., 2., 6.}), r3({108., 10., 10.});
diff --git a/test/test_xfunctor_adaptor.cpp b/test/test_xfunctor_adaptor.cpp
new file mode 100644
index 000000000..caa12d34f
--- /dev/null
+++ b/test/test_xfunctor_adaptor.cpp
@@ -0,0 +1,183 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xcomplex.hpp"
+#include "xtensor/views/xfunctor_view.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    using namespace std::complex_literals;
+
+    template <class T>
+    struct nooblean_proxy
+    {
+        nooblean_proxy(T& ref)
+            : m_ref(ref)
+        {
+        }
+
+        operator bool()
+        {
+            return !m_ref;
+        };
+
+        nooblean_proxy& operator=(bool rhs)
+        {
+            m_ref = !rhs;
+            return *this;
+        }
+
+        T& m_ref;
+    };
+
+    template <class T>
+    struct xproxy_inner_types<nooblean_proxy<T>>
+    {
+        // T is used for constness deduction
+        using proxy = nooblean_proxy<T>;
+        using reference = nooblean_proxy<T>;
+        using pointer = nooblean_proxy<T>;
+    };
+
+    struct nooblean
+    {
+        using value_type = bool;
+        using reference = nooblean_proxy<bool>;
+        using const_reference = nooblean_proxy<const bool>;
+        using pointer = bool*;
+        using const_pointer = bool*;
+
+        template <class value_type, class requested_type>
+        using simd_return_type = xt_simd::simd_return_type<value_type, requested_type>;
+
+        const_reference operator()(const bool& in) const
+        {
+            return in;
+        }
+
+        reference operator()(bool& in)
+        {
+            return in;
+        }
+
+        /** cant implement yet -- need to figure out bool loading in xsimd **/
+        // template <class align, class requested_type, std::size_t N, class E>
+        // auto proxy_simd_load(const E& expr, std::size_t n) const
+        // {
+        //     using simd_value_type = xsimd::simd_type<value_type>;
+        //     return !expr.template load_simd<align, requested_type, N>(n);
+        // }
+    };
+
+    TEST(xfunctor_adaptor, basic)
+    {
+        using nooblean_adaptor = xt::xfunctor_adaptor<nooblean, xarray<bool>&>;
+        xarray<bool> vals = {{1, 1, 1, 0, 0}, {1, 0, 1, 0, 1}};
+        xarray<bool> xvals = !vals;
+
+        nooblean_adaptor aptvals(vals);
+        EXPECT_EQ(aptvals, xvals);
+        auto begin = aptvals.linear_begin();
+
+        *begin = true;
+        EXPECT_EQ(bool(*begin), true);
+        EXPECT_EQ(vals(0, 0), false);
+
+        aptvals(0, 0) = false;
+        EXPECT_EQ(vals(0, 0), true);
+        EXPECT_EQ(bool(aptvals(0, 0)), false);
+
+        bool execd = false;
+        if (aptvals(0, 0) == false)
+        {
+            execd = true;
+        }
+        EXPECT_TRUE(execd);
+
+        auto rhs1 = xt::xarray<bool>({true, false, true});
+        aptvals = rhs1;
+        EXPECT_EQ(rhs1, aptvals);
+        EXPECT_EQ(!rhs1, vals);
+    }
+
+    TEST(xfunctor_adaptor, iterator)
+    {
+        using nooblean_adaptor = xt::xfunctor_adaptor<nooblean, xarray<bool>&>;
+        xarray<bool> vals = {{1, 1, 1, 0, 0}, {1, 0, 1, 0, 1}};
+        xarray<bool> xvals = !vals;
+
+        nooblean_adaptor aptvals(vals);
+
+        auto it_adapt = aptvals.begin();
+        auto it_ref = xvals.begin();
+
+        for (; it_adapt != aptvals.end(); ++it_adapt, ++it_ref)
+        {
+            EXPECT_EQ(static_cast<bool>(*it_adapt), *it_ref);
+        }
+    }
+
+    TEST(xfunctor_adaptor, lhs_assignment)
+    {
+        using container_type = xarray<std::complex<double>>;
+
+        container_type e = {{3.0, 1.0 + 1.0i}, {1.0 - 1.0i, 2.0}};
+
+        // Assigning to a xfunctor_adaptor, which has a container semantics, resizes
+        // the underlying container.
+        auto radaptor = xt::xoffset_adaptor<container_type&, double, 0>(e);
+        xt::xtensor<double, 1> rhs = {4.0, 5.0};
+        radaptor = rhs;
+
+        EXPECT_EQ(e.dimension(), 1u);
+        EXPECT_EQ(xtl::real(e(0)), 4.0);
+        EXPECT_EQ(xtl::real(e(1)), 5.0);
+    }
+
+#if defined(XTENSOR_USE_XSIMD) && XSIMD_X86_INSTR_SET >= XSIMD_X86_AVX_VERSION \
+    && XSIMD_X86_INSTR_SET < XSIMD_X86_AVX512_VERSION
+    TEST(xfunctor_adaptor, simd)
+    {
+        // This test fails when the default layour is column_major
+        if (XTENSOR_DEFAULT_LAYOUT == ::xt::layout_type::column_major)
+        {
+            return;
+        }
+
+        xarray<std::complex<double>> e = {{3.0, 1.0 + 1.0i}, {1.0 - 1.0i, 2.0}};
+        auto iview = xt::imag(e);
+        auto loaded_batch = iview.template load_simd<xt_simd::aligned_mode, double, 4>(0);
+        EXPECT_TRUE(xsimd::all(xsimd::batch<double, 4>(0, 1, -1, 0) == loaded_batch));
+        auto newbatch = loaded_batch + 5;
+
+        iview.template store_simd<xt_simd::aligned_mode>(0, newbatch);
+        xarray<std::complex<double>> exp1 = {{3.0 + 5.0i, 1.0 + 6.0i}, {1.0 + 4.0i, 2.0 + 5.0i}};
+        EXPECT_EQ(exp1, e);
+
+        auto rview = xt::real(e);
+        auto loaded_batch2 = rview.template load_simd<xt_simd::aligned_mode, double, 4>(0);
+        EXPECT_TRUE(xsimd::all(xsimd::batch<double, 4>(3, 1, 1, 2) == loaded_batch2));
+        newbatch = loaded_batch2 + 5;
+        rview.template store_simd<xt_simd::aligned_mode>(0, newbatch);
+        xarray<std::complex<double>> exp2 = {{8.0 + 5.0i, 6.0 + 6.0i}, {6.0 + 4.0i, 7.0 + 5.0i}};
+        EXPECT_EQ(exp2, e);
+
+        auto f = xt::sin(xt::imag(e));
+        auto b = f.load_simd<xt_simd::aligned_mode>(0);
+        static_cast<void>(b);
+        using assign_to_view = xassign_traits<decltype(iview), decltype(f)>;
+        EXPECT_TRUE(assign_to_view::simd_linear_assign());
+    }
+#endif
+}
diff --git a/test/test_xhistogram.cpp b/test/test_xhistogram.cpp
index 47da88367..2876f246e 100644
--- a/test/test_xhistogram.cpp
+++ b/test/test_xhistogram.cpp
@@ -1,47 +1,81 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
 #include <complex>
 #include <limits>
 
-#include "gtest/gtest.h"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xhistogram.hpp"
-#include "xtensor/xrandom.hpp"
+// For some obscure reason xtensor.hpp need to be included first for Windows' Clangcl
+#include "xtensor/containers/xtensor.hpp"
+//
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/misc/xhistogram.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     TEST(xhistogram, histogram)
     {
-        xt::xtensor<double,1> data = {1., 1., 2., 2.};
+        xt::xtensor<double, 1> data = {1., 1., 2., 2.};
 
         {
-            xt::xtensor<double,1> count = xt::histogram(data, std::size_t(2));
+            xt::xtensor<double, 1> count = xt::histogram(data, std::size_t(2));
 
-            EXPECT_EQ(count.size(), std::size_t(2) );
-            EXPECT_EQ(count[0]    , 2.);
-            EXPECT_EQ(count[1]    , 2.);
+            EXPECT_EQ(count.size(), std::size_t(2));
+            EXPECT_EQ(count(0), 2.);
+            EXPECT_EQ(count(1), 2.);
         }
 
         {
-            xt::xtensor<double,1> count = xt::histogram(data,
+            xt::xtensor<double, 1> count = xt::histogram(
+                data,
                 xt::histogram_bin_edges(data, std::size_t(2), xt::histogram_algorithm::uniform)
             );
 
             EXPECT_EQ(count.size(), std::size_t(2));
-            EXPECT_EQ(count[0]    , 2.);
-            EXPECT_EQ(count[1]    , 2.);
+            EXPECT_EQ(count(0), 2.);
+            EXPECT_EQ(count(1), 2.);
+        }
+
+        {
+            xt::xtensor<double, 1> count = xt::histogram(data, size_t(2), 0.5, 1.5);
+
+            EXPECT_EQ(count.size(), std::size_t(2));
+            EXPECT_EQ(count(0), 0.);
+            EXPECT_EQ(count(1), 2.);
+        }
+
+        {
+            // test specifying return type as well
+            auto count = xt::histogram<float>(data, size_t(2), xt::xtensor<double, 1>({1., 2., 1., 1.}), 0.5, 1.5);
+
+            EXPECT_EQ(count.size(), std::size_t(2));
+            EXPECT_EQ(count(0), 0.f);
+            EXPECT_EQ(count(1), 3.f);
+            bool is_same_type = std::is_same<decltype(count)::value_type, float>::value;
+            EXPECT_TRUE(is_same_type);
+        }
+
+        {
+            // test input being a container other than xtensor
+            xt::xarray<double> arr = {1., 1., 2., 2.};
+            xt::xtensor<double, 1> count = xt::histogram(arr, std::size_t(2));
+
+            EXPECT_EQ(count.size(), std::size_t(2));
+            EXPECT_EQ(count(0), 2.);
+            EXPECT_EQ(count(1), 2.);
         }
     }
 
     TEST(xhistogram, bincount)
     {
-        xtensor<int, 1> data = {1,2,3,1,1,1,1,2,3,2,3,3,3,3};
+        xtensor<int, 1> data = {1, 2, 3, 1, 1, 1, 1, 2, 3, 2, 3, 3, 3, 3};
         xtensor<int, 1> weights = xt::ones<int>(data.shape()) * 3;
         xtensor<int, 1> expc = {0, 5, 3, 6};
         auto bc = bincount(data);
@@ -54,4 +88,29 @@ namespace xt
         EXPECT_EQ(bc3.size(), std::size_t(10));
         EXPECT_EQ(bc3(3), expc(3));
     }
+
+    TEST(xhistogram, digitize)
+    {
+        xt::xtensor<size_t, 1> bin_edges = {0, 10, 20, 30};
+        xt::xtensor<size_t, 1> data = {1, 12, 2, 21, 11, 10};
+        xt::xtensor<size_t, 1> res_left = {1, 2, 1, 3, 2, 2};
+        xt::xtensor<size_t, 1> res_right = {1, 2, 1, 3, 2, 1};
+        EXPECT_EQ(xt::digitize(data, bin_edges), res_left);
+        EXPECT_EQ(xt::digitize(data, bin_edges, false), res_left);
+        EXPECT_EQ(xt::digitize(data, bin_edges, true), res_right);
+    }
+
+    TEST(xhistogram, bin_items_1)
+    {
+        xt::xtensor<size_t, 1> a = xt::bin_items(11, xt::xtensor<double, 1>{0.9, 0.0, 0.0, 0.1});
+        xt::xtensor<size_t, 1> b = {9, 0, 0, 2};
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xhistogram, bin_items_2)
+    {
+        xt::xtensor<size_t, 1> a = xt::bin_items(11, xt::xtensor<double, 1>{0.25, 0.25, 0.25, 0.25});
+        xt::xtensor<size_t, 1> b = {3, 3, 3, 2};
+        EXPECT_EQ(a, b);
+    }
 }
diff --git a/test/test_xindex_view.cpp b/test/test_xindex_view.cpp
index b55e8faf1..cdf22c1f6 100644
--- a/test/test_xindex_view.cpp
+++ b/test/test_xindex_view.cpp
@@ -1,19 +1,21 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xadapt.hpp"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xindex_view.hpp"
-#include "xtensor/xbroadcast.hpp"
-#include "xtensor/xview.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xadapt.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/views/xbroadcast.hpp"
+#include "xtensor/views/xindex_view.hpp"
+#include "xtensor/views/xview.hpp"
+
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -40,7 +42,7 @@ namespace xt
         EXPECT_EQ(expected, e(1, 1));
 
         auto t = v + 3;
-		EXPECT_DOUBLE_EQ((e_copy(1, 1) + 6), t(0));
+        EXPECT_DOUBLE_EQ((e_copy(1, 1) + 6), t(0));
         EXPECT_EQ((e(1, 1) + 3), t(0));
 
         v = broadcast(123, v.shape());
@@ -54,6 +56,15 @@ namespace xt
         EXPECT_EQ(3, e(2, 2));
     }
 
+    TEST(xindex_view, indices_const)
+    {
+        const xarray<double> e = xt::random::rand<double>({3, 3});
+        auto v = index_view(e, {{1ul, 1ul}, {1ul, 2ul}, {2ul, 2ul}});
+        EXPECT_EQ(e(1, 1), v(0));
+        const auto vc = index_view(e, {{1ul, 1ul}, {1ul, 2ul}, {2ul, 2ul}});
+        EXPECT_EQ(vc(0), v(0));
+    }
+
     TEST(xindex_view, boolean)
     {
         xarray<double> e = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
@@ -76,7 +87,7 @@ namespace xt
 
     TEST(xindex_view, access)
     {
-        xarray<double> e = {{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }};
+        xarray<double> e = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
         auto v = filter(e, e > 0);
         EXPECT_EQ(v(), v(0));
         EXPECT_EQ(v(1, 2, 1), v(1));
@@ -84,8 +95,8 @@ namespace xt
 
     TEST(xindex_view, fill)
     {
-        xarray<double> e = { { 1, 0, 0 },{ 0, 1, 0 },{ 0, 0, 1 } };
-        xarray<double> res = { {1, 2, 2}, {2, 1, 2}, {2, 2, 1} };
+        xarray<double> e = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+        xarray<double> res = {{1, 2, 2}, {2, 1, 2}, {2, 2, 1}};
         auto v = filter(e, e < 1);
         v.fill(2);
         EXPECT_EQ(e, res);
@@ -93,7 +104,7 @@ namespace xt
 
     TEST(xindex_view, unchecked)
     {
-        xarray<double> e = { { 1, 0, 0 },{ 0, 1, 0 },{ 0, 0, 1 } };
+        xarray<double> e = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
         auto v = filter(e, e > 0);
         EXPECT_EQ(v.unchecked(1), v(1));
     }
@@ -146,16 +157,30 @@ namespace xt
 
     TEST(xindex_view, filter)
     {
-        xarray<double> a = {{ 1, 5, 3 },{ 4, 5, 6 }};
-        const xarray<double> b = {{ 1, 5, 3 },{ 4, 5, 6 }};
+        xarray<double> a = {{1, 5, 3}, {4, 5, 6}};
+        const xarray<double> b = {{1, 5, 3}, {4, 5, 6}};
         filter(a, a > 3) += filter(b, b > 3);
-        xarray<double> expected = {{ 1, 10, 3}, {8, 10, 12}};
+        xarray<double> expected = {{1, 10, 3}, {8, 10, 12}};
         EXPECT_EQ(expected, a);
     }
 
+    TEST(xindex_view, filter_column_major)
+    {
+        xarray<int> a = {{{1, 3}, {2, 4}}, {{5, 7}, {6, 8}}};
+        xarray<bool> cond = {{{true, true}, {false, false}}, {{true, true}, {false, false}}};
+
+        xarray<int> resc = xt::filter<xt::layout_type::column_major>(a, cond);
+        xarray<int> expc = {1, 5, 3, 7};
+        EXPECT_EQ(resc, expc);
+
+        xarray<int> resr = xt::filter(a, cond);
+        xarray<int> expr = {1, 3, 5, 7};
+        EXPECT_EQ(resr, expr);
+    }
+
     TEST(xindex_view, const_adapt_filter)
     {
-        const std::vector<double> av({1,2,3,4,5,6});
+        const std::vector<double> av({1, 2, 3, 4, 5, 6});
         auto a = xt::adapt(av, std::array<std::size_t, 2>({3, 2}));
         xt::xarray<double> b = {{1, 2, 3}, {4, 5, 6}};
         xt::filter(b, b > 3) += xt::filter(a, a < 4);
diff --git a/test/test_xinfo.cpp b/test/test_xinfo.cpp
index bc812cc54..c5148c91b 100644
--- a/test/test_xinfo.cpp
+++ b/test/test_xinfo.cpp
@@ -1,34 +1,40 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
 
 #include <sstream>
 #include <string>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xinfo.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/io/xinfo.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     TEST(xinfo, compiles)
     {
-    	xarray<double> test = {{1,2,3}, {4,5,6}};
-    	std::stringstream ss;
+        xarray<double> test = {{1, 2, 3}, {4, 5, 6}};
+        std::stringstream ss;
 
-    	ss << info(test) << std::endl;
+        ss << info(test) << std::endl;
     }
 
+    // See https://github.com/xtensor-stack/xtensor/issues/2694
     TEST(xinfo, typename)
     {
-    	xarray<double> test = {{1,2,3}, {4,5,6}};
-    	auto t_s = type_to_string<typename decltype(test)::value_type>();
-    	std::string expected = "double";
-    	EXPECT_EQ(expected, t_s);
+        xarray<double> test = {{1, 2, 3}, {4, 5, 6}};
+        auto t_s = type_to_string<typename decltype(test)::value_type>();
+        std::string expected = "double";
+#if defined(__clang__)
+        WARN_EQ(expected, t_s);
+#else
+        EXPECT_EQ(expected, t_s);
+#endif
     }
-}
\ No newline at end of file
+}
diff --git a/test/test_xio.cpp b/test/test_xio.cpp
index ebfb911c2..1afb80fab 100644
--- a/test/test_xio.cpp
+++ b/test/test_xio.cpp
@@ -1,30 +1,38 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
-
-#include <vector>
 #include <algorithm>
-#include <sstream>
 #include <limits>
+#include <sstream>
+#include <vector>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xdynamic_view.hpp"
-#include "xtensor/xview.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/views/xdynamic_view.hpp"
+#include "xtensor/views/xview.hpp"
 
 #include "files/xio_expected_results.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
+    TEST(xio, xarray_size_t)
+    {
+        xt::xarray<size_t> e = xt::arange<size_t>(5);
+        std::stringstream out;
+        out << e;
+        EXPECT_EQ("{0, 1, 2, 3, 4}", out.str());
+    }
+
     TEST(xio, xtensor_one_d)
     {
         xtensor<double, 1> e = xt::arange<double>(1, 6);
@@ -43,9 +51,7 @@ namespace xt
 
     TEST(xio, xarray_two_d)
     {
-        xarray<double> e{{1, 2, 3, 4},
-                         {5, 6, 7, 8},
-                         {9, 10, 11, 12}};
+        xarray<double> e{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
         std::stringstream out;
         out << e;
         EXPECT_EQ(twod_double, out.str());
@@ -53,9 +59,7 @@ namespace xt
 
     TEST(xio, view)
     {
-        xarray<double> e{{1, 2, 3, 4},
-                         {5, 6, 7, 8},
-                         {9, 10, 11, 12}};
+        xarray<double> e{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
 
         auto v_1 = view(e, 1, xt::all());
         auto v_2 = view(e, xt::all(), 1);
@@ -83,10 +87,8 @@ namespace xt
 
     TEST(xio, xdynamic_view)
     {
-        xarray<int> e{{1, 2, 3, 4},
-                      {5, 6, 7, 8},
-                      {9, 10, 11, 12}};
-        auto v = xt::dynamic_view(e, { 1, keep(0, 2, 3)});
+        xarray<int> e{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+        auto v = xt::dynamic_view(e, {1, keep(0, 2, 3)});
         std::stringstream out;
         out << v;
         EXPECT_EQ("{5, 7, 8}", out.str());
@@ -99,7 +101,7 @@ namespace xt
         rn(1, 1) = -1;
         rn(1, 2) = +1;
         rn(1, 1) = -1;
-        rn(2, 2) = std::numeric_limits<double>::infinity();  //  inf
+        rn(2, 2) = std::numeric_limits<double>::infinity();   //  inf
         rn(2, 3) = -std::numeric_limits<double>::infinity();  // -inf
         rn(4, 4) = std::nan("xnan");
         std::stringstream out;
@@ -138,7 +140,7 @@ namespace xt
 
         std::stringstream out;
         out << (rn > 0);
-        std::string res = (XTENSOR_DEFAULT_LAYOUT == layout_type::row_major) ? bool_fn_rm : bool_fn_cm;
+        std::string res = bool_fn;
         EXPECT_EQ(res, out.str());
     }
 
@@ -206,11 +208,7 @@ namespace xt
         xt::xarray<double, layout_type::row_major> rn = xt::random::rand<double>({100, 100}, -10, 10);
 
         std::stringstream out;
-        out << po::line_width(150)
-            << po::edge_items(10)
-            << po::precision(10)
-            << po::threshold(100)
-            << rn;
+        out << po::line_width(150) << po::edge_items(10) << po::precision(10) << po::threshold(100) << rn;
 
         EXPECT_EQ(print_options_result, out.str());
 
@@ -222,18 +220,11 @@ namespace xt
 
     TEST(xio, three_d)
     {
-        xarray<double> e{{{1, 2},
-                          {3, 4},
-                          {5, 6},
-                          {7, 8}},
-                         {{9, 10},
-                          {11, 12},
-                          {7, 9},
-                          {11, 14}},
-                         {{5, 26},
-                          {7, 8},
-                          {10, 8},
-                          {4, 3}}};
+        xarray<double> e{
+            {{1, 2}, {3, 4}, {5, 6}, {7, 8}},
+            {{9, 10}, {11, 12}, {7, 9}, {11, 14}},
+            {{5, 26}, {7, 8}, {10, 8}, {4, 3}}
+        };
         std::stringstream out;
         out << e;
         EXPECT_EQ(threed_double, out.str());
@@ -249,7 +240,10 @@ namespace xt
 
     TEST(xio, long_strings)
     {
-        xt::xarray<std::string> e = {{"some", "random very long and very very", "boring"}, {"strings", "in", "xtensor xarray"}};
+        xt::xarray<std::string> e = {
+            {"some", "random very long and very very", "boring"},
+            {"strings", "in", "xtensor xarray"}
+        };
         std::stringstream out;
         out << e;
         EXPECT_EQ(long_strings, out.str());
@@ -292,11 +286,16 @@ namespace xt
         xt::xarray<int> e = {{1, 2, 3, 4}, {100, 200, 1000, 10000000}};
 
         std::stringstream out;
-        pretty_print(e, [](const int& val) {
-            std::stringstream buf;
-            buf << "0x" << std::hex << val;
-            return buf.str();
-        }, out);
+        pretty_print(
+            e,
+            [](const int& val)
+            {
+                std::stringstream buf;
+                buf << "0x" << std::hex << val;
+                return buf.str();
+            },
+            out
+        );
 
         EXPECT_EQ(custom_formatter_result, out.str());
     }
@@ -310,4 +309,15 @@ namespace xt
         std::string exp = "{1, 1, 1, 1, 1}";
         EXPECT_EQ(exp, out.str());
     }
+
+    TEST(xio, flags_reset)
+    {
+        xt::xarray<double> aod = {123400000., 123400000.};
+        std::stringstream out;
+        out << aod;
+        double d = 2.119;
+        out << '\n' << d;
+        std::string exp = "{ 1.234000e+08,  1.234000e+08}\n2.119";
+        EXPECT_EQ(exp, out.str());
+    }
 }
diff --git a/test/test_xiterator.cpp b/test/test_xiterator.cpp
index 38886cd0d..96a2e11d5 100644
--- a/test/test_xiterator.cpp
+++ b/test/test_xiterator.cpp
@@ -1,17 +1,17 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
-
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
 
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -19,13 +19,10 @@ namespace xt
     class xiterator_test : public ::testing::Test
     {
     public:
+
         using result_type = R;
     };
 
-    using testing_types = ::testing::Types<row_major_result<>, column_major_result<>,
-        central_major_result<>, unit_shape_result<>>;
-    TYPED_TEST_CASE(xiterator_test, testing_types);
-
     using std::size_t;
 
     template <layout_type L, class R, class S>
@@ -36,51 +33,30 @@ namespace xt
         vector_type data = result.storage();
         xarray_adaptor<typename R::vector_type, layout_type::dynamic> a(data, result.shape(), result.strides());
 
-        size_type nb_inc = L == layout_type::row_major ?
-            shape.back() * shape[shape.size() - 2] + 1 :
-            shape.front() * shape[1] + 1;
+        auto offset = shape.size() - a.dimension();
+        auto broadcasting_stride = std::accumulate(
+            shape.cbegin(),
+            shape.cbegin() + offset,
+            size_type(1),
+            std::multiplies<size_type>()
+        );
+        size_type nb_inc =
+            (L == layout_type::row_major
+                 ? shape.back() * shape[shape.size() - 2] + 1
+                 : broadcasting_stride * (result.shape().front() * result.shape()[1] + 1));
+
         int expected = a(1, 0, 1);
 
-        auto iter = a.template begin<L>();
-        auto iter2 = a.template begin<L>();
+        auto iter = a.template begin<L>(shape);
+        auto iter2 = a.template begin<L>(shape);
         for (size_type i = 0; i < nb_inc; ++i)
         {
             ++iter;
             iter2++;
         }
 
-        EXPECT_EQ(*iter, expected) << "preincrement operator doesn't give expected result";
-        EXPECT_EQ(*iter2, expected) << "postincrement operator doesn't give expected result";
-    }
-
-    TYPED_TEST(xiterator_test, increment)
-    {
-        typename TestFixture::result_type rm;
-        {
-            SCOPED_TRACE("same shape - row_major iterator");
-            test_increment<layout_type::row_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("broadcasting shape - row_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_increment<layout_type::row_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("same shape - column_major iterator");
-            test_increment<layout_type::column_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("broadcasting shape - column_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_increment<layout_type::column_major>(rm, rm.shape());
-        }
+        CHECK_MESSAGE(*iter == expected, "preincrement operator doesn't give expected result");
+        CHECK_MESSAGE(*iter2 == expected, "postincrement operator doesn't give expected result");
     }
 
     template <layout_type L, class R, class S>
@@ -90,9 +66,19 @@ namespace xt
         using vector_type = typename R::vector_type;
         vector_type data = result.storage();
         xarray_adaptor<typename R::vector_type, layout_type::dynamic> a(data, result.shape(), result.strides());
-        difference_type nb_inc = difference_type(L == layout_type::row_major ?
-            shape.back() * shape[shape.size() - 2] + 1 :
-            shape.front() * shape[1] + 1);
+
+        auto offset = shape.size() - a.dimension();
+        auto broadcasting_stride = std::accumulate(
+            shape.cbegin(),
+            shape.cbegin() + offset,
+            difference_type(1),
+            std::multiplies<difference_type>()
+        );
+        auto nb_inc = L == layout_type::row_major
+                          ? difference_type(shape.back() * shape[shape.size() - 2] + 1)
+                          : broadcasting_stride
+                                * difference_type(result.shape().front() * result.shape()[1] + 1);
+
         int expected = a(1, 0, 1);
 
         auto iter = a.template begin<L>();
@@ -101,91 +87,32 @@ namespace xt
         iter += nb_inc;
         auto iter3 = iter2 + nb_inc;
 
-        EXPECT_EQ(*iter, expected) << "preincrement operator doesn't give expected result";
-        EXPECT_EQ(*iter3, expected) << "postincrement operator doesn't give expected result";
-        EXPECT_EQ(iter2[nb_inc], expected) << "postincrement operator doesn't give expected result";
-    }
-
-    TYPED_TEST(xiterator_test, random_increment)
-    {
-        typename TestFixture::result_type rm;
-        {
-            SCOPED_TRACE("same shape - row_major iterator");
-            test_random_increment<layout_type::row_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("broadcasting shape - row_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_random_increment<layout_type::row_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("same shape - column_major iterator");
-            test_random_increment<layout_type::column_major>(rm, rm.shape());
-        }
 
-        {
-            SCOPED_TRACE("broadcasting shape - column_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_random_increment<layout_type::column_major>(rm, rm.shape());
-        }
+        CHECK_MESSAGE(*iter == expected, "preincrement operator doesn't give expected result");
+        CHECK_MESSAGE(*iter3 == expected, "postincrement operator doesn't give expected result");
+        CHECK_MESSAGE(iter2[nb_inc] == expected, "postincrement operator doesn't give expected result");
     }
 
-    template <layout_type L, class R>
-    void test_end(const R& result)
+    template <layout_type L, class R, class S>
+    void test_end(const R& result, const S& shape)
     {
         using size_type = typename R::size_type;
         using vector_type = typename R::vector_type;
         vector_type data = result.storage();
         xarray_adaptor<typename R::vector_type, layout_type::dynamic> a(data, result.shape(), result.strides());
 
-        size_type size = a.size();
-        auto iter = a.template begin<L>();
-        auto last = a.template end<L>();
+        size_type size = compute_size(shape);
+        auto iter = a.template begin<L>(shape);
+        auto last = a.template end<L>(shape);
         for (size_type i = 0; i < size; ++i)
         {
             ++iter;
         }
 
-        EXPECT_EQ(iter, last) << "iterator doesn't reach the end";
+        CHECK_MESSAGE(iter == last, "iterator doesn't reach the end");
         EXPECT_FALSE(iter < last);
     }
 
-    TYPED_TEST(xiterator_test, end)
-    {
-        typename TestFixture::result_type rm;
-        {
-            SCOPED_TRACE("same shape - row_major iterator");
-            test_end<layout_type::row_major>(rm);
-        }
-
-        {
-            SCOPED_TRACE("broadcasting shape - row_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_end<layout_type::row_major>(rm);
-        }
-
-        {
-            SCOPED_TRACE("same shape - column_major iterator");
-            test_end<layout_type::column_major>(rm);
-        }
-
-        {
-            SCOPED_TRACE("broadcasting shape - column_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_end<layout_type::column_major>(rm);
-        }
-    }
-
     template <layout_type L, class R, class S>
     void test_decrement(const R& result, const S& shape)
     {
@@ -193,50 +120,30 @@ namespace xt
         using vector_type = typename R::vector_type;
         vector_type data = result.storage();
         xarray_adaptor<typename R::vector_type, layout_type::dynamic> a(data, result.shape(), result.strides());
-        size_type nb_inc = L == layout_type::row_major ?
-            shape.back() * shape[shape.size() - 2] + 1 :
-            shape.front() * shape[1] + 1;
+
+        auto offset = shape.size() - a.dimension();
+        auto broadcasting_stride = std::accumulate(
+            shape.cbegin(),
+            shape.cbegin() + offset,
+            size_type(1),
+            std::multiplies<size_type>()
+        );
+        size_type nb_inc =
+            (L == layout_type::row_major
+                 ? shape.back() * shape[shape.size() - 2] + 1
+                 : broadcasting_stride * (result.shape().front() * result.shape()[1] + 1));
+
         int expected = a(1, 1, 2);
 
-        auto iter = a.template rbegin<L>();
-        auto iter2 = a.template rbegin<L>();
+        auto iter = a.template rbegin<L>(shape);
+        auto iter2 = a.template rbegin<L>(shape);
         for (size_type i = 0; i < nb_inc; ++i)
         {
             ++iter;
             iter2++;
         }
-        EXPECT_EQ(*iter, expected) << "predecrement operator doesn't give expected result";
-        EXPECT_EQ(*iter2, expected) << "postdecrement operator doesn't give expected result";
-    }
-
-    TYPED_TEST(xiterator_test, decrement)
-    {
-        typename TestFixture::result_type rm;
-        {
-            SCOPED_TRACE("same shape - row_major iterator");
-            test_decrement<layout_type::row_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("broadcasting shape - row_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_decrement<layout_type::row_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("same shape - column_major iterator");
-            test_decrement<layout_type::column_major>(rm, rm.shape());
-        }
-
-        {
-            SCOPED_TRACE("broadcasting shape - column_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_decrement<layout_type::column_major>(rm, rm.shape());
-        }
+        CHECK_MESSAGE(*iter == expected, "predecrement operator doesn't give expected result");
+        CHECK_MESSAGE(*iter2 == expected, "postdecrement operator doesn't give expected result");
     }
 
     template <layout_type L, class R, class S>
@@ -246,97 +153,248 @@ namespace xt
         using vector_type = typename R::vector_type;
         vector_type data = result.storage();
         xarray_adaptor<typename R::vector_type, layout_type::dynamic> a(data, result.shape(), result.strides());
-        difference_type nb_inc = difference_type(L == layout_type::row_major ?
-            shape.back() * shape[shape.size() - 2] + 1 :
-            shape.front() * shape[1] + 1);
-        int expected = a(1, 1, 2);
 
-        auto iter = a.template rbegin<L>();
-        auto iter2 = a.template rbegin<L>();
+        auto offset = shape.size() - a.dimension();
+        auto broadcasting_stride = std::accumulate(
+            shape.cbegin(),
+            shape.cbegin() + offset,
+            difference_type(1),
+            std::multiplies<difference_type>()
+        );
 
-        iter += nb_inc;
-        auto iter3 = iter2 + nb_inc;
-
-        EXPECT_EQ(*iter, expected) << "predecrement operator doesn't give expected result";
-        EXPECT_EQ(*iter3, expected) << "postdecrement operator doesn't give expected result";
-    }
+        auto nb_inc = L == layout_type::row_major
+                          ? difference_type(shape.back() * shape[shape.size() - 2] + 1)
+                          : broadcasting_stride
+                                * difference_type(result.shape().front() * result.shape()[1] + 1);
 
-    TYPED_TEST(xiterator_test, random_decrement)
-    {
-        typename TestFixture::result_type rm;
-        {
-            SCOPED_TRACE("same shape - row_major iterator");
-            test_random_decrement<layout_type::row_major>(rm, rm.shape());
-        }
+        int expected = a(1, 1, 2);
 
-        {
-            SCOPED_TRACE("broadcasting shape - row_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_random_decrement<layout_type::row_major>(rm, rm.shape());
-        }
+        auto iter = a.template rbegin<L>(shape);
+        auto iter2 = a.template rbegin<L>(shape);
 
-        {
-            SCOPED_TRACE("same shape - column_major iterator");
-            test_random_decrement<layout_type::column_major>(rm, rm.shape());
-        }
+        iter += nb_inc;
+        auto iter3 = iter2 + nb_inc;
 
-        {
-            SCOPED_TRACE("broadcasting shape - column_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_random_decrement<layout_type::column_major>(rm, rm.shape());
-        }
+        CHECK_MESSAGE(*iter == expected, "predecrement operator doesn't give expected result");
+        CHECK_MESSAGE(*iter3 == expected, "postdecrement operator doesn't give expected result");
     }
 
-    template <layout_type L, class R>
-    void test_rend(const R& result)
+    template <layout_type L, class R, class S>
+    void test_rend(const R& result, const S& shape)
     {
         using size_type = typename R::size_type;
         using vector_type = typename R::vector_type;
         vector_type data = result.storage();
         xarray_adaptor<typename R::vector_type, layout_type::dynamic> a(data, result.shape(), result.strides());
 
-        size_type size = a.size();
-        auto iter = a.template rbegin<L>();
-        auto last = a.template rend<L>();
+        size_type size = compute_size(shape);
+        auto iter = a.template rbegin<L>(shape);
+        auto last = a.template rend<L>(shape);
+
+        CHECK_MESSAGE(*iter == data.back(), "dereferencing rbegin does not result in last element");
+        CHECK_MESSAGE(*last == data.front(), "dereferencing rend does not result in first element");
+
         for (size_type i = 0; i < size; ++i)
         {
             ++iter;
         }
 
-        EXPECT_EQ(iter, last) << "reverse iterator doesn't reach the end";
+        CHECK_MESSAGE(iter == last, "reverse iterator doesn't reach the end");
     }
 
-    TYPED_TEST(xiterator_test, reverse_end)
+#define XITERATOR_TEST_TYPES \
+    row_major_result<>, column_major_result<>, central_major_result<>, unit_shape_result<>
+
+    TEST_SUITE("xiterator_test")
     {
-        typename TestFixture::result_type rm;
+        TEST_CASE_TEMPLATE("increment", TypeParam, XITERATOR_TEST_TYPES)
         {
-            SCOPED_TRACE("same shape - row_major iterator");
-            test_rend<layout_type::row_major>(rm);
+            using TestFixture = xiterator_test<TypeParam>;
+            typename TestFixture::result_type rm;
+            SUBCASE("same shape - row_major iterator")
+            {
+                test_increment<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - row_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_increment<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("same shape - column_major iterator")
+            {
+                test_increment<layout_type::column_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - column_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_increment<layout_type::column_major>(rm, rm.shape());
+            }
         }
 
+
+        TEST_CASE_TEMPLATE("random_increment", TypeParam, XITERATOR_TEST_TYPES)
         {
-            SCOPED_TRACE("broadcasting shape - row_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_rend<layout_type::row_major>(rm);
+            using TestFixture = xiterator_test<TypeParam>;
+            typename TestFixture::result_type rm;
+            SUBCASE("same shape - row_major iterator")
+            {
+                test_random_increment<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - row_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_random_increment<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("same shape - column_major iterator")
+            {
+                test_random_increment<layout_type::column_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - column_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_random_increment<layout_type::column_major>(rm, rm.shape());
+            }
         }
 
+
+        TEST_CASE_TEMPLATE("end", TypeParam, XITERATOR_TEST_TYPES)
         {
-            SCOPED_TRACE("same shape - column_major iterator");
-            test_rend<layout_type::column_major>(rm);
+            using TestFixture = xiterator_test<TypeParam>;
+            typename TestFixture::result_type rm;
+            SUBCASE("same shape - row_major iterator")
+            {
+                test_end<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - row_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_end<layout_type::row_major>(rm, sh);
+            }
+
+            SUBCASE("same shape - column_major iterator")
+            {
+                test_end<layout_type::column_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - column_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_end<layout_type::column_major>(rm, sh);
+            }
         }
 
+
+        TEST_CASE_TEMPLATE("decrement", TypeParam, XITERATOR_TEST_TYPES)
         {
-            SCOPED_TRACE("broadcasting shape - column_major iterator");
-            layout_result<>::shape_type sh = rm.shape();
-            sh.insert(sh.begin(), 2);
-            sh.insert(sh.begin(), 4);
-            test_rend<layout_type::column_major>(rm);
+            using TestFixture = xiterator_test<TypeParam>;
+            typename TestFixture::result_type rm;
+            SUBCASE("same shape - row_major iterator")
+            {
+                test_decrement<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - row_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_decrement<layout_type::row_major>(rm, sh);
+            }
+
+            SUBCASE("same shape - column_major iterator")
+            {
+                test_decrement<layout_type::column_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - column_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_decrement<layout_type::column_major>(rm, sh);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("random_decrement", TypeParam, XITERATOR_TEST_TYPES)
+        {
+            using TestFixture = xiterator_test<TypeParam>;
+            typename TestFixture::result_type rm;
+            SUBCASE("same shape - row_major iterator")
+            {
+                test_random_decrement<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - row_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_random_decrement<layout_type::row_major>(rm, sh);
+            }
+
+            SUBCASE("same shape - column_major iterator")
+            {
+                test_random_decrement<layout_type::column_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - column_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_random_decrement<layout_type::column_major>(rm, sh);
+            }
+        }
+
+
+        TEST_CASE_TEMPLATE("reverse_end", TypeParam, XITERATOR_TEST_TYPES)
+        {
+            using TestFixture = xiterator_test<TypeParam>;
+            typename TestFixture::result_type rm;
+            SUBCASE("same shape - row_major iterator")
+            {
+                test_rend<layout_type::row_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - row_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_rend<layout_type::row_major>(rm, sh);
+            }
+
+            SUBCASE("same shape - column_major iterator")
+            {
+                test_rend<layout_type::column_major>(rm, rm.shape());
+            }
+
+            SUBCASE("broadcasting shape - column_major iterator")
+            {
+                layout_result<>::shape_type sh = rm.shape();
+                sh.insert(sh.begin(), 2);
+                sh.insert(sh.begin(), 4);
+                test_rend<layout_type::column_major>(rm, sh);
+            }
         }
     }
 
@@ -348,42 +406,44 @@ namespace xt
         using vector_type = typename R::vector_type;
         vector_type data = result.storage();
         xarray_adaptor<typename R::vector_type, layout_type::dynamic> a(data, result.shape(), result.strides());
-        
+
         size_type size = shape.size();
-        difference_type nb_inc = difference_type(L == layout_type::row_major ?
-            shape.back() * shape[size - 2] + shape.back() + 2 :
-            shape[size - 3] * shape[size - 2] * 2 + shape[size - 3] + 1);
-        difference_type nb_inc2 = difference_type(L == layout_type::row_major ?
-            shape.back() * shape[size - 2] * 2  + 3 :
-            shape[size - 3] * shape[size - 2] * 3 + 2);
+        difference_type nb_inc = difference_type(
+            L == layout_type::row_major ? shape.back() * shape[size - 2] + shape.back() + 2
+                                        : shape[size - 3] * shape[size - 2] * 2 + shape[size - 3] + 1
+        );
+        difference_type nb_inc2 = difference_type(
+            L == layout_type::row_major ? shape.back() * shape[size - 2] * 2 + 3
+                                        : shape[size - 3] * shape[size - 2] * 3 + 2
+        );
 
         ptrdiff_t expected = ptrdiff_t(nb_inc2 - nb_inc);
 
         auto iter = a.template begin<L>() + nb_inc;
         auto iter2 = a.template begin<L>() + nb_inc2;
-        EXPECT_EQ(iter2 - iter, expected) << "operator- doesn't give expected result";
+        CHECK_MESSAGE(iter2 - iter == expected, "operator- doesn't give expected result");
 
         auto riter = a.template rbegin<L>() + nb_inc;
         auto riter2 = a.template rbegin<L>() + nb_inc2;
-        EXPECT_EQ(riter2 - riter, expected) << "operator- doesn't give expected result";
+        CHECK_MESSAGE(riter2 - riter == expected, "operator- doesn't give expected result");
 
         auto diff = a.template end<L>() - a.template begin<L>();
-        EXPECT_EQ(size_type(diff), a.size());
+        CHECK_EQ(size_type(diff), a.size());
 
         auto rdiff = a.template rend<L>() - a.template rbegin<L>();
-        EXPECT_EQ(size_type(rdiff), a.size());
+        CHECK_EQ(size_type(rdiff), a.size());
     }
 
     TEST(xiterator, row_major_minus)
     {
         row_major_result<> rm;
+        SUBCASE("same shape - row_major iterator")
         {
-            SCOPED_TRACE("same shape - row_major iterator");
             test_minus<layout_type::row_major>(rm, rm.shape());
         }
 
+        SUBCASE("broadcasting shape - row_major iterator")
         {
-            SCOPED_TRACE("broadcasting shape - row_major iterator");
             layout_result<>::shape_type sh = rm.shape();
             sh.insert(sh.begin(), 2);
             sh.insert(sh.begin(), 4);
@@ -394,13 +454,13 @@ namespace xt
     TEST(xiterator, column_major_minus)
     {
         column_major_result<> rm;
+        SUBCASE("same shape - column_major iterator")
         {
-            SCOPED_TRACE("same shape - column_major iterator");
             test_minus<layout_type::column_major>(rm, rm.shape());
         }
 
+        SUBCASE("broadcasting shape - column_major iterator")
         {
-            SCOPED_TRACE("broadcasting shape - column_major iterator");
             layout_result<>::shape_type sh = rm.shape();
             sh.insert(sh.begin(), 2);
             sh.insert(sh.begin(), 4);
@@ -410,17 +470,18 @@ namespace xt
 
     TEST(xiterator, broadcast)
     {
-        EXPECT_TRUE(broadcastable(std::vector<size_t>({1, 2, 1}), std::vector<size_t>({ 3, 2, 1 })));
-        EXPECT_TRUE(broadcastable(std::vector<size_t>({1, 1}), std::vector<size_t>({ 3, 2, 1 })));
+        EXPECT_TRUE(broadcastable(std::vector<size_t>({1, 2, 1}), std::vector<size_t>({3, 2, 1})));
+        EXPECT_TRUE(broadcastable(std::vector<size_t>({1, 1}), std::vector<size_t>({3, 2, 1})));
         EXPECT_TRUE(broadcastable(std::vector<size_t>({1, 1}), std::vector<size_t>({2, 2, 1})));
-        EXPECT_FALSE(broadcastable(std::vector<size_t>({2, 2, 1}), std::vector<size_t>({ 3, 2, 1 })));
+        EXPECT_FALSE(broadcastable(std::vector<size_t>({2, 2, 1}), std::vector<size_t>({3, 2, 1})));
     }
 
     TEST(xiterator, pointer)
     {
-        xarray<double> m {{3, 4}, {6, 5}};
-        constexpr layout_type l = xarray<double>::static_layout == layout_type::column_major ?
-            layout_type::row_major : layout_type::column_major;
+        xarray<double> m{{3, 4}, {6, 5}};
+        constexpr layout_type l = xarray<double>::static_layout == layout_type::column_major
+                                      ? layout_type::row_major
+                                      : layout_type::column_major;
         auto it = m.begin<l>();
         EXPECT_EQ(*(it.operator->()), 3);
     }
@@ -467,18 +528,26 @@ namespace xt
         row_major_result<> rm;
         using vector_type = row_major_result<>::vector_type;
         xarray_adaptor<vector_type, layout_type::dynamic> a(rm.storage(), rm.shape(), rm.strides());
-        
+
+        SUBCASE("row_major iterator")
         {
-            SCOPED_TRACE("row_major iterator");
             xarray<vector_type::value_type> dst(a.shape(), 1);
-            std::copy(a.cbegin<layout_type::row_major>(), a.cend<layout_type::row_major>(), dst.begin<layout_type::row_major>());
+            std::copy(
+                a.cbegin<layout_type::row_major>(),
+                a.cend<layout_type::row_major>(),
+                dst.begin<layout_type::row_major>()
+            );
             EXPECT_EQ(a, dst);
         }
 
+        SUBCASE("column_major iterator")
         {
-            SCOPED_TRACE("column_major iterator");
             xarray<vector_type::value_type> dst(a.shape(), 1);
-            std::copy(a.cbegin<layout_type::column_major>(), a.cend<layout_type::column_major>(), dst.begin<layout_type::column_major>());
+            std::copy(
+                a.cbegin<layout_type::column_major>(),
+                a.cend<layout_type::column_major>(),
+                dst.begin<layout_type::column_major>()
+            );
             EXPECT_EQ(a, dst);
         }
     }
@@ -489,26 +558,32 @@ namespace xt
         using vector_type = row_major_result<>::vector_type;
         xarray_adaptor<vector_type, layout_type::dynamic> a(rm.storage(), rm.shape(), rm.strides());
 
+        SUBCASE("row_major iterator")
         {
-            SCOPED_TRACE("row_major iterator");
             xarray<vector_type::value_type> dst(a.shape(), 1);
-            std::copy(a.crbegin<layout_type::row_major>(), a.crend<layout_type::row_major>(), dst.rbegin<layout_type::row_major>());
+            std::copy(
+                a.crbegin<layout_type::row_major>(),
+                a.crend<layout_type::row_major>(),
+                dst.rbegin<layout_type::row_major>()
+            );
             EXPECT_EQ(a, dst);
         }
 
+        SUBCASE("column_major iterator")
         {
-            SCOPED_TRACE("column_major iterator");
             xarray<vector_type::value_type> dst(a.shape(), 1);
-            std::copy(a.crbegin<layout_type::column_major>(), a.crend<layout_type::column_major>(), dst.rbegin<layout_type::column_major>());
+            std::copy(
+                a.crbegin<layout_type::column_major>(),
+                a.crend<layout_type::column_major>(),
+                dst.rbegin<layout_type::column_major>()
+            );
             EXPECT_EQ(a, dst);
         }
     }
 
     TEST(xiterator, reverse_corner_cases)
     {
-        xtensor<double, 3> a = {{{13, 16},
-                                 {13, 16},
-                                 {13, 16}}};
+        xtensor<double, 3> a = {{{13, 16}, {13, 16}, {13, 16}}};
 
         constexpr auto cm = layout_type::column_major;
         constexpr auto rm = layout_type::row_major;
@@ -555,14 +630,9 @@ namespace xt
             }
         }
 
-        xtensor<double, 3> b = {{{1},
-                                 {1}},
-                                {{2},
-                                 {2}},
-                                {{3},
-                                 {3}}};
+        xtensor<double, 3> b = {{{1}, {1}}, {{2}, {2}}, {{3}, {3}}};
 
-       {
+        {
             std::vector<double> exp_iter = {3, 2, 1, 3, 2, 1};
             auto e_iter = exp_iter.begin();
             for (auto it = b.template rbegin<cm>(); it != b.template rend<cm>(); ++it)
@@ -571,9 +641,9 @@ namespace xt
                 ++e_iter;
             }
             EXPECT_TRUE(e_iter == exp_iter.end());
-       }
+        }
 
-       {
+        {
             std::vector<double> exp_iter = {3, 3, 2, 2, 1, 1};
             auto e_iter = exp_iter.begin();
             for (auto it = b.template rbegin<rm>(); it != b.template rend<rm>(); ++it)
@@ -582,9 +652,9 @@ namespace xt
                 ++e_iter;
             }
             EXPECT_TRUE(e_iter == exp_iter.end());
-       }
+        }
 
-       {
+        {
             std::vector<double> exp_iter = {1, 1, 2, 2, 3, 3};
             auto e_iter = exp_iter.begin();
             for (auto it = b.template begin<rm>(); it != b.template end<rm>(); ++it)
@@ -593,9 +663,9 @@ namespace xt
                 ++e_iter;
             }
             EXPECT_TRUE(e_iter == exp_iter.end());
-       }
+        }
 
-       {
+        {
             std::vector<double> exp_iter = {1, 2, 3, 1, 2, 3};
             auto e_iter = exp_iter.begin();
             for (auto it = b.template begin<cm>(); it != b.template end<cm>(); ++it)
@@ -604,6 +674,6 @@ namespace xt
                 ++e_iter;
             }
             EXPECT_TRUE(e_iter == exp_iter.end());
-       }
+        }
     }
 }
diff --git a/test/test_xjson.cpp b/test/test_xjson.cpp
index d9f545331..b34ffc38b 100644
--- a/test/test_xjson.cpp
+++ b/test/test_xjson.cpp
@@ -1,29 +1,26 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
 
 #include <string>
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xjson.hpp"
-#include "xtensor/xview.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/io/xjson.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     TEST(xjson, xarray_to_json)
     {
-        xt::xarray<double> t =
-          {{{1, 2},
-            {3, 4}},
-           {{1, 2},
-            {3, 4}}};
+        xt::xarray<double> t = {{{1, 2}, {3, 4}}, {{1, 2}, {3, 4}}};
 
         nlohmann::json jl = t;
         std::string s = jl.dump();
@@ -34,31 +31,19 @@ namespace xt
     {
         nlohmann::json j = "[[[1.0,2.0],[3.0,4.0]],[[1.0,2.0],[3.0,4.0]]]"_json;
         auto arr = j.get<xt::xarray<double>>();
-        auto ref = xt::xarray<double>(
-          {{{1, 2},
-            {3, 4}},
-           {{1, 2},
-            {3, 4}}});
+        auto ref = xt::xarray<double>({{{1, 2}, {3, 4}}, {{1, 2}, {3, 4}}});
         EXPECT_TRUE(all(equal(arr, ref)));
     }
 
     TEST(xjson, xview_from_json)
     {
-        xt::xarray<double> arr =
-          {{{1, 2},
-            {3, 4}},
-           {{1, 2},
-            {3, 4}}};
+        xt::xarray<double> arr = {{{1, 2}, {3, 4}}, {{1, 2}, {3, 4}}};
 
         auto v = xt::view(arr, 0);
         auto j = "[[10.0,10.0],[10.0,10.0]]"_json;
         from_json(j, v);
 
-        auto ref = xt::xarray<double>(
-          {{{10, 10},
-            {10, 10}},
-           {{1, 2},
-            {3, 4}}});
+        auto ref = xt::xarray<double>({{{10, 10}, {10, 10}}, {{1, 2}, {3, 4}}});
         EXPECT_TRUE(all(equal(arr, ref)));
     }
 }
diff --git a/test/test_xlayout.cpp b/test/test_xlayout.cpp
index 4b10f2db1..76c49bb2b 100644
--- a/test/test_xlayout.cpp
+++ b/test/test_xlayout.cpp
@@ -1,19 +1,21 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xview.hpp"
-#include "xtensor/xmath.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/views/xview.hpp"
+
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
diff --git a/test/test_xmanipulation.cpp b/test/test_xmanipulation.cpp
index 61eedd148..bbc2663a2 100644
--- a/test/test_xmanipulation.cpp
+++ b/test/test_xmanipulation.cpp
@@ -1,22 +1,25 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
-
-#include "gtest/gtest.h"
-
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xmanipulation.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
-    TEST(xstrided_view, transpose_assignment)
+    TEST(xmanipulation, transpose_assignment)
     {
         xarray<double> e = xt::arange<double>(24);
         e.resize({2, 2, 6});
@@ -26,11 +29,11 @@ namespace xt
         EXPECT_EQ(123, e(1, 0, 0));
         auto val = vt[{1, 0, 1}];
         EXPECT_EQ(e(1, 0, 1), val);
-        EXPECT_ANY_THROW(vt.at(10, 10, 10));
-        EXPECT_ANY_THROW(vt.at(0, 0, 0, 0));
+        XT_EXPECT_ANY_THROW(vt.at(10, 10, 10));
+        XT_EXPECT_ANY_THROW(vt.at(0, 0, 0, 0));
     }
 
-    TEST(xstrided_view, transpose_layout_swap)
+    TEST(xmanipulation, transpose_layout_swap)
     {
         xarray<double, layout_type::row_major> a = xt::ones<double>({5, 5});
 
@@ -44,7 +47,7 @@ namespace xt
         auto cbt = transpose(b);
         EXPECT_EQ(cbt.layout(), layout_type::row_major);
 
-        auto cbw1 = transpose(b, {0, 1 ,2});
+        auto cbw1 = transpose(b, {0, 1, 2});
         auto cbw2 = transpose(b, {2, 1, 0});
         auto cbw3 = transpose(b, {2, 0, 1});
         EXPECT_EQ(cbw1.layout(), layout_type::column_major);
@@ -52,10 +55,10 @@ namespace xt
         EXPECT_EQ(cbw3.layout(), layout_type::dynamic);
     }
 
-    TEST(xstrided_view, transpose_function)
+    TEST(xmanipulation, transpose_function)
     {
-        xarray<int, layout_type::row_major> a = { { 0, 1, 2 }, { 3, 4, 5 } };
-        xarray<int, layout_type::row_major> b = { { 0, 1, 2 }, { 3, 4, 5 } };
+        xarray<int, layout_type::row_major> a = {{0, 1, 2}, {3, 4, 5}};
+        xarray<int, layout_type::row_major> b = {{0, 1, 2}, {3, 4, 5}};
         auto fun = a + b;
         auto tr = transpose(fun);
         EXPECT_EQ(fun(0, 0), tr(0, 0));
@@ -65,8 +68,8 @@ namespace xt
         EXPECT_EQ(fun(1, 1), tr(1, 1));
         EXPECT_EQ(fun(1, 2), tr(2, 1));
 
-        xarray<int, layout_type::column_major> a2 = { { 0, 1, 2 },{ 3, 4, 5 } };
-        xarray<int, layout_type::column_major> b2 = { { 0, 1, 2 },{ 3, 4, 5 } };
+        xarray<int, layout_type::column_major> a2 = {{0, 1, 2}, {3, 4, 5}};
+        xarray<int, layout_type::column_major> b2 = {{0, 1, 2}, {3, 4, 5}};
         auto fun2 = a2 + b2;
         auto tr2 = transpose(fun2);
         EXPECT_EQ(fun2(0, 0), tr2(0, 0));
@@ -77,9 +80,42 @@ namespace xt
         EXPECT_EQ(fun2(1, 2), tr2(2, 1));
     }
 
-    TEST(xstrided_view, ravel)
+    TEST(xmanipulation, swapaxes)
     {
-        xarray<int, layout_type::row_major> a = { { 0, 1, 2 },{ 3, 4, 5 } };
+        const auto a = xarray<double>::from_shape({1, 2, 3, 4, 5});
+        using shape_type = decltype(a)::shape_type;
+
+        EXPECT_EQ(swapaxes(a, 0, 1).shape(), (shape_type{2, 1, 3, 4, 5}));
+        EXPECT_EQ(swapaxes(a, 1, 3).shape(), (shape_type{1, 4, 3, 2, 5}));
+        EXPECT_EQ(swapaxes(a, 1, -1).shape(), (shape_type{1, 5, 3, 4, 2}));
+        // Symetry
+        EXPECT_EQ(swapaxes(a, 0, 1).shape(), swapaxes(a, 1, 0).shape());
+        EXPECT_EQ(swapaxes(a, 1, 4).shape(), swapaxes(a, 4, 1).shape());
+        EXPECT_EQ(swapaxes(a, -1, 0).shape(), swapaxes(a, 0, -1).shape());
+        // No Op
+        EXPECT_EQ(swapaxes(a, 0, 0).shape(), a.shape());
+        EXPECT_EQ(swapaxes(a, -1, -1).shape(), a.shape());
+    }
+
+    TEST(xmanipulation, moveaxis)
+    {
+        const auto a = xarray<double>::from_shape({1, 2, 3, 4, 5});
+        using shape_type = decltype(a)::shape_type;
+
+        EXPECT_EQ(moveaxis(a, 0, 1).shape(), (shape_type{2, 1, 3, 4, 5}));
+        EXPECT_EQ(moveaxis(a, 1, 0).shape(), (shape_type{2, 1, 3, 4, 5}));
+        EXPECT_EQ(moveaxis(a, 1, 3).shape(), (shape_type{1, 3, 4, 2, 5}));
+        EXPECT_EQ(moveaxis(a, 3, 1).shape(), (shape_type{1, 4, 2, 3, 5}));
+        EXPECT_EQ(moveaxis(a, 1, -1).shape(), (shape_type{1, 3, 4, 5, 2}));
+        EXPECT_EQ(moveaxis(a, -1, 1).shape(), (shape_type{1, 5, 2, 3, 4}));
+        // No Op
+        EXPECT_EQ(moveaxis(a, 0, 0).shape(), a.shape());
+        EXPECT_EQ(moveaxis(a, -1, -1).shape(), a.shape());
+    }
+
+    TEST(xmanipulation, ravel)
+    {
+        xarray<int, layout_type::row_major> a = {{0, 1, 2}, {3, 4, 5}};
 
         auto flat = ravel<layout_type::row_major>(a);
         EXPECT_EQ(flat(0), a(0, 0));
@@ -99,9 +135,107 @@ namespace xt
 
         auto flat2 = flatten(a);
         EXPECT_EQ(flat, flat2);
+
+        auto flat3 = ravel(a);
+        EXPECT_EQ(flat, flat3);
+    }
+
+    TEST(xmanipulation, flatten)
+    {
+        xtensor<double, 3> a = linspace<double>(1., 100., 100).reshape({2, 5, 10});
+        auto v = view(a, range(0, 2), range(0, 3), range(0, 3));
+        xtensor<double, 1> fl = flatten<XTENSOR_DEFAULT_TRAVERSAL>(v);
+        xtensor<double, 1> expected_rm =
+            {1., 2., 3., 11., 12., 13., 21., 22., 23., 51., 52., 53, 61., 62., 63., 71., 72., 73.};
+        xtensor<double, 1> expected_cm =
+            {1., 2., 3., 4., 5., 6., 11., 12., 13., 14., 15., 16., 21., 22., 23., 24., 25., 26.};
+        xtensor<double, 1> expected = XTENSOR_DEFAULT_TRAVERSAL == layout_type::row_major ? expected_rm
+                                                                                          : expected_cm;
+        EXPECT_EQ(fl, expected);
+        auto v2 = strided_view(a, {range(0, 2), range(0, 3), range(0, 3)});
+        xtensor<double, 1> fl2 = flatten<XTENSOR_DEFAULT_TRAVERSAL>(v2);
+        EXPECT_EQ(fl2, expected);
+
+        xt::xarray<float> af = xt::arange<float>(100., 127.).reshape({3, 3, 3});
+        auto view = xt::flatten(xt::view(af, xt::range(1, 3), xt::range(1, 3), xt::range(1, 3)));
+        auto iter = view.begin();
+        EXPECT_EQ(*iter++, 113);
+        EXPECT_EQ(*iter++, 114);
+        EXPECT_EQ(*iter++, 116);
+        EXPECT_EQ(*iter++, 117);
+        EXPECT_EQ(*iter++, 122);
+        EXPECT_EQ(*iter++, 123);
+        EXPECT_EQ(*iter++, 125);
+        EXPECT_EQ(*iter++, 126);
+        EXPECT_EQ(iter, view.end());
+    }
+
+    TEST(xmanipulation, flatten_generator)
+    {
+        // Compilation test
+        xt::xtensor<double, 1> y = xt::flatten(xt::random::randint({100, 1}, 1, 100));
+    }
+
+    TEST(xmanipulation, flatten_simd_linear_assign_trait)
+    {
+        xtensor<double, 3> a = linspace<double>(1., 100., 100).reshape({2, 5, 10});
+        auto v = view(a, range(0, 2), range(0, 3), range(0, 3));
+
+        {
+            auto e = flatten<XTENSOR_DEFAULT_LAYOUT>(a);
+            xtensor<double, 1> fl = e;
+            using assign_traits = xassign_traits<decltype(fl), decltype(e)>;
+
+#if XTENSOR_USE_XSIMD
+            EXPECT_TRUE(assign_traits::simd_linear_assign());
+            EXPECT_TRUE(assign_traits::simd_linear_assign(fl, e));
+#else
+            EXPECT_FALSE(assign_traits::simd_linear_assign());
+            EXPECT_FALSE(assign_traits::simd_linear_assign(fl, e));
+#endif
+        }
+
+        {
+            auto e = flatten<XTENSOR_DEFAULT_LAYOUT>(v);
+            xtensor<double, 1> fl = e;
+            using assign_traits = xassign_traits<decltype(fl), decltype(e)>;
+            EXPECT_FALSE(assign_traits::simd_linear_assign());
+            EXPECT_FALSE(assign_traits::simd_linear_assign(fl, e));
+        }
     }
 
-    TEST(xstrided_view, split)
+    TEST(xmanipulation, flatten_assign)
+    {
+        xt::xarray<int> patch = xt::zeros<int>({2, 8});
+        xt::xarray<int> seq_r = xt::zeros<int>({16});
+        seq_r[0] = 1;
+        seq_r[1] = 2;
+        seq_r[2] = 3;
+        seq_r[3] = 4;
+        xt::flatten(xt::view(patch, xt::all(), xt::range(0, 2))) = xt::view(seq_r, xt::range(0, 4));
+        EXPECT_EQ(patch(0, 0), 1);
+        EXPECT_EQ(patch(0, 1), 2);
+        EXPECT_EQ(patch(1, 0), 3);
+        EXPECT_EQ(patch(1, 1), 4);
+        for (size_t i = 2; i < 8; ++i)
+        {
+            EXPECT_EQ(patch(0, i), 0);
+            EXPECT_EQ(patch(1, i), 0);
+        }
+    }
+
+    TEST(xmanipulation, flatnonzero)
+    {
+        xt::xtensor<int, 1> a = arange(-2, 3);
+        std::vector<std::size_t> expected_a = {0, 1, 3, 4};
+        EXPECT_EQ(expected_a, flatnonzero<layout_type::row_major>(a));
+
+        xt::xarray<int> b = arange(-2, 3);
+        std::vector<std::size_t> expected_b = {0, 1, 3, 4};
+        EXPECT_EQ(expected_b, flatnonzero<layout_type::row_major>(b));
+    }
+
+    TEST(xmanipulation, split)
     {
         auto b = xt::xarray<double>::from_shape({3, 3, 3});
         using ds = xt::dynamic_shape<std::size_t>;
@@ -113,8 +247,8 @@ namespace xt
         EXPECT_EQ(s1[1](0, 0), b(1, 0, 0));
         EXPECT_EQ(s1[2](0, 0), b(2, 0, 0));
 
-        EXPECT_THROW(split(b, 4), std::runtime_error);
-        EXPECT_THROW(split(b, 2), std::runtime_error);
+        XT_EXPECT_THROW(split(b, 4), std::runtime_error);
+        XT_EXPECT_THROW(split(b, 2), std::runtime_error);
 
         auto s2 = split(b, 1);
         EXPECT_EQ(s2.size(), 1u);
@@ -129,7 +263,23 @@ namespace xt
         EXPECT_EQ(s3[2](0, 1), b(0, 2, 1));
     }
 
-    TEST(xstrided_view, squeeze)
+    TEST(xmanipulation, hsplit)
+    {
+        xt::xarray<int> a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+        auto res = xt::hsplit(a, 2);
+        auto e = xt::split(a, 2, 1);
+        EXPECT_EQ(e, res);
+    }
+
+    TEST(xmanipulation, vsplit)
+    {
+        xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};
+        auto res = xt::vsplit(a, 2);
+        auto e = xt::split(a, 2, 0);
+        EXPECT_EQ(e, res);
+    }
+
+    TEST(xmanipulation, squeeze)
     {
         auto b = xt::xarray<double>::from_shape({3, 3, 1, 1, 2, 1, 3});
         std::iota(b.begin(), b.end(), 0);
@@ -138,8 +288,8 @@ namespace xt
 
         EXPECT_EQ(sq.shape(), ds({3, 3, 2, 3}));
         EXPECT_EQ(sq(1, 1, 1, 1), b(1, 1, 0, 0, 1, 0, 1));
-        EXPECT_THROW(squeeze(b, 1, check_policy::full()), std::runtime_error);
-        EXPECT_THROW(squeeze(b, 10, check_policy::full()), std::runtime_error);
+        XT_EXPECT_THROW(squeeze(b, 1, check_policy::full()), std::runtime_error);
+        XT_EXPECT_THROW(squeeze(b, 10, check_policy::full()), std::runtime_error);
 
         auto sq2 = squeeze(b, {2, 3}, check_policy::full());
         EXPECT_EQ(sq2.shape(), ds({3, 3, 2, 1, 3}));
@@ -150,7 +300,7 @@ namespace xt
         EXPECT_EQ(sq3(2, 2, 0, 1, 0, 2), b(2, 2, 0, 0, 1, 0, 2));
     }
 
-    TEST(xstrided_view, expand_dims)
+    TEST(xmanipulation, expand_dims)
     {
         auto b = xt::xarray<double>::from_shape({3, 3});
         std::iota(b.begin(), b.end(), 0);
@@ -166,7 +316,7 @@ namespace xt
         EXPECT_EQ(ex1(2, 0, 1), b(2, 1));
     }
 
-    TEST(xstrided_view, atleast_nd)
+    TEST(xmanipulation, atleast_nd)
     {
         xt::xarray<char> d0 = 123;
         auto d1 = xt::xarray<char>::from_shape({3});
@@ -196,7 +346,7 @@ namespace xt
         EXPECT_EQ(d2d1.shape(), ds({1, 3}));
     }
 
-    TEST(xstrided_view, trim_zeros)
+    TEST(xmanipulation, trim_zeros)
     {
         using arr_t = xarray<int>;
         arr_t a = {0, 0, 0, 1, 3, 0};
@@ -232,7 +382,7 @@ namespace xt
         EXPECT_EQ(trim_zeros(d, "b"), edb);
     }
 
-    TEST(xstrided_view, flipud)
+    TEST(xmanipulation, flipud)
     {
         xarray<double> e = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
         xarray<double> t = xt::flip(e, 0);
@@ -247,14 +397,11 @@ namespace xt
         xarray<double> f = {{{0, 1, 2}, {3, 4, 5}}, {{6, 7, 8}, {9, 10, 11}}};
 
         xarray<double> ft = xt::flip(f, 0);
-        xarray<double> expected_2 = {{{6, 7, 8},
-        {9, 10, 11}},
-        {{0, 1, 2},
-        {3, 4, 5}}};
+        xarray<double> expected_2 = {{{6, 7, 8}, {9, 10, 11}}, {{0, 1, 2}, {3, 4, 5}}};
         ASSERT_EQ(expected_2, ft);
     }
 
-    TEST(xstrided_view, fliplr)
+    TEST(xmanipulation, fliplr)
     {
         xarray<double> e = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
         xarray<double> t = xt::flip(e, 1);
@@ -269,29 +416,41 @@ namespace xt
         xarray<double> f = {{{0, 1, 2}, {3, 4, 5}}, {{6, 7, 8}, {9, 10, 11}}};
 
         xarray<double> ft = xt::flip(f, 1);
-        xarray<double> expected_2 = {
-            {{3, 4, 5},
-            {0, 1, 2}},
-            {{9, 10, 11},
-            {6, 7, 8}}};
+        xarray<double> expected_2 = {{{3, 4, 5}, {0, 1, 2}}, {{9, 10, 11}, {6, 7, 8}}};
 
         ASSERT_EQ(expected_2, ft);
     }
 
-    TEST(xstrided_view, rot90)
+    TEST(xmanipulation, flip_noaxis)
+    {
+        {
+            xtensor<double, 1> e = {1, 2, 3, 4, 5, 6};
+            xtensor<double, 1> t = xt::flip(e);
+            xtensor<double, 1> expected = {6, 5, 4, 3, 2, 1};
+            ASSERT_EQ(expected, t);
+        }
+        {
+            xtensor<double, 2> e = {{1, 2, 3}, {4, 5, 6}};
+            xtensor<double, 2> t = xt::flip(e);
+            xtensor<double, 2> expected = {{6, 5, 4}, {3, 2, 1}};
+            ASSERT_EQ(expected, t);
+        }
+    }
+
+    TEST(xmanipulation, rot90)
     {
         xarray<double> e = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
         xarray<double> e2 = {{1, 2}, {3, 4}};
         xarray<double> e3 = {{{0, 1}, {2, 3}}, {{4, 5}, {6, 7}}};
 
         std::array<std::ptrdiff_t, 2> axes = {0, 0};
-        ASSERT_ANY_THROW(xt::rot90(e, axes));
+        XT_ASSERT_ANY_THROW(xt::rot90(e, axes));
         axes = {1, 1};
-        ASSERT_ANY_THROW(xt::rot90(e, axes));
+        XT_ASSERT_ANY_THROW(xt::rot90(e, axes));
         axes = {0, 2};
-        ASSERT_ANY_THROW(xt::rot90(e, axes));
+        XT_ASSERT_ANY_THROW(xt::rot90(e, axes));
         axes = {56, 58};
-        ASSERT_ANY_THROW(xt::rot90(e, axes));
+        XT_ASSERT_ANY_THROW(xt::rot90(e, axes));
 
         ASSERT_EQ(e, xt::rot90<0>(e));
         ASSERT_EQ(e, xt::rot90<4>(e));
@@ -311,4 +470,158 @@ namespace xt
         xarray<double> expected5 = {{{1, 3}, {0, 2}}, {{5, 7}, {4, 6}}};
         ASSERT_EQ(expected5, xt::rot90(e3, {1, 2}));
     }
+
+    TEST(xmanipulation, roll)
+    {
+        xarray<double> e1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+
+        ASSERT_EQ(e1, xt::roll(e1, 0));
+
+        xarray<double> expected1 = {{2, 3, 4}, {5, 6, 7}, {8, 9, 1}};
+        ASSERT_EQ(expected1, xt::roll(e1, -1));
+
+        xarray<double> expected2 = {{8, 9, 1}, {2, 3, 4}, {5, 6, 7}};
+        ASSERT_EQ(expected2, xt::roll(e1, 2));
+
+        xarray<double> expected3 = {{8, 9, 1}, {2, 3, 4}, {5, 6, 7}};
+        ASSERT_EQ(expected3, xt::roll(e1, 11));
+
+        xarray<double> expected4 = {{7, 8, 9}, {1, 2, 3}, {4, 5, 6}};
+        ASSERT_EQ(expected4, xt::roll(e1, 1, /*axis*/ 0));
+
+        xarray<double> expected5 = {{3, 1, 2}, {6, 4, 5}, {9, 7, 8}};
+        ASSERT_EQ(expected5, xt::roll(e1, 1, /*axis*/ 1));
+
+        xarray<double> e2 = {{{1, 2, 3}}, {{4, 5, 6}}, {{7, 8, 9}}};
+
+        xarray<double> expected6 = {{{4, 5, 6}}, {{7, 8, 9}}, {{1, 2, 3}}};
+        ASSERT_EQ(expected6, xt::roll(e2, 2, /*axis*/ 0));
+
+        xarray<double> expected7 = {{{1, 2, 3}}, {{4, 5, 6}}, {{7, 8, 9}}};
+        ASSERT_EQ(expected7, xt::roll(e2, -2, /*axis*/ 1));
+
+        xarray<double> expected8 = {{{3, 1, 2}}, {{6, 4, 5}}, {{9, 7, 8}}};
+        ASSERT_EQ(expected8, xt::roll(e2, -2, /*axis*/ 2));
+
+        EXPECT_THROW(xt::roll(e2, 1, /*axis*/ 3), std::runtime_error);
+        EXPECT_THROW(xt::roll(e2, 1, /*axis*/ -4), std::runtime_error);
+
+        xarray<double> expected9 = {{{3, 1, 2}}, {{6, 4, 5}}, {{9, 7, 8}}};
+        ASSERT_EQ(expected9, xt::roll(e2, -2, /*axis*/ -1));
+
+        xarray<double> expected10 = {{{1, 2, 3}}, {{4, 5, 6}}, {{7, 8, 9}}};
+        ASSERT_EQ(expected10, xt::roll(e2, -2, /*axis*/ -2));
+
+        xarray<double> expected11 = {{{4, 5, 6}}, {{7, 8, 9}}, {{1, 2, 3}}};
+        ASSERT_EQ(expected11, xt::roll(e2, 2, /*axis*/ -3));
+
+        xarray<double> empty_1d = xt::xarray<double>::from_shape({0});
+        EXPECT_EQ(xt::roll(empty_1d, 5).shape(), empty_1d.shape());
+
+        xarray<double> partial_empty = xt::xarray<double>::from_shape({3, 0});
+        EXPECT_EQ(xt::roll(partial_empty, 1, 1).shape(), partial_empty.shape());
+
+        xarray<double> mixed_empty = xt::xarray<double>::from_shape({3, 0, 4});
+        EXPECT_EQ(xt::roll(mixed_empty, 1, 0).shape(), mixed_empty.shape());
+    }
+
+    TEST(xmanipulation, repeat_all_elements_of_axis_0_of_int_array_2_times)
+    {
+        xarray<int> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        const auto result = xt::view(repeated_array, xt::all());
+
+        xarray<int>::shape_type expected_shape{6, 3};
+        const auto expected = xt::view(
+            xarray<int>{
+                {1, 2, 3},
+                {1, 2, 3},
+                {4, 5, 6},
+                {4, 5, 6},
+                {7, 8, 9},
+                {7, 8, 9},
+            },
+            xt::all()
+        );
+        ASSERT_EQ(expected_shape, repeated_array.shape());
+        ASSERT_EQ(expected, result);
+    }
+
+    TEST(xmanipulation, repeat_all_elements_of_axis_1_of_double_array_2_times)
+    {
+        xarray<double> array = {
+            {1.0, 2.0, 3.0},
+            {4.0, 5.0, 6.0},
+            {7.0, 8.0, 9.0},
+        };
+
+        const auto repeated_array = xt::repeat(array, 2, 1);
+        const auto result = xt::view(repeated_array, xt::all());
+
+        xarray<double>::shape_type expected_shape{3, 6};
+        const auto expected = xt::view(
+            xarray<double>{
+                {1.0, 1.0, 2.0, 2.0, 3.0, 3.0},
+                {4.0, 4.0, 5.0, 5.0, 6.0, 6.0},
+                {7.0, 7.0, 8.0, 8.0, 9.0, 9.0},
+            },
+            xt::all()
+        );
+        ASSERT_EQ(expected_shape, repeated_array.shape());
+        ASSERT_EQ(expected, result);
+    }
+
+    TEST(xmanipulation, repeat_elements_of_axis_0_123)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+
+        const auto repeated_array = xt::repeat(array, {1, 2, 3}, 0);
+        const auto result = xt::view(repeated_array, xt::all());
+
+        xarray<size_t>::shape_type expected_shape{6, 3};
+        const auto expected = xt::view(
+            xarray<size_t>{
+                {1, 2, 3},
+                {4, 5, 6},
+                {4, 5, 6},
+                {7, 8, 9},
+                {7, 8, 9},
+                {7, 8, 9},
+            },
+            xt::all()
+        );
+        ASSERT_EQ(expected_shape, repeated_array.shape());
+        ASSERT_EQ(expected, result);
+    }
+
+    TEST(xmanipulation, repeat_and_access_various_elements)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+
+        const std::vector<std::size_t> repeats{1, 2, 3};
+        const auto repeated_array = xt::repeat(array, repeats, 0);
+
+        ASSERT_EQ(1, repeated_array(0, 0));
+        ASSERT_EQ(4, repeated_array(1, 0));
+        ASSERT_EQ(5, repeated_array(2, 1));
+        ASSERT_EQ(7, repeated_array(3, 0));
+        ASSERT_EQ(8, repeated_array(3, 1));
+        ASSERT_EQ(9, repeated_array(3, 2));
+    }
+
+    TEST(xmanipulation, zzzzzz)
+    {
+    }
 }
diff --git a/test/test_xmasked_value.cpp b/test/test_xmasked_value.cpp
deleted file mode 100644
index 4a7469298..000000000
--- a/test/test_xmasked_value.cpp
+++ /dev/null
@@ -1,624 +0,0 @@
-/***************************************************************************
-* Copyright (c) 2017, 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. *
-****************************************************************************/
-
-#include "gtest/gtest.h"
-
-#include "xtensor/xmasked_value.hpp"
-
-namespace xt
-{
-    using optional_type = xtl::xoptional<double&, bool&>;
-
-    TEST(xmasked_value, ctor)
-    {
-        double a = 5.2;
-
-        auto m = xmasked_value<double&>(a);
-        EXPECT_EQ(m.value(), 5.2);
-        EXPECT_EQ(m.visible(), true);
-    }
-
-    TEST(xmasked_value, value)
-    {
-        double a = 5.2;
-        bool bool_val = true;
-
-        auto b = optional_type(a, bool_val);
-        auto c = xmasked_value<optional_type>(b);
-
-        EXPECT_EQ(c.value(), 5.2);
-        a = 3.35;
-        EXPECT_EQ(c.value(), 3.35);
-        c.value() = 126.;
-        EXPECT_EQ(c.value(), 126.);
-        EXPECT_EQ(a, 126.);
-
-        auto c2 = xmasked_value<double>(3.);
-        EXPECT_EQ(c2.value(), 3.);
-        c2.value() = 36.;
-        EXPECT_EQ(c2.value(), 36.);
-    }
-
-    TEST(xmasked_value, visible)
-    {
-        double a = 5.2;
-        bool bool_val = true;
-
-        auto b = optional_type(a, bool_val);
-        auto c = xmasked_value<optional_type, bool&>(b, bool_val);
-
-        EXPECT_TRUE(c.visible());
-        bool_val = false;
-        EXPECT_FALSE(c.visible());
-    }
-
-    TEST(xmasked_value, conversion)
-    {
-        double a = 5.2;
-        bool bool_val = true;
-
-        auto b = xmasked_value<double&, bool&>(a, bool_val);
-
-        xtl::xoptional<double&, bool> c = b;
-        EXPECT_EQ(c.value(), 5.2);
-        EXPECT_TRUE(c.has_value());
-
-        double& val = b;
-        EXPECT_EQ(val, 5.2);
-        val = 36.;
-        EXPECT_EQ(c.value(), 36.);
-        EXPECT_EQ(b.value(), 36.);
-    }
-
-    TEST(xmasked_value, comparison)
-    {
-        double a = 5.2;
-        bool bool_val = true;
-
-        auto m1 = xmasked_value<double&, bool&>(a, bool_val);
-        auto m2 = xmasked_value<double&, bool&>(a, bool_val);
-
-        EXPECT_EQ(m1, m2);
-        EXPECT_EQ(m2, m1);
-
-        EXPECT_EQ(m1, 5.2);
-        EXPECT_EQ(5.2, m1);
-
-        EXPECT_NE(m1, 6.2);
-        EXPECT_NE(6.2, m1);
-
-        bool_val = false;
-
-        EXPECT_NE(m1, 5.2);
-        EXPECT_NE(5.2, m1);
-
-        auto masked1 = masked<xtl::xoptional<double, bool>>();
-        EXPECT_EQ(m1, masked1);
-        EXPECT_EQ(m2, masked1);
-
-        auto o1 = xtl::xoptional<double, bool>(3.5, true);
-        auto o2 = xtl::xoptional<double, bool>(6.5, false);
-        auto m3 = xmasked_value<xtl::xoptional<double, bool>, bool>(o1, true);
-        auto m4 = xmasked_value<xtl::xoptional<double, bool>, bool>(o2, true);
-
-        EXPECT_EQ(m3, o1);
-        EXPECT_EQ(o1, m3);
-        EXPECT_NE(m4, o1);
-        EXPECT_NE(o2, m3);
-        EXPECT_NE(m3, m4);
-
-        m3.visible() = m4.visible() = false;
-        EXPECT_EQ(m3, m4);
-        auto masked2 = masked<xtl::xoptional<double, bool>>();
-        EXPECT_EQ(m3, masked2);
-        EXPECT_EQ(m4, masked2);
-    }
-
-    TEST(xmasked_value, swap)
-    {
-        double a1 = 5.2;
-        bool b1 = true;
-        double a2 = 36.5;
-        bool b2 = false;
-
-        auto m1 = xmasked_value<double&, bool&>(a1, b1);
-        auto m2 = xmasked_value<double&, bool&>(a2, b2);
-
-        EXPECT_EQ(a1, 5.2);
-        EXPECT_EQ(b1, true);
-        EXPECT_EQ(a2, 36.5);
-        EXPECT_EQ(b2, false);
-
-        m1.swap(m2);
-
-        EXPECT_EQ(a1, 36.5);
-        EXPECT_EQ(b1, false);
-        EXPECT_EQ(a2, 5.2);
-        EXPECT_EQ(b2, true);
-
-        auto o1 = xtl::xoptional<double, bool>(3.5, true);
-        auto o2 = xtl::xoptional<double, bool>(6.5, false);
-        auto m3 = xmasked_value<xtl::xoptional<double, bool>, bool>(o1, true);
-        auto m4 = xmasked_value<xtl::xoptional<double, bool>, bool>(o2, false);
-
-        swap(m3, m4);
-
-        EXPECT_EQ(m3.value().value(), 6.5);
-        EXPECT_FALSE(m3.value().has_value());
-        EXPECT_FALSE(m3.visible());
-        EXPECT_EQ(m4.value().value(), 3.5);
-        EXPECT_TRUE(m4.value().has_value());
-        EXPECT_TRUE(m4.visible());
-    }
-
-    TEST(xmasked_value, arithm_neg)
-    {
-        double a = 5.2;
-        bool b = true;
-
-        auto m = xmasked_value<double&, bool&>(a, b);
-
-        xmasked_value<double, bool> r = -m;
-        EXPECT_EQ(r.value(), -5.2);
-        EXPECT_EQ(r.visible(), true);
-    }
-
-    TEST(xmasked_value, arithm_plus)
-    {
-        double a = 5.2;
-        bool b = true;
-
-        auto o = optional_type(a, b);
-
-        auto m = xmasked_value<optional_type>(o);
-
-        auto r1 = m + o;
-        EXPECT_EQ(r1.value(), 10.4);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o + m;
-        EXPECT_EQ(r2.value(), 10.4);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m + m;
-        EXPECT_EQ(r3.value(), 10.4);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 4.2 + m;
-        EXPECT_EQ(r4.value(), 9.4);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m + 4.2;
-        EXPECT_EQ(r5.value(), 9.4);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, arithm_minus)
-    {
-        double a = 5.2;
-        bool b = true;
-
-        auto o = optional_type(a, b);
-
-        auto m = xmasked_value<optional_type>(o);
-
-        auto r1 = m - o;
-        EXPECT_EQ(r1.value(), 0.0);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o - m;
-        EXPECT_EQ(r2.value(), 0.0);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m - m;
-        EXPECT_EQ(r3.value(), 0.0);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 4.2 - m;
-        EXPECT_EQ(r4.value(), -1.0);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m - 4.2;
-        EXPECT_EQ(r5.value(), 1.0);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, arithm_mult)
-    {
-        double a = 5.0;
-        bool b = true;
-
-        auto o = optional_type(a, b);
-
-        auto m = xmasked_value<optional_type>(o);
-
-        auto r1 = m * o;
-        EXPECT_EQ(r1.value(), 25.);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o * m;
-        EXPECT_EQ(r2.value(), 25.);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m * m;
-        EXPECT_EQ(r3.value(), 25.);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 4. * m;
-        EXPECT_EQ(r4.value(), 20.);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m * 4.;
-        EXPECT_EQ(r5.value(), 20.);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, arithm_div)
-    {
-        double a = 5.0;
-        bool b = true;
-
-        auto o = optional_type(a, b);
-
-        auto m = xmasked_value<optional_type>(o);
-
-        auto r1 = m / o;
-        EXPECT_EQ(r1.value(), 1.);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o / m;
-        EXPECT_EQ(r2.value(), 1.);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m / m;
-        EXPECT_EQ(r3.value(), 1.);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 25. / m;
-        EXPECT_EQ(r4.value(), 5.);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m / 1.;
-        EXPECT_EQ(r5.value(), 5.);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, operator_or)
-    {
-        bool b = true;
-
-        auto o = xtl::xoptional<bool, bool&>(true, b);
-        auto m = xmasked_value<xtl::xoptional<bool, bool&>, bool>(o, true);
-
-        auto r1 = m || o;
-        EXPECT_EQ(r1.value(), true);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o || m;
-        EXPECT_EQ(r2.value(), true);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m || m;
-        EXPECT_EQ(r3.value(), true);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = true || m;
-        EXPECT_EQ(r4.value(), true);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = false || m;
-        EXPECT_EQ(r5.value(), true);
-        EXPECT_EQ(r5.visible(), true);
-
-        auto r6 = m || true;
-        EXPECT_EQ(r6.value(), true);
-        EXPECT_EQ(r6.visible(), true);
-
-        auto r7 = m || false;
-        EXPECT_EQ(r7.value(), true);
-        EXPECT_EQ(r7.visible(), true);
-    }
-
-    TEST(xmasked_value, operator_and)
-    {
-        bool b = true;
-
-        auto o = xtl::xoptional<bool, bool&>(true, b);
-        auto m = xmasked_value<xtl::xoptional<bool, bool&>, bool>(o, true);
-
-        auto r1 = m && o;
-        EXPECT_EQ(r1.value(), true);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o && m;
-        EXPECT_EQ(r2.value(), true);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m && m;
-        EXPECT_EQ(r3.value(), true);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = true && m;
-        EXPECT_EQ(r4.value(), true);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = false && m;
-        EXPECT_EQ(r5.value(), false);
-        EXPECT_EQ(r5.visible(), true);
-
-        auto r6 = m && true;
-        EXPECT_EQ(r6.value(), true);
-        EXPECT_EQ(r6.visible(), true);
-
-        auto r7 = m && false;
-        EXPECT_EQ(r7.value(), false);
-        EXPECT_EQ(r7.visible(), true);
-
-        m.visible() = false;
-        auto r8 = m && true;
-        EXPECT_EQ(r8.visible(), false);
-    }
-
-    TEST(xmasked_value, operator_not)
-    {
-        bool b = true;
-
-        auto m1 = xmasked_value<bool, bool&>(true, b);
-        auto m2 = xmasked_value<bool, bool&>(false, b);
-
-        EXPECT_EQ(!m1, false);
-        EXPECT_EQ(!m2, true);
-    }
-
-    TEST(xmasked_value, operator_less)
-    {
-        double a1 = 5.0;
-        double a2 = 10.0;
-        bool b = true;
-
-        auto o = optional_type(a1, b);
-        auto o2 = optional_type(a2, b);
-
-        auto m = xmasked_value<optional_type, bool>(o2, true);
-
-        auto r1 = m < o;
-        EXPECT_EQ(r1.value(), false);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o < m;
-        EXPECT_EQ(r2.value(), true);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m < m;
-        EXPECT_EQ(r3.value(), false);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 25. < m;
-        EXPECT_EQ(r4.value(), false);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m < 25.;
-        EXPECT_EQ(r5.value(), true);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, operator_less_equal)
-    {
-        double a1 = 5.0;
-        double a2 = 10.0;
-        bool b = true;
-
-        auto o = optional_type(a1, b);
-        auto o2 = optional_type(a2, b);
-
-        auto m = xmasked_value<optional_type, bool>(o2, true);
-
-        auto r1 = m <= o;
-        EXPECT_EQ(r1.value(), false);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o <= m;
-        EXPECT_EQ(r2.value(), true);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m <= m;
-        EXPECT_EQ(r3.value(), true);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 25. <= m;
-        EXPECT_EQ(r4.value(), false);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m <= 25.;
-        EXPECT_EQ(r5.value(), true);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, operator_more)
-    {
-        double a1 = 5.0;
-        double a2 = 10.0;
-        bool b = true;
-
-        auto o = optional_type(a1, b);
-        auto o2 = optional_type(a2, b);
-
-        auto m = xmasked_value<optional_type, bool&>(o2, b);
-
-        auto r1 = m > o;
-        EXPECT_EQ(r1.value(), true);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o > m;
-        EXPECT_EQ(r2.value(), false);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m > m;
-        EXPECT_EQ(r3.value(), false);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 25. > m;
-        EXPECT_EQ(r4.value(), true);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m > 25.;
-        EXPECT_EQ(r5.value(), false);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, operator_more_equal)
-    {
-        double a1 = 5.0;
-        double a2 = 10.0;
-        bool b = true;
-
-        auto o = optional_type(a1, b);
-        auto o2 = optional_type(a2, b);
-
-        auto m = xmasked_value<optional_type, bool&>(o2, b);
-
-        auto r1 = m >= o;
-        EXPECT_EQ(r1.value(), true);
-        EXPECT_EQ(r1.visible(), true);
-
-        auto r2 = o >= m;
-        EXPECT_EQ(r2.value(), false);
-        EXPECT_EQ(r2.visible(), true);
-
-        auto r3 = m >= m;
-        EXPECT_EQ(r3.value(), true);
-        EXPECT_EQ(r3.visible(), true);
-
-        auto r4 = 25. >= m;
-        EXPECT_EQ(r4.value(), true);
-        EXPECT_EQ(r4.visible(), true);
-
-        auto r5 = m >= 25.;
-        EXPECT_EQ(r5.value(), false);
-        EXPECT_EQ(r5.visible(), true);
-    }
-
-    TEST(xmasked_value, assign)
-    {
-        double a = 5.2;
-        double a2 = 3.35;
-        bool bool_val = true;
-
-        auto b = optional_type(a, bool_val);
-        auto c = xmasked_value<optional_type>(b);
-
-        // Value not masked, assigning a value works
-        EXPECT_EQ(c.value(), 5.2);
-        c = a2;
-        EXPECT_EQ(c.value(), 3.35);
-        EXPECT_EQ(a, 3.35);
-        c += 1.;
-        EXPECT_EQ(c.value(), 4.35);
-        EXPECT_EQ(a, 4.35);
-        c -= 1.;
-        c *= 2.;
-        EXPECT_NEAR(a, 6.7, 0.0001);
-        c -= b;
-        EXPECT_NEAR(a, 0., 0.0001);
-        c = 3.35;
-
-        // When masked, the assign doesn't do anything
-        c.visible() = false;
-        c = 126.;
-        EXPECT_EQ(c.value(), 3.35);
-        EXPECT_EQ(a, 3.35);
-        c *= 126;
-        EXPECT_EQ(c.value(), 3.35);
-        EXPECT_EQ(a, 3.35);
-    }
-
-    TEST(xmasked_value, unary_op)
-    {
-        double a1 = -5.2;
-        double a2 = 5.2;
-        bool bool_val = true;
-
-        auto m1 = xmasked_value<double&, bool&>(a1, bool_val);
-        auto m2 = xmasked_value<double&, bool&>(a2, bool_val);
-
-        EXPECT_EQ(xt::abs(m1).value(), 5.2);
-        EXPECT_EQ(xt::abs(m2).value(), 5.2);
-    }
-
-    TEST(xmasked_value, unary_bool_op)
-    {
-        double a = -5.2;
-        bool bool_val = true;
-
-        auto m = xmasked_value<double&, bool&>(a, bool_val);
-
-        EXPECT_EQ(xt::isfinite(m).value(), true);
-    }
-
-    TEST(xmasked_value, binary_op)
-    {
-        double a1 = 5.0;
-        double a2 = 5.0;
-        bool bool_val = true;
-
-        auto o = xtl::xoptional<double&>(a1);
-        auto m1 = xmasked_value<xtl::xoptional<double&>, bool&>(o, bool_val);
-        auto m2 = xmasked_value<double&, bool&>(a2, bool_val);
-
-        EXPECT_EQ(xt::pow(m1, m1).value(), std::pow(5., 5.));
-        EXPECT_EQ(xt::pow(m1, o).value(), std::pow(5., 5.));
-        EXPECT_EQ(xt::pow(o, m1).value(), std::pow(5., 5.));
-        EXPECT_EQ(xt::pow(m1, 2).value(), 25.0);
-        EXPECT_EQ(xt::pow(2, m1).value(), 32);
-    }
-
-    TEST(xmasked_value, ternary_op)
-    {
-        double a1 = 5.0;
-        double a2 = 11.0;
-        bool bool_val = true;
-
-        auto m1 = xmasked_value<double&, bool&>(a1, bool_val);
-        auto m2 = xmasked_value<double&, bool&>(a2, bool_val);
-        auto masked1 = masked<double>();
-
-        EXPECT_EQ(xt::fma(m1, m2, m2).value(), 66.);
-        EXPECT_EQ(xt::fma(m1, masked1, m2), masked1);
-
-        EXPECT_EQ(xt::fma(m1, m2, 2.).value(), 57.);
-        EXPECT_EQ(xt::fma(m1, 2., m2).value(), 21.);
-        EXPECT_EQ(xt::fma(2., m1, m2).value(), 21.);
-        EXPECT_EQ(xt::fma(2., 10., m2).value(), 31.);
-        EXPECT_EQ(xt::fma(2., m2, 3.).value(), 25.);
-        EXPECT_EQ(xt::fma(m2, 5., 3.).value(), 58.);
-        EXPECT_EQ(xt::fma(m2, 5., masked1), masked1);
-
-        auto o = xtl::xoptional<double>(2.);
-        auto o1 = xtl::xoptional<double>(5.);
-        auto o2 = xtl::xoptional<double>(11.);
-        auto m3 = xmasked_value<xtl::xoptional<double>, bool&>(o1, bool_val);
-        auto m4 = xmasked_value<xtl::xoptional<double>, bool&>(o2, bool_val);
-        auto masked2 = masked<xtl::xoptional<double>>();
-
-        EXPECT_EQ(xt::fma(m3, m4, o).value(), 57.);
-        EXPECT_EQ(xt::fma(m3, o, m4).value(), 21.);
-        EXPECT_EQ(xt::fma(o, m3, m4).value(), 21.);
-        EXPECT_EQ(xt::fma(o, m3, masked2), masked2);
-        EXPECT_EQ(xt::fma(o, o, m4).value(), 15.);
-        EXPECT_EQ(xt::fma(o, m4, o).value(), 24.);
-        EXPECT_EQ(xt::fma(m4, o, o).value(), 24.);
-
-        EXPECT_EQ(xt::fma(3., m4, o).value(), 35.);
-        EXPECT_EQ(xt::fma(m4, 3., o).value(), 35.);
-        EXPECT_EQ(xt::fma(m4, o, 3.).value(), 25.);
-        EXPECT_EQ(xt::fma(o, m4, 3.).value(), 25.);
-        EXPECT_EQ(xt::fma(o, 3., m3).value(), 11.);
-        EXPECT_EQ(xt::fma(3., o, m3).value(), 11.);
-    }
-}
diff --git a/test/test_xmasked_view.cpp b/test/test_xmasked_view.cpp
index f24d1b544..1c7f9cb4d 100644
--- a/test/test_xmasked_view.cpp
+++ b/test/test_xmasked_view.cpp
@@ -1,17 +1,19 @@
 /***************************************************************************
-* Copyright (c) 2017, 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
+#include <sstream>
 
-#include "xtensor/xoptional_assembly.hpp"
-#include "xtensor/xmasked_view.hpp"
-#include "xtensor/xio.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/optional/xoptional_assembly.hpp"
+#include "xtensor/views/xmasked_view.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -22,9 +24,7 @@ namespace xt
     //         { 7. ,  8.,  9. }}
     inline data_type make_test_data()
     {
-        data_type d = {{ 1., 2., 3.},
-                       { 4., 5., 6.},
-                       { 7., 8., 9.}};
+        data_type d = {{1., 2., 3.}, {4., 5., 6.}, {7., 8., 9.}};
         d(0, 2).has_value() = false;
         d(1, 0).has_value() = false;
         return d;
@@ -35,9 +35,7 @@ namespace xt
     //                { 7. ,  8.,  9. }}
     inline auto make_masked_data(data_type& data)
     {
-        xarray<bool> mask = {{ true,  true,  true},
-                             {false, false, false},
-                             { true,  true,  true}};
+        xarray<bool> mask = {{true, true, true}, {false, false, false}, {true, true, true}};
 
         return masked_view(data, std::move(mask));
     }
@@ -74,7 +72,7 @@ namespace xt
         auto data = make_test_data();
         auto masked_data = make_masked_data(data);
 
-        auto masked_value = masked<xtl::xoptional<double, bool>>();
+        auto masked_value = xtl::masked<xtl::xoptional<double, bool>>();
         EXPECT_EQ(masked_data(0, 0), 1.);
         EXPECT_EQ(masked_data(0, 1), 2.);
         EXPECT_EQ(masked_data(0, 2), xtl::missing<double>());
@@ -85,8 +83,10 @@ namespace xt
         EXPECT_EQ(masked_data(2, 1), 8.);
         EXPECT_EQ(masked_data(2, 2), 9.);
 
-#ifdef XTENSOR_ENABLE_ASSERT
-        EXPECT_ANY_THROW(masked_data(3, 3));
+#if defined(XTENSOR_ENABLE_ASSERT)
+#if !defined(XTENSOR_DISABLE_EXCEPTIONS)
+        XT_EXPECT_ANY_THROW(masked_data(3, 3));
+#endif
 #endif
     }
 
@@ -95,7 +95,7 @@ namespace xt
         auto data = make_test_data();
         auto masked_data = make_masked_data(data);
 
-        auto masked_value = masked<xtl::xoptional<double, bool>>();
+        auto masked_value = xtl::masked<xtl::xoptional<double, bool>>();
         EXPECT_EQ(masked_data.at(0, 0), 1.);
         EXPECT_EQ(masked_data.at(0, 1), 2.);
         EXPECT_EQ(masked_data.at(0, 2), xtl::missing<double>());
@@ -106,7 +106,7 @@ namespace xt
         EXPECT_EQ(masked_data.at(2, 1), 8.);
         EXPECT_EQ(masked_data.at(2, 2), 9.);
 
-        EXPECT_ANY_THROW(masked_data.at(3, 3));
+        XT_EXPECT_ANY_THROW(masked_data.at(3, 3));
     }
 
     TEST(xmasked_view, unchecked)
@@ -114,7 +114,7 @@ namespace xt
         auto data = make_test_data();
         auto masked_data = make_masked_data(data);
 
-        auto masked_value = masked<xtl::xoptional<double, bool>>();
+        auto masked_value = xtl::masked<xtl::xoptional<double, bool>>();
         EXPECT_EQ(masked_data.unchecked(0, 0), 1.);
         EXPECT_EQ(masked_data.unchecked(0, 1), 2.);
         EXPECT_EQ(masked_data.unchecked(0, 2), xtl::missing<double>());
@@ -131,7 +131,7 @@ namespace xt
         auto data = make_test_data();
         auto masked_data = make_masked_data(data);
 
-        auto masked_value = masked<xtl::xoptional<double, bool>>();
+        auto masked_value = xtl::masked<xtl::xoptional<double, bool>>();
 
         auto val = masked_data[{0, 0}];
         EXPECT_EQ(val, 1.);
@@ -149,7 +149,7 @@ namespace xt
         auto data = make_test_data();
         auto masked_data = make_masked_data(data);
 
-        auto masked_value = masked<xtl::xoptional<double, bool>>();
+        auto masked_value = xtl::masked<xtl::xoptional<double, bool>>();
 
         auto index1 = std::array<int, 2>({0, 0});
         auto index2 = std::array<int, 2>({1, 0});
@@ -164,7 +164,7 @@ namespace xt
 
         masked_data.fill(2.);
 
-        auto masked_value = masked<xtl::xoptional<double, bool>>();
+        auto masked_value = xtl::masked<xtl::xoptional<double, bool>>();
         EXPECT_EQ(masked_data.at(0, 0), 2.);
         EXPECT_EQ(masked_data.at(0, 1), 2.);
         EXPECT_EQ(masked_data.at(0, 2), 2.);
@@ -188,19 +188,15 @@ namespace xt
 
     TEST(xmasked_view, non_optional_data)
     {
-        xarray<double> data = {{ 1.,-2., 3.},
-                               { 4., 5.,-6.},
-                               { 7., 8.,-9.}};
-        xarray<bool> mask = {{ true,  true,  true},
-                             { true, false, false},
-                             { true, false,  true}};
+        xarray<double> data = {{1., -2., 3.}, {4., 5., -6.}, {7., 8., -9.}};
+        xarray<bool> mask = {{true, true, true}, {true, false, false}, {true, false, true}};
 
         auto masked_data = masked_view(data, mask);
 
-        auto masked_value = masked<double>();
+        auto masked_value = xtl::masked<double>();
 
         EXPECT_EQ(masked_data(0, 0), 1.);
-        EXPECT_EQ(masked_data.at(0, 1),-2.);
+        EXPECT_EQ(masked_data.at(0, 1), -2.);
         EXPECT_EQ(masked_data.at(0, 2), 3.);
         EXPECT_EQ(masked_data.unchecked(1, 0), 4.);
         EXPECT_EQ(masked_data.unchecked(1, 1), masked_value);
@@ -208,15 +204,55 @@ namespace xt
         EXPECT_EQ(masked_data[index1], masked_value);
 
         masked_data = 3.65;
-        xarray<double> expected1 = {{3.65, 3.65, 3.65},
-                                   {3.65, 5.  ,-6.  },
-                                   {3.65, 8.  , 3.65}};
+        xarray<double> expected1 = {{3.65, 3.65, 3.65}, {3.65, 5., -6.}, {3.65, 8., 3.65}};
         EXPECT_EQ(data, expected1);
 
         masked_data += 3.;
-        xarray<double> expected2 = {{6.65, 6.65, 6.65},
-                                    {6.65, 5.  ,-6.  },
-                                    {6.65, 8.  , 6.65}};
+        xarray<double> expected2 = {{6.65, 6.65, 6.65}, {6.65, 5., -6.}, {6.65, 8., 6.65}};
         EXPECT_EQ(data, expected2);
     }
+
+    TEST(xmasked_view, non_optional_data_stream)
+    {
+        const xarray<double> data = {{1., 5., 3.}, {4., 5., 6.}};
+        const xarray<bool> mask = {{true, false, false}, {false, true, false}};
+
+        const auto masked_data = masked_view(data, mask);
+
+        std::stringstream out;
+        out << masked_data;
+
+        const std::string expected = "{{     1, masked, masked},\n"
+                                     " {masked,      5, masked}}";
+        EXPECT_EQ(out.str(), expected);
+    }
+
+    TEST(xmasked_view, assign)
+    {
+        xarray<double> data = {{1., -2., 3.}, {4., 5., -6.}, {7., 8., -9.}};
+        xarray<double> data2 = {{0.1, 0.2, 0.3}, {0.4, 0.5, 0.6}, {0.7, 0.8, 0.9}};
+        xarray<bool> mask = {{true, true, true}, {true, false, false}, {true, false, true}};
+
+        auto masked_data = masked_view(data, mask);
+
+        masked_data = data2;
+        xarray<double> expected1 = {{0.1, 0.2, 0.3}, {0.4, 5., -6.}, {0.7, 8., 0.9}};
+        EXPECT_EQ(data, expected1);
+    }
+
+    TEST(xmasked_view, view)
+    {
+        xt::xarray<size_t> data = {{0, 1}, {2, 3}, {4, 5}};
+        xt::xarray<size_t> data_new = xt::zeros<size_t>(data.shape());
+        xt::xarray<bool> col_mask = {false, true};
+
+        auto row_masked = xt::masked_view(xt::view(data, 0, xt::all()), col_mask);
+        auto new_row_masked = xt::masked_view(xt::view(data_new, 0, xt::all()), col_mask);
+
+        row_masked += 10;
+        new_row_masked = row_masked;
+
+        EXPECT_EQ(data_new(0, 0), size_t(0));
+        EXPECT_EQ(data_new(0, 1), size_t(11));
+    }
 }
diff --git a/test/test_xmath.cpp b/test/test_xmath.cpp
index 43ec2947c..57771859b 100644
--- a/test/test_xmath.cpp
+++ b/test/test_xmath.cpp
@@ -1,187 +1,28 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
 #include <complex>
 #include <limits>
 
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xmath.hpp"
-#include "xtensor/xrandom.hpp"
+#include "xtensor/containers/xadapt.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/optional/xoptional_assembly.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     using std::size_t;
     using shape_type = dynamic_shape<size_t>;
 
-    /*******************
-     * type conversion *
-     *******************/
-
-#define CHECK_RESULT_TYPE(EXPRESSION, EXPECTED_TYPE)                                 \
-    {                                                                                \
-        using result_type = typename std::decay_t<decltype(EXPRESSION)>::value_type; \
-        EXPECT_TRUE((std::is_same<result_type, EXPECTED_TYPE>::value));              \
-    }
-#define ARRAY_TYPE(VALUE_TYPE)  \
-    std::array<VALUE_TYPE, 2>
-
-#define CHECK_TEMPLATED_RESULT_TYPE(FUNC, INPUT)                                     \
-        CHECK_RESULT_TYPE(FUNC<unsigned char>(INPUT), int);                          \
-        CHECK_RESULT_TYPE(FUNC<signed char>(INPUT), int);                            \
-        CHECK_RESULT_TYPE(FUNC<char>(INPUT), int);                                   \
-        CHECK_RESULT_TYPE(FUNC<unsigned short>(INPUT), int);                         \
-        CHECK_RESULT_TYPE(FUNC<signed short>(INPUT), int);                           \
-        CHECK_RESULT_TYPE(FUNC<short>(INPUT), int);                                  \
-        CHECK_RESULT_TYPE(FUNC<unsigned int>(INPUT), unsigned int);                  \
-        CHECK_RESULT_TYPE(FUNC<signed int>(INPUT), signed int);                      \
-        CHECK_RESULT_TYPE(FUNC<int>(INPUT), int);                                    \
-        CHECK_RESULT_TYPE(FUNC<unsigned long long>(INPUT), unsigned long long);      \
-        CHECK_RESULT_TYPE(FUNC<signed long long>(INPUT), signed long long);
-
-    TEST(xmath, result_type)
-    {
-        shape_type shape = {3, 2};
-        xarray<unsigned char> auchar(shape);
-        xarray<short> ashort(shape);
-        xarray<int> aint(shape);
-        xarray<unsigned int> auint(shape);
-        xarray<unsigned long long> aulong(shape);
-        xarray<float> afloat(shape);
-        xarray<double> adouble(shape);
-        xarray<std::complex<float>> afcomplex(shape);
-        xarray<std::complex<double>> adcomplex(shape);
-
-        /*****************
-         * unsigned char *
-         *****************/
-        CHECK_RESULT_TYPE(auchar + auchar, int);
-        CHECK_RESULT_TYPE(2 * auchar, int);
-        CHECK_RESULT_TYPE(2.0 * auchar, double);
-        CHECK_RESULT_TYPE(sqrt(auchar), double);
-        CHECK_RESULT_TYPE(abs(auchar), unsigned char);
-        CHECK_RESULT_TYPE(sum(auchar), unsigned long long);
-        CHECK_RESULT_TYPE(mean(auchar), double);
-        CHECK_RESULT_TYPE(minmax(auchar), ARRAY_TYPE(unsigned char));
-        CHECK_TEMPLATED_RESULT_TYPE(mean, auchar);
-
-        /*********
-         * short *
-         *********/
-        CHECK_RESULT_TYPE(ashort + ashort, int);
-        CHECK_RESULT_TYPE(2 * ashort, int);
-        CHECK_RESULT_TYPE(2.0 * ashort, double);
-        CHECK_RESULT_TYPE(sqrt(ashort), double);
-        CHECK_RESULT_TYPE(abs(ashort), decltype(std::abs(short{})));
-        CHECK_RESULT_TYPE(sum(ashort), long long);
-        CHECK_RESULT_TYPE(mean(ashort), double);
-        CHECK_RESULT_TYPE(minmax(ashort), ARRAY_TYPE(short));
-        CHECK_TEMPLATED_RESULT_TYPE(mean, ashort);
-
-        /*******
-         * int *
-         *******/
-        CHECK_RESULT_TYPE(aint + aint, int);
-        CHECK_RESULT_TYPE(2 * aint, int);
-        CHECK_RESULT_TYPE(2.0 * aint, double);
-        CHECK_RESULT_TYPE(sqrt(aint), double);
-        CHECK_RESULT_TYPE(abs(aint), int);
-        CHECK_RESULT_TYPE(sum(aint), long long);
-        CHECK_RESULT_TYPE(mean(aint), double);
-        CHECK_RESULT_TYPE(minmax(aint), ARRAY_TYPE(int));
-        CHECK_TEMPLATED_RESULT_TYPE(mean, aint);
-
-        /****************
-         * unsigned int *
-         ****************/
-        CHECK_RESULT_TYPE(auint + auint, unsigned int);
-        CHECK_RESULT_TYPE(2 * auint, unsigned int);
-        CHECK_RESULT_TYPE(2.0 * auint, double);
-        CHECK_RESULT_TYPE(sqrt(auint), double);
-        CHECK_RESULT_TYPE(abs(auint), unsigned int);
-        CHECK_RESULT_TYPE(sum(auint), unsigned long long);
-        CHECK_RESULT_TYPE(mean(auint), double);
-        CHECK_RESULT_TYPE(minmax(auint), ARRAY_TYPE(unsigned int));
-        CHECK_TEMPLATED_RESULT_TYPE(mean, auint);
-
-        /**********************
-         * unsigned long long *
-         **********************/
-        CHECK_RESULT_TYPE(aulong + aulong, unsigned long long);
-        CHECK_RESULT_TYPE(2 * aulong, unsigned long long);
-        CHECK_RESULT_TYPE(2.0 * aulong, double);
-        CHECK_RESULT_TYPE(sqrt(aulong), double);
-        CHECK_RESULT_TYPE(abs(aulong), unsigned long long);
-        CHECK_RESULT_TYPE(sum(aulong), unsigned long long);
-        CHECK_RESULT_TYPE(mean(aulong), double);
-        CHECK_RESULT_TYPE(minmax(aulong), ARRAY_TYPE(unsigned long long));
-        CHECK_TEMPLATED_RESULT_TYPE(mean, aulong);
-
-        /*********
-         * float *
-         *********/
-        CHECK_RESULT_TYPE(afloat + afloat, float);
-        CHECK_RESULT_TYPE(2.0f * afloat, float);
-        CHECK_RESULT_TYPE(2.0 * afloat, double);
-        CHECK_RESULT_TYPE(sqrt(afloat), float);
-        CHECK_RESULT_TYPE(abs(afloat), float);
-        CHECK_RESULT_TYPE(sum(afloat), double);
-        CHECK_RESULT_TYPE(mean(afloat), double);
-        CHECK_RESULT_TYPE(minmax(afloat), ARRAY_TYPE(float));
-        CHECK_TEMPLATED_RESULT_TYPE(mean, afloat);
-
-        /**********
-         * double *
-         **********/
-        CHECK_RESULT_TYPE(adouble + adouble, double);
-        CHECK_RESULT_TYPE(2.0 * adouble, double);
-        CHECK_RESULT_TYPE(sqrt(adouble), double);
-        CHECK_RESULT_TYPE(abs(adouble), double);
-        CHECK_RESULT_TYPE(sum(adouble), double);
-        CHECK_RESULT_TYPE(mean(adouble), double);
-        CHECK_RESULT_TYPE(minmax(adouble), ARRAY_TYPE(double));
-        CHECK_TEMPLATED_RESULT_TYPE(mean, adouble);
-
-        /***********************
-         * std::complex<float> *
-         ***********************/
-        CHECK_RESULT_TYPE(afcomplex + afcomplex, std::complex<float>);
-        CHECK_RESULT_TYPE(std::complex<float>(2.0) * afcomplex, std::complex<float>);
-        CHECK_RESULT_TYPE(2.0f * afcomplex, std::complex<float>);
-        CHECK_RESULT_TYPE(sqrt(afcomplex), std::complex<float>);
-        CHECK_RESULT_TYPE(abs(afcomplex), float);
-        CHECK_RESULT_TYPE(sum(afcomplex), std::complex<double>);
-        CHECK_RESULT_TYPE(mean(afcomplex), std::complex<double>);
-
-        /************************
-         * std::complex<double> *
-         ************************/
-        CHECK_RESULT_TYPE(adcomplex + adcomplex, std::complex<double>);
-        CHECK_RESULT_TYPE(std::complex<double>(2.0) * adcomplex, std::complex<double>);
-        CHECK_RESULT_TYPE(2.0 * adcomplex, std::complex<double>);
-        CHECK_RESULT_TYPE(sqrt(adcomplex), std::complex<double>);
-        CHECK_RESULT_TYPE(abs(adcomplex), double);
-        CHECK_RESULT_TYPE(sum(adcomplex), std::complex<double>);
-        CHECK_RESULT_TYPE(mean(adcomplex), std::complex<double>);
-
-        /***************
-         * mixed types *
-         ***************/
-        CHECK_RESULT_TYPE(auchar + aint, int);
-        CHECK_RESULT_TYPE(ashort + aint, int);
-        CHECK_RESULT_TYPE(aulong + aint, unsigned long long);
-        CHECK_RESULT_TYPE(afloat + aint, float);
-        CHECK_RESULT_TYPE(adouble + aint, double);
-        CHECK_RESULT_TYPE(adouble + adcomplex, std::complex<double>);
-        CHECK_RESULT_TYPE(aulong + adouble, double);
-    }
-
-
     /********************
      * Basic operations *
      ********************/
@@ -205,10 +46,7 @@ namespace xt
         using assign_traits = xassign_traits<xarray<double>, decltype(f)>;
 
 #if XTENSOR_USE_XSIMD
-        EXPECT_TRUE(assign_traits::convertible_types());
-        EXPECT_TRUE(assign_traits::simd_size());
-        EXPECT_FALSE(assign_traits::forbid_simd());
-        EXPECT_TRUE(assign_traits::simd_assign());
+        EXPECT_TRUE(assign_traits::simd_linear_assign());
 #endif
     }
 
@@ -306,14 +144,91 @@ namespace xt
         EXPECT_EQ(fdim(sa, b)(0, 0), std::fdim(sa, b(0, 0)));
     }
 
+    TEST(xmath, amin_amax)
+    {
+        xarray<double> a{-10.0};
+        EXPECT_EQ(amin(a)[0], -10.0);
+        EXPECT_EQ(amax(a)[0], -10.0);
+
+        xarray<double> b{-10.0, -20.0};
+        EXPECT_EQ(amin(b)[0], -20.0);
+        EXPECT_EQ(amax(b)[0], -10.0);
+
+        xarray<double> c{-10.0, +20.0};
+        EXPECT_EQ(amin(c)[0], -10.0);
+        EXPECT_EQ(amax(c)[0], +20.0);
+
+        xarray<double> d{+10.0, +20.0};
+        EXPECT_EQ(amin(d)[0], +10.0);
+        EXPECT_EQ(amax(d)[0], +20.0);
+
+        xarray<double> e{+10.0};
+        EXPECT_EQ(amin(e)[0], +10.0);
+        EXPECT_EQ(amax(e)[0], +10.0);
+    }
+
+    TEST(xmath, minimum)
+    {
+        using opt_type = xoptional_assembly<xarray<double>, xarray<bool>>;
+        auto missing = xtl::missing<double>();
+
+        xarray<double> a = {1, 2, 3, 4, 5, 6};
+        xarray<double> b = {6, 5, 4, 3, 2, 1};
+        opt_type opt_a = {1, missing, 3, 4, 5, missing};
+        opt_type opt_b = {6, 5, 4, 3, missing, 1};
+
+        xarray<double> res = {1, 2, 3, 3, 2, 1};
+        EXPECT_EQ(res, minimum(a, b));
+
+        opt_type res1 = {1, missing, 3, 3, 2, missing};
+        EXPECT_EQ(res1, minimum(opt_a, b));
+
+        opt_type res2 = {1, missing, 3, 3, missing, missing};
+        EXPECT_EQ(res2, minimum(opt_a, opt_b));
+    }
+
+    TEST(xmath, maximum)
+    {
+        using opt_type = xoptional_assembly<xarray<double>, xarray<bool>>;
+        auto missing = xtl::missing<double>();
+
+        xarray<double> a = {1, 2, 3, 4, 5, 6};
+        xarray<double> b = {6, 5, 4, 3, 2, 1};
+        opt_type opt_a = {1, missing, 3, 4, 5, missing};
+        opt_type opt_b = {6, 5, 4, 3, missing, 1};
+
+        xarray<double> res = {6, 5, 4, 4, 5, 6};
+        EXPECT_EQ(res, maximum(a, b));
+
+        opt_type res1 = {6, missing, 4, 4, 5, missing};
+        EXPECT_EQ(res1, maximum(opt_a, b));
+
+        opt_type res2 = {6, missing, 4, 4, missing, missing};
+        EXPECT_EQ(res2, maximum(opt_a, opt_b));
+    }
+
     TEST(xmath, clip)
     {
-        shape_type shape = {3, 2};
+        using opt_type = xoptional_assembly<xarray<double>, xarray<bool>>;
+        auto missing = xtl::missing<double>();
+
         xarray<double> a = {1, 2, 3, 4, 5, 6};
+        opt_type opt_a = {1, missing, 3, 4, 5, missing};
+
         xarray<double> res = {2, 2, 3, 4, 4, 4};
+        EXPECT_EQ(res, clip(a, 2.0, 4.0));
 
-        xarray<double> clipped = clip(a, 2.0, 4.0);
-        EXPECT_EQ(res, clipped);
+        opt_type res1 = {2, missing, 3, 4, 4, missing};
+        EXPECT_EQ(res1, clip(opt_a, 2.0, 4.0));
+    }
+
+    TEST(xmath, clip_amin_greater_than_amax)
+    {
+        // NumPy-compatible behavior: when a_min > a_max, all values
+        // are set to a_max (the hi bound).
+        const xarray<int> arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        const xarray<int> expected = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+        EXPECT_EQ(expected, clip(arr, 8, 1));
     }
 
     TEST(xmath, sign)
@@ -368,14 +283,44 @@ namespace xt
 
     TEST(xmath, isnan)
     {
-        xarray<double> arr
-           {{1.0, std::numeric_limits<double>::quiet_NaN()},
-            {std::numeric_limits<double>::quiet_NaN(), 0.0}};
-        xarray<bool> expected
-           {{false, true}, {true, false}};
+        xarray<double> arr{
+            {1.0, std::numeric_limits<double>::quiet_NaN()},
+            {std::numeric_limits<double>::quiet_NaN(), 0.0}
+        };
+        xarray<bool> expected{{false, true}, {true, false}};
         EXPECT_TRUE(all(equal(expected, xt::isnan(arr))));
     }
 
+    TEST(xmath, deg2rad)
+    {
+        xarray<double> arr{-180, -135, -90, -45, 0, 45, 90, 135, 180};
+        xarray<double>
+            expected{-3.141593, -2.356194, -1.570796, -0.785398, 0., 0.785398, 1.570796, 2.356194, 3.141593};
+        EXPECT_TRUE(all(isclose(expected, xt::deg2rad(arr))));
+    }
+
+    TEST(xmath, radians)
+    {
+        xarray<double> arr{-180, -135, -90, -45, 0, 45, 90, 135, 180};
+        xarray<double>
+            expected{-3.141593, -2.356194, -1.570796, -0.785398, 0., 0.785398, 1.570796, 2.356194, 3.141593};
+        EXPECT_TRUE(all(isclose(expected, xt::radians(arr))));
+    }
+
+    TEST(xmath, rad2deg)
+    {
+        xarray<double> arr{-3.141593, -2.356194, -1.570796, -0.785398, 0., 0.785398, 1.570796, 2.356194, 3.141593};
+        xarray<double> expected{-180, -135, -90, -45, 0, 45, 90, 135, 180};
+        EXPECT_TRUE(all(isclose(expected, xt::rad2deg(arr))));
+    }
+
+    TEST(xmath, degrees)
+    {
+        xarray<double> arr{-3.141593, -2.356194, -1.570796, -0.785398, 0., 0.785398, 1.570796, 2.356194, 3.141593};
+        xarray<double> expected{-180, -135, -90, -45, 0, 45, 90, 135, 180};
+        EXPECT_TRUE(all(isclose(expected, xt::degrees(arr))));
+    }
+
     /*************************
      * Exponential functions *
      *************************/
@@ -383,67 +328,49 @@ namespace xt
     TEST(xmath, assign_traits)
     {
         using array_type = xarray<double>;
-        array_type a = { {1.2, 2.3}, {3.4, 4.5} };
+        array_type a = {{1.2, 2.3}, {3.4, 4.5}};
 
+        SUBCASE("unary function")
         {
-            SCOPED_TRACE("unary function");
             auto fexp = exp(a);
             using assign_traits = xassign_traits<array_type, decltype(fexp)>;
 #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits::convertible_types());
-            EXPECT_TRUE(assign_traits::simd_size());
-            EXPECT_FALSE(assign_traits::forbid_simd());
-            EXPECT_TRUE(assign_traits::simd_assign());
+            EXPECT_TRUE(assign_traits::simd_linear_assign());
 #else
             // SFINAE on load_simd is broken on mingw when xsimd is disabled. This using
             // triggers the same error as the one caught by mingw.
             using return_type = decltype(fexp.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits::convertible_types());
-            EXPECT_FALSE(assign_traits::simd_size());
-            EXPECT_TRUE(assign_traits::forbid_simd());
-            EXPECT_FALSE(assign_traits::simd_assign());
+            EXPECT_FALSE(assign_traits::simd_linear_assign());
             EXPECT_TRUE((std::is_same<return_type, double>::value));
 #endif
         }
 
+        SUBCASE("binary function")
         {
-            SCOPED_TRACE("binary function");
             auto fpow = pow(a, a);
             using assign_traits = xassign_traits<array_type, decltype(fpow)>;
 #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits::convertible_types());
-            EXPECT_TRUE(assign_traits::simd_size());
-            EXPECT_FALSE(assign_traits::forbid_simd());
-            EXPECT_TRUE(assign_traits::simd_assign());
+            EXPECT_TRUE(assign_traits::simd_linear_assign());
 #else
             // SFINAE on load_simd is broken on mingw when xsimd is disabled. This using
             // triggers the same error as the one caught by mingw.
             using return_type = decltype(fpow.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits::convertible_types());
-            EXPECT_FALSE(assign_traits::simd_size());
-            EXPECT_TRUE(assign_traits::forbid_simd());
-            EXPECT_FALSE(assign_traits::simd_assign());
+            EXPECT_FALSE(assign_traits::simd_linear_assign());
             EXPECT_TRUE((std::is_same<return_type, double>::value));
 #endif
         }
 
+        SUBCASE("ternary function")
         {
-            SCOPED_TRACE("ternary function");
             auto ffma = xt::fma(a, a, a);
             using assign_traits = xassign_traits<array_type, decltype(ffma)>;
 #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits::convertible_types());
-            EXPECT_TRUE(assign_traits::simd_size());
-            EXPECT_FALSE(assign_traits::forbid_simd());
-            EXPECT_TRUE(assign_traits::simd_assign());
+            EXPECT_TRUE(assign_traits::simd_linear_assign());
 #else
             // SFINAE on load_simd is broken on mingw when xsimd is disabled. This using
             // triggers the same error as the one caught by mingw.
             using return_type = decltype(ffma.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits::convertible_types());
-            EXPECT_FALSE(assign_traits::simd_size());
-            EXPECT_TRUE(assign_traits::forbid_simd());
-            EXPECT_FALSE(assign_traits::simd_assign());
+            EXPECT_FALSE(assign_traits::simd_linear_assign());
             EXPECT_TRUE((std::is_same<return_type, double>::value));
 #endif
         }
@@ -529,10 +456,7 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
         using assign_traits = xassign_traits<xarray<double>, decltype(f)>;
-        EXPECT_TRUE(assign_traits::convertible_types());
-        EXPECT_TRUE(assign_traits::simd_size());
-        EXPECT_FALSE(assign_traits::forbid_simd());
-        EXPECT_TRUE(assign_traits::simd_assign());
+        EXPECT_TRUE(assign_traits::simd_linear_assign());
 #endif
     }
 
@@ -568,12 +492,8 @@ namespace xt
 
 #if XTENSOR_USE_XSIMD
         using assign_traits = xassign_traits<xarray<double>, decltype(f)>;
-        EXPECT_TRUE(assign_traits::convertible_types());
-        EXPECT_TRUE(assign_traits::simd_size());
-        EXPECT_FALSE(assign_traits::forbid_simd());
-        EXPECT_TRUE(assign_traits::simd_assign());
+        EXPECT_TRUE(assign_traits::simd_linear_assign());
 #endif
-
     }
 
     TEST(xmath, cube)
@@ -667,7 +587,6 @@ namespace xt
         EXPECT_EQ(atan2(sa, b)(0, 0), std::atan2(sa, b(0, 0)));
     }
 
-
     /************************
      * Hyperbolic functions *
      ************************/
@@ -714,7 +633,6 @@ namespace xt
         EXPECT_EQ(atanh(a)(0, 0), std::atanh(a(0, 0)));
     }
 
-
     /*****************************
      * Error and gamma functions *
      *****************************/
@@ -858,7 +776,7 @@ namespace xt
     {
         xarray<double> a = {{1, 2, 3, 4}, {0, 0, 0, 0}, {3, 0, 1, 0}};
         std::size_t as = count_nonzero(a)();
-        std::size_t ase = count_nonzero(a, evaluation_strategy::immediate())();
+        std::size_t ase = count_nonzero(a, evaluation_strategy::immediate)();
         EXPECT_EQ(as, 6u);
         EXPECT_EQ(ase, 6u);
 
@@ -868,11 +786,11 @@ namespace xt
         EXPECT_EQ(count_nonzero(a, {0}), ea0);
         EXPECT_EQ(count_nonzero(a, {1}), ea1);
 
-        EXPECT_EQ(count_nonzero(a, {0}, evaluation_strategy::immediate()), ea0);
-        EXPECT_EQ(count_nonzero(a, {1}, evaluation_strategy::immediate()), ea1);
+        EXPECT_EQ(count_nonzero(a, {0}, evaluation_strategy::immediate), ea0);
+        EXPECT_EQ(count_nonzero(a, {1}, evaluation_strategy::immediate), ea1);
 
         a = random::randint<int>({5, 5, 5, 5, 5}, 10);
-        auto lm = count_nonzero(a, {0, 1, 3}, evaluation_strategy::immediate());
+        auto lm = count_nonzero(a, {0, 1, 3}, evaluation_strategy::immediate);
         auto lz = count_nonzero(a, {0, 1, 3});
         EXPECT_EQ(lm, lz);
     }
@@ -880,7 +798,7 @@ namespace xt
     TEST(xmath, diff)
     {
         xt::xarray<int> a = {1, 2, 4, 7, 0};
-        xt::xarray<int> expected1 = {1,  2,  3, -7};
+        xt::xarray<int> expected1 = {1, 2, 3, -7};
         EXPECT_EQ(xt::diff(a), expected1);
         xt::xarray<int> expected2 = {1, 1, -10};
         EXPECT_EQ(xt::diff(a, 2), expected2);
@@ -896,12 +814,22 @@ namespace xt
         EXPECT_EQ(xt::diff(c, 1), expected6);
         xt::xarray<bool> expected7({2, 1}, false);
         EXPECT_EQ(xt::diff(c, 2), expected7);
+
+        std::vector<int> d = {1, 2, 4, 7, 0};
+        xt::xarray<int> orig = {1, 2, 4, 7, 0};
+        auto ad = xt::adapt(d);
+        EXPECT_EQ(xt::diff(ad), expected1);
+        EXPECT_EQ(ad, orig);
+
+        xt::xarray<int> e = {1, 2};
+        auto expected8 = xt::xarray<int>::from_shape({0});
+        EXPECT_EQ(xt::diff(e, 2), expected8);
+        EXPECT_EQ(xt::diff(e, 5), expected8);
     }
 
     TEST(xmath, trapz)
     {
-        xt::xarray<int> a = {{0, 1, 2},
-                             {3, 4, 5}};
+        xt::xarray<int> a = {{0, 1, 2}, {3, 4, 5}};
         xt::xarray<double> expected1 = {1.5, 2.5, 3.5};
         EXPECT_EQ(trapz(a, 1.0, 0), expected1);
 
@@ -922,21 +850,179 @@ namespace xt
         EXPECT_EQ(res5[0], 8.0);
     }
 
+    /********************
+     * Mean and average *
+     ********************/
+
+    TEST(xmath, mean)
+    {
+        xt::xtensor<double, 2> v = {{1.0, 1.0, 1.0}, {2.0, 2.0, 2.0}};
+        xt::xtensor<double, 1> m0 = {1.5, 1.5, 1.5};
+        xt::xtensor<double, 1> m1 = {1.0, 2.0};
+        double m = 9.0 / 6.0;
+
+        EXPECT_TRUE(xt::all(xt::equal(xt::mean(v, 0), m0)));
+        EXPECT_TRUE(xt::all(xt::equal(xt::mean(v, {0}), m0)));
+        EXPECT_TRUE(xt::all(xt::equal(xt::mean(v, 1), m1)));
+        EXPECT_TRUE(xt::all(xt::equal(xt::mean(v, {1}), m1)));
+        EXPECT_EQ(xt::mean(v)(), m);
+        EXPECT_EQ(xt::mean(v, {0, 1})(), m);
+    }
+
+    TEST(xmath, average)
+    {
+        xt::xtensor<double, 2> v = {{1.0, 1.0, 1.0}, {2.0, 2.0, 2.0}};
+        xt::xtensor<double, 2> w = {{2.0, 2.0, 2.0}, {2.0, 2.0, 2.0}};
+        xt::xtensor<double, 1> m0 = {1.5, 1.5, 1.5};
+        xt::xtensor<double, 1> m1 = {1.0, 2.0};
+        double m = 9.0 / 6.0;
+
+        EXPECT_TRUE(xt::all(xt::equal(xt::average(v, w, 0), m0)));
+        EXPECT_TRUE(xt::all(xt::equal(xt::average(v, w, {0}), m0)));
+        EXPECT_TRUE(xt::all(xt::equal(xt::average(v, w, 1), m1)));
+        EXPECT_TRUE(xt::all(xt::equal(xt::average(v, w, {1}), m1)));
+        EXPECT_EQ(xt::average(v, w)(), m);
+        EXPECT_EQ(xt::average(v, w, {0, 1})(), m);
+    }
+
     /************************
      * Linear interpolation *
      ************************/
 
     TEST(xmath, interp)
     {
-        xt::xtensor<double,1> xp = {0.0, 1.0, 3.0};
-        xt::xtensor<double,1> fp = {0.0, 1.0, 3.0};
-        xt::xtensor<double,1> x  = {0.0, .5, 1.0, 1.5, 2.0, 2.5, 3.0};
+        xt::xtensor<double, 1> xp = {0.0, 1.0, 3.0};
+        xt::xtensor<double, 1> fp = {0.0, 1.0, 3.0};
+        xt::xtensor<double, 1> x = {0.0, .5, 1.0, 1.5, 2.0, 2.5, 3.0};
 
-        auto f = xt::interp(x,xp,fp);
+        auto f = xt::interp(x, xp, fp);
 
-        for ( std::size_t i = 0 ; i < x.size() ; ++i )
+        for (std::size_t i = 0; i < x.size(); ++i)
         {
             EXPECT_EQ(f[i], x[i]);
         }
     }
+
+    TEST(xmath, cov)
+    {
+        xt::xarray<double> x = {0.0, 1.0, 2.0};
+        xt::xarray<double> y = {2.0, 1.0, 0.0};
+        xt::xarray<double> expected = {{1.0, -1.0}, {-1.0, 1.0}};
+
+        EXPECT_EQ(expected, xt::cov(x, y));
+    }
+
+    TEST(xmath, convolve_full)
+    {
+        xt::xarray<double> x = {1.0, 3.0, 1.0};
+        xt::xarray<double> y = {1.0, 1.0, 1.0};
+        xt::xarray<double> expected = {1, 4, 5, 4, 1};
+
+        auto result = xt::convolve(x, y, xt::convolve_mode::full());
+
+        EXPECT_EQ(result, expected);
+    }
+
+    TEST(xmath, convolve_valid)
+    {
+        xt::xarray<double> x = {3.0, 1.0, 1.0};
+        xt::xarray<double> y = {1.0, 1.0, 1.0};
+        xt::xarray<double> expected = {5};
+
+        auto result = xt::convolve(x, y, xt::convolve_mode::valid());
+
+        EXPECT_EQ(result, expected);
+    }
+
+    TEST(xmath, unwrap)
+    {
+        {
+            // {0, pi / 4, pi / 2, -pi / 4, 0}
+            xt::xarray<double> expected = {0., 0.78539816, 1.57079633, -0.78539816, 0};
+            auto pi = xt::numeric_constants<double>::PI;
+            xt::xarray<double> phase = xt::linspace<double>(0, pi, 5);
+            xt::view(phase, xt::range(3, xt::xnone())) += pi;
+            auto unwrapped = xt::unwrap(phase);
+            EXPECT_TRUE(xt::allclose(expected, unwrapped));
+        }
+        {
+            xt::xarray<double> expected = {
+                -180.,
+                -140.,
+                -100.,
+                -60.,
+                -20.,
+                20.,
+                60.,
+                100.,
+                140.,
+                180.,
+                220.,
+                260.,
+                300.,
+                340.,
+                380.,
+                420.,
+                460.,
+                500.,
+                540.
+            };
+            xt::xarray<double> phase_deg = xt::fmod(xt::linspace<double>(0, 720, 19), 360) - 180;
+            auto unwrapped = xt::unwrap(phase_deg, xnone(), -1, 360.0);
+            EXPECT_TRUE(xt::allclose(expected, unwrapped));
+        }
+        {
+            xt::xarray<int> expected = {2, 3, 4, 5, 6, 7, 8, 9};
+            xt::xarray<int> phase = {2, 3, 4, 5, 2, 3, 4, 5};
+            auto unwrapped = xt::unwrap(phase, xnone(), -1, 4);
+            EXPECT_TRUE(xt::allclose(expected, unwrapped));
+        }
+    }
+
+    // Test for GitHub issue #2871: Proper handling of intermediate results
+    // This test documents the correct way to use reducers with keep_dims
+    // when intermediate expressions are needed.
+    TEST(xmath, issue_2871_intermediate_result_handling)
+    {
+        // This test verifies the correct pattern for using reducers with
+        // intermediate results. Returning a lazy expression from a function can lead
+        // to dangling references — only the returned expression must be evaluated.
+
+        // The CORRECT way: reducer results must be evaluated; element-wise lazy
+        // expressions are safe to leave as auto
+        auto logSoftmax_correct = [](const xt::xtensor<double, 2>& matrix)
+        {
+            xt::xtensor<double, 2> maxVals = xt::amax(matrix, {1}, xt::keep_dims);
+            auto shifted = matrix - maxVals;
+            auto expVals = xt::exp(shifted);
+            xt::xtensor<double, 2> sumExp = xt::sum(expVals, {1}, xt::keep_dims);
+            return xt::xtensor<double, 2>(shifted - xt::log(sumExp));
+        };
+
+        // Alternative CORRECT way: use xt::eval for reducer results
+        auto logSoftmax_eval = [](const xt::xtensor<double, 2>& matrix)
+        {
+            auto maxVals = xt::eval(xt::amax(matrix, {1}, xt::keep_dims));
+            auto shifted = matrix - maxVals;
+            auto expVals = xt::exp(shifted);
+            auto sumExp = xt::eval(xt::sum(expVals, {1}, xt::keep_dims));
+            return xt::xtensor<double, 2>(shifted - xt::log(sumExp));
+        };
+
+        // Test data
+        xt::xtensor<double, 2> input = {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}};
+
+        // Both implementations should produce the same result
+        auto result1 = logSoftmax_correct(input);
+        auto result2 = logSoftmax_eval(input);
+
+        EXPECT_TRUE(xt::allclose(result1, result2));
+
+        // Verify the result is a valid log-softmax (rows sum to 0 in log space)
+        // exp(log_softmax).sum(axis=1) should equal 1
+        auto exp_result = xt::exp(result1);
+        auto row_sums = xt::sum(exp_result, {1});
+        xt::xtensor<double, 1> expected_sums = {1.0, 1.0};
+        EXPECT_TRUE(xt::allclose(row_sums, expected_sums));
+    }
 }
diff --git a/test/test_xmath_result_type.cpp b/test/test_xmath_result_type.cpp
new file mode 100644
index 000000000..333d0fb07
--- /dev/null
+++ b/test/test_xmath_result_type.cpp
@@ -0,0 +1,310 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <complex>
+
+#include "test_common_macros.hpp"
+
+// The following disables the conversion warnings. These warnings
+// are legit and we don't want to avoid them with specific cast
+// in xtensor implementation. However, we still want to check the
+// results are correct and we don't want the warnings to pollute
+// the output when building the tests suite.
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wfloat-conversion"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#pragma GCC diagnostic pop
+#elif defined(_WIN32)
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4267)
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#pragma warning(pop)
+#else
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#endif
+
+#include "xtl/xtype_traits.hpp"
+
+namespace xt
+{
+    using std::size_t;
+    using shape_type = dynamic_shape<size_t>;
+
+    /*******************
+     * type conversion *
+     *******************/
+
+#define CHECK_RESULT_TYPE(EXPRESSION, EXPECTED_TYPE)                                 \
+    {                                                                                \
+        using result_type = typename std::decay_t<decltype(EXPRESSION)>::value_type; \
+        EXPECT_TRUE((std::is_same<result_type, EXPECTED_TYPE>::value));              \
+    }
+
+    template <class T1, class T2>
+    using promote_t = xtl::promote_type_t<T1, T2>;
+
+    template <class T, class E>
+    void check_promoted_types(E&& e)
+    {
+        using result_type = typename std::decay_t<decltype(e)>::value_type;
+        EXPECT_TRUE((std::is_same<result_type, promote_t<T, result_type>>::value));
+    }
+
+#define ARRAY_TYPE(VALUE_TYPE) std::array<VALUE_TYPE, 2>
+
+#define CHECK_TEMPLATED_RESULT_TYPE(FUNC, INPUT)                               \
+    check_promoted_types<unsigned char>(FUNC<unsigned char>(INPUT));           \
+    check_promoted_types<signed char>(FUNC<signed char>(INPUT));               \
+    check_promoted_types<char>(FUNC<char>(INPUT));                             \
+    check_promoted_types<unsigned short>(FUNC<unsigned short>(INPUT));         \
+    check_promoted_types<signed short>(FUNC<signed short>(INPUT));             \
+    check_promoted_types<short>(FUNC<short>(INPUT));                           \
+    check_promoted_types<unsigned int>(FUNC<unsigned int>(INPUT));             \
+    check_promoted_types<signed int>(FUNC<signed int>(INPUT));                 \
+    check_promoted_types<int>(FUNC<int>(INPUT));                               \
+    check_promoted_types<unsigned long long>(FUNC<unsigned long long>(INPUT)); \
+    check_promoted_types<long long>(FUNC<signed long long>(INPUT));            \
+    check_promoted_types<long long>(FUNC<long long>(INPUT));                   \
+    check_promoted_types<float>(FUNC<float>(INPUT));                           \
+    check_promoted_types<double>(FUNC<double>(INPUT));
+
+#define CHECK_STDDEV_TEMPLATED_RESULT_TYPE(FUNC, INPUT)                                             \
+    {                                                                                               \
+        using result_type = typename std::decay_t<decltype(INPUT)>::value_type;                     \
+        using promo_type = std::conditional_t<std::is_integral<result_type>::value, double, float>; \
+                                                                                                    \
+        check_promoted_types<promo_type>(FUNC<unsigned char>(INPUT));                               \
+        check_promoted_types<promo_type>(FUNC<signed char>(INPUT));                                 \
+        check_promoted_types<promo_type>(FUNC<char>(INPUT));                                        \
+        check_promoted_types<promo_type>(FUNC<unsigned short>(INPUT));                              \
+        check_promoted_types<promo_type>(FUNC<signed short>(INPUT));                                \
+        check_promoted_types<promo_type>(FUNC<short>(INPUT));                                       \
+        check_promoted_types<promo_type>(FUNC<unsigned int>(INPUT));                                \
+        check_promoted_types<promo_type>(FUNC<signed int>(INPUT));                                  \
+        check_promoted_types<promo_type>(FUNC<int>(INPUT));                                         \
+        check_promoted_types<promo_type>(FUNC<unsigned long long>(INPUT));                          \
+        check_promoted_types<promo_type>(FUNC<signed long long>(INPUT));                            \
+        check_promoted_types<promo_type>(FUNC<long long>(INPUT));                                   \
+        check_promoted_types<float>(FUNC<float>(INPUT));                                            \
+        check_promoted_types<double>(FUNC<double>(INPUT));                                          \
+    }
+
+#define CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(INPUT) \
+    CHECK_TEMPLATED_RESULT_TYPE(sum, INPUT)        \
+    CHECK_TEMPLATED_RESULT_TYPE(mean, INPUT)       \
+    CHECK_TEMPLATED_RESULT_TYPE(prod, INPUT)       \
+    CHECK_TEMPLATED_RESULT_TYPE(variance, INPUT)   \
+    CHECK_STDDEV_TEMPLATED_RESULT_TYPE(stddev, INPUT)
+
+    TEST(xmath, uchar_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto auchar = xt::zeros<unsigned char>(shape);
+
+        CHECK_RESULT_TYPE(auchar + auchar, int);
+        CHECK_RESULT_TYPE(2 * auchar, int);
+        CHECK_RESULT_TYPE(2.0 * auchar, double);
+        CHECK_RESULT_TYPE(sqrt(auchar), double);
+        CHECK_RESULT_TYPE(abs(auchar), unsigned char);
+        CHECK_RESULT_TYPE(sum(auchar), int);
+        CHECK_RESULT_TYPE(mean(auchar), double);
+        CHECK_RESULT_TYPE(minmax(auchar), ARRAY_TYPE(unsigned char));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(auchar);
+    }
+
+    TEST(xmath, short_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto ashort = xt::zeros<short>(shape);
+
+        CHECK_RESULT_TYPE(ashort + ashort, int);
+        CHECK_RESULT_TYPE(2 * ashort, int);
+        CHECK_RESULT_TYPE(2.0 * ashort, double);
+        CHECK_RESULT_TYPE(sqrt(ashort), double);
+        CHECK_RESULT_TYPE(abs(ashort), decltype(std::abs(short{})));
+        CHECK_RESULT_TYPE(sum(ashort), int);
+        CHECK_RESULT_TYPE(mean(ashort), double);
+        CHECK_RESULT_TYPE(minmax(ashort), ARRAY_TYPE(short));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(ashort);
+    }
+
+    TEST(xmath, ushort_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto aushort = xt::zeros<unsigned short>(shape);
+
+        CHECK_RESULT_TYPE(aushort + aushort, int);
+        CHECK_RESULT_TYPE(2u * aushort, unsigned int);
+        CHECK_RESULT_TYPE(2.0 * aushort, double);
+        CHECK_RESULT_TYPE(sqrt(aushort), double);
+        CHECK_RESULT_TYPE(abs(aushort), unsigned short);
+        CHECK_RESULT_TYPE(sum(aushort), int);
+        CHECK_RESULT_TYPE(mean(aushort), double);
+        CHECK_RESULT_TYPE(minmax(aushort), ARRAY_TYPE(unsigned short));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aushort);
+    }
+
+    TEST(xmath, int_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto aint = xt::zeros<int>(shape);
+
+        CHECK_RESULT_TYPE(aint + aint, int);
+        CHECK_RESULT_TYPE(2 * aint, int);
+        CHECK_RESULT_TYPE(2.0 * aint, double);
+        CHECK_RESULT_TYPE(sqrt(aint), double);
+        CHECK_RESULT_TYPE(abs(aint), int);
+        CHECK_RESULT_TYPE(sum(aint), int);
+        CHECK_RESULT_TYPE(mean(aint), double);
+        CHECK_RESULT_TYPE(minmax(aint), ARRAY_TYPE(int));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aint);
+    }
+
+    TEST(xmath, uint_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto auint = xt::zeros<unsigned int>(shape);
+
+        CHECK_RESULT_TYPE(auint + auint, unsigned int);
+        CHECK_RESULT_TYPE(2u * auint, unsigned int);
+        CHECK_RESULT_TYPE(2.0 * auint, double);
+        CHECK_RESULT_TYPE(sqrt(auint), double);
+        CHECK_RESULT_TYPE(abs(auint), unsigned int);
+        CHECK_RESULT_TYPE(sum(auint), unsigned int);
+        CHECK_RESULT_TYPE(mean(auint), double);
+        CHECK_RESULT_TYPE(minmax(auint), ARRAY_TYPE(unsigned int));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(auint);
+    }
+
+    TEST(xmath, long_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto along = xt::zeros<long long>(shape);
+
+        CHECK_RESULT_TYPE(along + along, signed long long);
+        CHECK_RESULT_TYPE(2 * along, signed long long);
+        CHECK_RESULT_TYPE(2.0 * along, double);
+        CHECK_RESULT_TYPE(sqrt(along), double);
+        CHECK_RESULT_TYPE(abs(along), signed long long);
+        CHECK_RESULT_TYPE(sum(along), signed long long);
+        CHECK_RESULT_TYPE(mean(along), double);
+        CHECK_RESULT_TYPE(minmax(along), ARRAY_TYPE(signed long long));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(along);
+    }
+
+    TEST(xmath, ulong_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto aulong = xt::zeros<unsigned long long>(shape);
+
+        CHECK_RESULT_TYPE(aulong + aulong, unsigned long long);
+        CHECK_RESULT_TYPE(2ul * aulong, unsigned long long);
+        CHECK_RESULT_TYPE(2.0 * aulong, double);
+        CHECK_RESULT_TYPE(sqrt(aulong), double);
+        CHECK_RESULT_TYPE(abs(aulong), unsigned long long);
+        CHECK_RESULT_TYPE(sum(aulong), unsigned long long);
+        CHECK_RESULT_TYPE(mean(aulong), double);
+        CHECK_RESULT_TYPE(minmax(aulong), ARRAY_TYPE(unsigned long long));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aulong);
+    }
+
+    TEST(xmath, float_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto afloat = xt::zeros<float>(shape);
+
+        CHECK_RESULT_TYPE(afloat + afloat, float);
+        CHECK_RESULT_TYPE(2.0f * afloat, float);
+        CHECK_RESULT_TYPE(2.0 * afloat, double);
+        CHECK_RESULT_TYPE(sqrt(afloat), float);
+        CHECK_RESULT_TYPE(abs(afloat), float);
+        CHECK_RESULT_TYPE(sum(afloat), float);
+        CHECK_RESULT_TYPE(mean(afloat), double);
+        CHECK_RESULT_TYPE(minmax(afloat), ARRAY_TYPE(float));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(afloat);
+    }
+
+    TEST(xmath, double_result_type)
+    {
+        shape_type shape = {3, 2};
+        auto adouble = xt::zeros<double>(shape);
+
+        CHECK_RESULT_TYPE(adouble + adouble, double);
+        CHECK_RESULT_TYPE(2.0 * adouble, double);
+        CHECK_RESULT_TYPE(sqrt(adouble), double);
+        CHECK_RESULT_TYPE(abs(adouble), double);
+        CHECK_RESULT_TYPE(sum(adouble), double);
+        CHECK_RESULT_TYPE(mean(adouble), double);
+        CHECK_RESULT_TYPE(minmax(adouble), ARRAY_TYPE(double));
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(adouble);
+    }
+
+    TEST(xmath, float_complex_result_type)
+    {
+        shape_type shape = {3, 2};
+        xarray<std::complex<float>> afcomplex(shape);
+
+        CHECK_RESULT_TYPE(afcomplex + afcomplex, std::complex<float>);
+        CHECK_RESULT_TYPE(std::complex<float>(2.0) * afcomplex, std::complex<float>);
+        CHECK_RESULT_TYPE(2.0f * afcomplex, std::complex<float>);
+        CHECK_RESULT_TYPE(sqrt(afcomplex), std::complex<float>);
+        CHECK_RESULT_TYPE(abs(afcomplex), float);
+        CHECK_RESULT_TYPE(sum(afcomplex), std::complex<float>);
+        CHECK_RESULT_TYPE(mean(afcomplex), std::complex<double>);
+    }
+
+    TEST(xmath, double_complex_result_type)
+    {
+        shape_type shape = {3, 2};
+        xarray<std::complex<double>> adcomplex(shape);
+
+        CHECK_RESULT_TYPE(adcomplex + adcomplex, std::complex<double>);
+        CHECK_RESULT_TYPE(std::complex<double>(2.0) * adcomplex, std::complex<double>);
+        CHECK_RESULT_TYPE(2.0 * adcomplex, std::complex<double>);
+        CHECK_RESULT_TYPE(sqrt(adcomplex), std::complex<double>);
+        CHECK_RESULT_TYPE(abs(adcomplex), double);
+        CHECK_RESULT_TYPE(sum(adcomplex), std::complex<double>);
+        CHECK_RESULT_TYPE(mean(adcomplex), std::complex<double>);
+    }
+
+    TEST(xmath, mixed_result_type)
+    {
+        shape_type shape = {3, 2};
+        xarray<unsigned char> auchar(shape);
+        xarray<short> ashort(shape);
+        xarray<unsigned short> aushort(shape);
+        xarray<int> aint(shape);
+        xarray<unsigned int> auint(shape);
+        xarray<long long> along(shape);
+        xarray<unsigned long long> aulong(shape);
+        xarray<float> afloat(shape);
+        xarray<double> adouble(shape);
+        xarray<std::complex<float>> afcomplex(shape);
+        xarray<std::complex<double>> adcomplex(shape);
+
+        CHECK_RESULT_TYPE(auchar + aint, int);
+        CHECK_RESULT_TYPE(ashort + aint, int);
+        CHECK_RESULT_TYPE(aulong + aint, unsigned long long);
+        CHECK_RESULT_TYPE(afloat + aint, float);
+        CHECK_RESULT_TYPE(adouble + aint, double);
+        CHECK_RESULT_TYPE(adouble + adcomplex, std::complex<double>);
+        CHECK_RESULT_TYPE(aulong + adouble, double);
+        CHECK_RESULT_TYPE(afcomplex + adcomplex, std::complex<double>);
+    }
+}
diff --git a/test/test_xmime.cpp b/test/test_xmime.cpp
new file mode 100644
index 000000000..cad7dc7d4
--- /dev/null
+++ b/test/test_xmime.cpp
@@ -0,0 +1,35 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <iostream>
+
+#include <nlohmann/json.hpp>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/io/xmime.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    TEST(xmime, xarray_two_d)
+    {
+        xarray<double> e{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+
+        nlohmann::json ser = mime_bundle_repr_impl(e);
+
+        nlohmann::json ref = {
+            {"text/html",
+             "<table style='border-style:solid;border-width:1px;'><tbody><tr><td style='font-family:monospace;' title='(0, 0)'><pre>  1.</pre></td><td style='font-family:monospace;' title='(0, 1)'><pre>  2.</pre></td><td style='font-family:monospace;' title='(0, 2)'><pre>  3.</pre></td><td style='font-family:monospace;' title='(0, 3)'><pre>  4.</pre></td></tr><tr><td style='font-family:monospace;' title='(1, 0)'><pre>  5.</pre></td><td style='font-family:monospace;' title='(1, 1)'><pre>  6.</pre></td><td style='font-family:monospace;' title='(1, 2)'><pre>  7.</pre></td><td style='font-family:monospace;' title='(1, 3)'><pre>  8.</pre></td></tr><tr><td style='font-family:monospace;' title='(2, 0)'><pre>  9.</pre></td><td style='font-family:monospace;' title='(2, 1)'><pre> 10.</pre></td><td style='font-family:monospace;' title='(2, 2)'><pre> 11.</pre></td><td style='font-family:monospace;' title='(2, 3)'><pre> 12.</pre></td></tr></tbody></table>"
+            }
+        };
+
+        EXPECT_EQ(ser, ref);
+    }
+}
diff --git a/test/test_xmultiindex_iterator.cpp b/test/test_xmultiindex_iterator.cpp
new file mode 100644
index 000000000..ced5e97e7
--- /dev/null
+++ b/test/test_xmultiindex_iterator.cpp
@@ -0,0 +1,41 @@
+#include <vector>
+
+#include "xtensor/core/xmultiindex_iterator.hpp"
+
+#include "test_common.hpp"
+
+namespace xt
+{
+
+    TEST_SUITE("xmultiindex_iterator")
+    {
+        TEST_CASE("sum")
+        {
+            using shape_type = std::vector<std::size_t>;
+            using iter_type = xmultiindex_iterator<shape_type>;
+
+            shape_type roi_begin{2, 3, 4};
+            shape_type roi_end{3, 5, 6};
+            shape_type current{2, 3, 4};
+            iter_type iter(roi_begin, roi_end, current, 0);
+
+
+            iter_type end(roi_begin, roi_end, roi_end, 4);
+
+            shape_type should(3);
+            for (should[0] = roi_begin[0]; should[0] < roi_end[0]; ++should[0])
+            {
+                for (should[1] = roi_begin[1]; should[1] < roi_end[1]; ++should[1])
+                {
+                    for (should[2] = roi_begin[2]; should[2] < roi_end[2]; ++should[2])
+                    {
+                        EXPECT_EQ(*iter, should);
+                        ++iter;
+                    }
+                }
+            }
+            EXPECT_TRUE(iter == end);
+        }
+    }
+
+}
diff --git a/test/test_xnan_functions.cpp b/test/test_xnan_functions.cpp
index fbbf3ca95..1de36245e 100644
--- a/test/test_xnan_functions.cpp
+++ b/test/test_xnan_functions.cpp
@@ -1,36 +1,82 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xmath.hpp"
-#include "xtensor/xstrided_view.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "test_common_macros.hpp"
+
+#if (defined(__GNUC__) && !defined(__clang__))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#include "xtensor/core/xmath.hpp"
+#pragma GCC diagnostic pop
+#endif
+
+#include <xtensor/views/xindex_view.hpp>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/views/xstrided_view.hpp"
+
+#include "xtl/xtype_traits.hpp"
 
 namespace xt
 {
+    using namespace std::complex_literals;
     static const double nanv = std::nan("0");
+    static const double d_min = std::numeric_limits<double>::min();
+    static const double d_max = std::numeric_limits<double>::max();
+
+#define NAN_SENSITIVE_EQ(E1, E2, PLACE_HOLDER)             \
+    EXPECT_EQ(xt::isnan(E1), xt::equal(E2, PLACE_HOLDER)); \
+    EXPECT_EQ(xt::filter(E1, !xt::isnan(E1)), xt::filter(E2, xt::not_equal(E2, PLACE_HOLDER)));
+
     namespace nantest
     {
-        xarray<double> aN = {{ nanv, nanv, 123, 3 }, { 1, 2, nanv, 3 }, { 1, 1, nanv, 3 }};
-        xarray<double> aR = {{ 0, 0, 123 , 3 }, { 1, 2, 0 , 3}, { 1, 1, 0, 3 }};
-        xarray<double> aP = {{ 1, 1, 123 , 3}, { 1, 2, 1, 3 }, { 1, 1, 1, 3 }};
+        xarray<double> aN = {{nanv, nanv, 123, 3}, {1, 2, nanv, 3}, {1, 1, nanv, 3}};
+        xarray<double> aR = {{0, 0, 123, 3}, {1, 2, 0, 3}, {1, 1, 0, 3}};
+        xarray<double> aP = {{1, 1, 123, 3}, {1, 2, 1, 3}, {1, 1, 1, 3}};
+        xarray<double> aI = {{d_max, d_max, 123, 3}, {1, 2, d_max, 3}, {1, 1, d_max, 3}};
+        xarray<double> aA = {{d_min, d_min, 123, 3}, {1, 2, d_min, 3}, {1, 1, d_min, 3}};
+
+        xarray<double> xN = {{{nanv, nanv}, {1, 2}}, {{3, nanv}, {nanv, 5}}};
+        xarray<double> xR = {{{0, 0}, {1, 2}}, {{3, 0}, {0, 5}}};
+        xarray<double> xP = {{{1, 1}, {1, 2}}, {{3, 1}, {1, 5}}};
+        xarray<double> xI = {{{d_max, d_max}, {1, 2}}, {{3, d_max}, {d_max, 5}}};
+        xarray<double> xA = {{{d_min, d_min}, {1, 2}}, {{3, d_min}, {d_min, 5}}};
+
+        xarray<std::complex<double>> cN = {{1.0 + 1.0i, 1.0 + 1.0i, nanv}, {1.0 - 1.0i, 1.0, 3.0 + 2.0i}};
+
+    }
+
+    TEST(xnanfunctions, count_nonnan)
+    {
+        xarray<double> a = {{0, 1, 2, 3}, {nanv, nanv, nanv, nanv}, {3, nanv, 1, nanv}};
+        std::size_t as = count_nonnan(a)();
+        std::size_t ase = count_nonnan(a, evaluation_strategy::immediate)();
+        EXPECT_EQ(as, 6u);
+        EXPECT_EQ(ase, 6u);
+
+        xarray<std::size_t> ea0 = {2, 1, 2, 1};
+        xarray<std::size_t> ea1 = {4, 0, 2};
+
+        EXPECT_EQ(count_nonnan(a, {0}), ea0);
+        EXPECT_EQ(count_nonnan(a, {1}), ea1);
 
-        xarray<double> xN = {{{nanv, nanv}, {1,2}}, {{3, nanv}, {nanv, 5}}};
-        xarray<double> xR = {{{0, 0}, {1,2}}, {{3, 0}, {0, 5}}};
-        xarray<double> xP = {{{1, 1}, {1,2}}, {{3, 1}, {1, 5}}};
+        EXPECT_EQ(count_nonnan(a, {0}, evaluation_strategy::immediate), ea0);
+        EXPECT_EQ(count_nonnan(a, {1}, evaluation_strategy::immediate), ea1);
     }
 
     TEST(xnanfunctions, nan_to_num)
     {
         double neg_inf = -std::numeric_limits<double>::infinity();
         double inf = std::numeric_limits<double>::infinity();
-        xarray<double> a = {{ nanv, nanv, 123}, {0.5123, neg_inf, inf}};
+        xarray<double> a = {{nanv, nanv, 123}, {0.5123, neg_inf, inf}};
 
         auto expr = nan_to_num(a);
         EXPECT_EQ(expr(0, 0), 0);
@@ -41,11 +87,42 @@ namespace xt
         EXPECT_TRUE(expr(1, 1) < 0);
         EXPECT_EQ(expr(1, 2), std::numeric_limits<double>::max());
 
-        xarray<double> exp = {{ 0, 0, 123 }, {0.5123, std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() }};
+        xarray<double> exp = {
+            {0, 0, 123},
+            {0.5123, std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max()}
+        };
         xarray<double> assigned = exp;
         EXPECT_EQ(assigned, exp);
     }
 
+    TEST(xnanfunctions, nanmin)
+    {
+        EXPECT_EQ(nanmin(nantest::aN), amin(nantest::aI));
+        EXPECT_EQ(nanmin(nantest::aN, {0}), amin(nantest::aI, {0}));
+        EXPECT_EQ(nanmin(nantest::aN, {1}), amin(nantest::aI, {1}));
+
+        for (size_t i = 0; i < 3; ++i)
+        {
+            auto ret = nanmin(nantest::xN, {i});
+            auto reference = amin(nantest::xI, {i});
+            NAN_SENSITIVE_EQ(ret, reference, d_max)
+        }
+    }
+
+    TEST(xnanfunctions, nanmax)
+    {
+        EXPECT_EQ(nanmax(nantest::aN), amax(nantest::aA));
+        EXPECT_EQ(nanmax(nantest::aN, {0}), amax(nantest::aA, {0}));
+        EXPECT_EQ(nanmax(nantest::aN, {1}), amax(nantest::aA, {1}));
+
+        for (size_t i = 0; i < 3; ++i)
+        {
+            auto ret = nanmax(nantest::xN, {i});
+            auto reference = amax(nantest::xA, {i});
+            NAN_SENSITIVE_EQ(ret, reference, d_min)
+        }
+    }
+
     TEST(xnanfunctions, nansum)
     {
         xarray<double> res = nansum(nantest::aN);
@@ -107,4 +184,177 @@ namespace xt
         EXPECT_EQ(nancumprod(nantest::xN, 2), cumprod(nantest::xP, 2));
     }
 
+    TEST(xnanfunctions, nanmean)
+    {
+        auto as = nanmean(nantest::aN)();
+        auto ase = nanmean(nantest::aN, evaluation_strategy::immediate)();
+        EXPECT_DOUBLE_EQ(as, 17.125);
+        EXPECT_DOUBLE_EQ(ase, 17.125);
+
+        xarray<double> eaN0 = {1.0, 1.5, 123, 3};
+        xarray<double> eaN1 = {63.0, 2.0, 5.0 / 3.0};
+
+        EXPECT_TENSOR_EQ(nanmean(nantest::aN, {0}), eaN0);
+        EXPECT_TENSOR_EQ(nanmean(nantest::aN, {1}), eaN1);
+
+        std::array<std::size_t, 1> axis{0};
+        EXPECT_EQ(nanmean(nantest::aN, axis), eaN0);
+
+        EXPECT_TENSOR_EQ(nanmean(nantest::aN, {0}, evaluation_strategy::immediate), eaN0);
+        EXPECT_TENSOR_EQ(nanmean(nantest::aN, {1}, evaluation_strategy::immediate), eaN1);
+
+        auto cs = nanmean(nantest::cN)();
+        auto cse = nanmean(nantest::cN, evaluation_strategy::immediate)();
+        EXPECT_DOUBLE_EQ(cs, std::complex<double>(1.4, 0.6));
+        EXPECT_DOUBLE_EQ(cse, std::complex<double>(1.4, 0.6));
+
+        xarray<std::complex<double>> ecN0 = {1.0 + 0.0i, 1.0 + 0.5i, 3.0 + 2.0i};
+        xarray<std::complex<double>> ecN1 = {1.0 + 1.0i, (5.0 + 1.0i) / 3.0};
+
+        EXPECT_TENSOR_EQ(nanmean(nantest::cN, {0}), ecN0);
+        EXPECT_TENSOR_EQ(nanmean(nantest::cN, {1}), ecN1);
+
+        EXPECT_TENSOR_EQ(nanmean(nantest::cN, {0}, evaluation_strategy::immediate), ecN0);
+        EXPECT_TENSOR_EQ(nanmean(nantest::cN, {1}, evaluation_strategy::immediate), ecN1);
+    }
+
+    TEST(xnanfunctions, nanvar)
+    {
+        auto as = nanvar(nantest::aN)();
+        auto ase = nanvar(nantest::aN, evaluation_strategy::immediate)();
+        EXPECT_EQ(as, 1602.109375);
+        EXPECT_EQ(ase, 1602.109375);
+
+        xarray<double> eaN0 = {0.0, 0.25, 0.0, 0.0};
+        xarray<double> eaN1 = {3600.0, 2.0 / 3.0, 8.0 / 9.0};
+
+        EXPECT_EQ(nanvar(nantest::aN, {0}), eaN0);
+        EXPECT_TRUE(allclose(nanvar(nantest::aN, {1}), eaN1));
+
+        std::array<std::size_t, 1> axis{0};
+        EXPECT_EQ(nanvar(nantest::aN, axis), eaN0);
+
+        EXPECT_EQ(nanvar(nantest::aN, {0}, evaluation_strategy::immediate), eaN0);
+        EXPECT_TRUE(allclose(nanvar(nantest::aN, {1}, evaluation_strategy::immediate), eaN1));
+    }
+
+    using shape_type = dynamic_shape<size_t>;
+
+    /*******************
+     * type conversion *
+     *******************/
+
+#define CHECK_RESULT_TYPE(EXPRESSION, EXPECTED_TYPE)                                 \
+    {                                                                                \
+        using result_type = typename std::decay_t<decltype(EXPRESSION)>::value_type; \
+        EXPECT_TRUE((std::is_same<result_type, EXPECTED_TYPE>::value));              \
+    }
+
+    TEST(xnanfunctions, result_type)
+    {
+        shape_type shape = {4, 3, 2};
+        xarray<short> ashort(shape);
+        xarray<unsigned short> aushort(shape);
+        xarray<int> aint(shape);
+        xarray<unsigned int> auint(shape);
+        xarray<long long> along(shape);
+        xarray<unsigned long long> aulong(shape);
+        xarray<float> afloat(shape);
+        xarray<double> adouble(shape);
+
+#define CHECK_RESULT_TYPE_FOR_ALL(INPUT, RESULT_TYPE, MINMAX_TYPE) \
+    CHECK_RESULT_TYPE(nansum(INPUT, {1, 2}), RESULT_TYPE);         \
+    CHECK_RESULT_TYPE(nanmean(INPUT, {1, 2}), double);             \
+    CHECK_RESULT_TYPE(nanvar(INPUT, {1, 2}), double);              \
+    CHECK_RESULT_TYPE(nanstd(INPUT, {1, 2}), double);              \
+    CHECK_RESULT_TYPE(nanmin(INPUT, {1, 2}), MINMAX_TYPE);         \
+    CHECK_RESULT_TYPE(nanmax(INPUT, {1, 2}), MINMAX_TYPE);
+
+#define CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(INPUT, TEMPLATE_TYPE, RESULT_TYPE, STD_TYPE, MINMAX_TYPE) \
+    CHECK_RESULT_TYPE(nansum<TEMPLATE_TYPE>(INPUT, {1, 2}), RESULT_TYPE)                              \
+    CHECK_RESULT_TYPE(nanmean<TEMPLATE_TYPE>(INPUT, {1, 2}), RESULT_TYPE)                             \
+    CHECK_RESULT_TYPE(nanvar<TEMPLATE_TYPE>(INPUT, {1, 2}), RESULT_TYPE)                              \
+    CHECK_RESULT_TYPE(nanstd<TEMPLATE_TYPE>(INPUT, {1, 2}), STD_TYPE)                                 \
+    CHECK_RESULT_TYPE(nanmin<TEMPLATE_TYPE>(INPUT, {1, 2}), MINMAX_TYPE)                              \
+    CHECK_RESULT_TYPE(nanmax<TEMPLATE_TYPE>(INPUT, {1, 2}), MINMAX_TYPE)
+
+        /*********
+         * short *
+         *********/
+        CHECK_RESULT_TYPE_FOR_ALL(ashort, int, short);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(ashort, short, int, double, short);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(ashort, int, int, double, int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(ashort, double, double, double, double);
+
+        /******************
+         * unsigned short *
+         ******************/
+        CHECK_RESULT_TYPE_FOR_ALL(aushort, int, unsigned short);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aushort, unsigned short, int, double, unsigned short);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aushort, int, int, double, int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aushort, double, double, double, double);
+
+        /*********
+         * int *
+         *********/
+        CHECK_RESULT_TYPE_FOR_ALL(aint, int, int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aint, unsigned short, int, double, int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aint, int, int, double, int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aint, double, double, double, double);
+
+        /****************
+         * unsigned int *
+         ****************/
+        CHECK_RESULT_TYPE_FOR_ALL(auint, unsigned int, unsigned int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(auint, unsigned int, unsigned int, double, unsigned int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(auint, unsigned int, unsigned int, double, unsigned int);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(auint, double, double, double, double);
+
+        /**********************
+         * long long *
+         **********************/
+#ifndef SKIP_ON_WERROR
+        // intermediate computation done in double may imply precision loss
+        CHECK_RESULT_TYPE_FOR_ALL(along, signed long long, signed long long);
+#endif
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(along, int, signed long long, double, signed long long);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(along, long, signed long long, double, signed long long);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(along, signed long long, signed long long, double, signed long long);
+
+        /**********************
+         * unsigned long long *
+         **********************/
+#ifndef SKIP_ON_WERROR
+        // intermediate computation done in double may imply precision loss
+        CHECK_RESULT_TYPE_FOR_ALL(aulong, unsigned long long, unsigned long long);
+#endif
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aulong, unsigned int, unsigned long long, double, unsigned long long);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(aulong, unsigned long, unsigned long long, double, unsigned long long);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(
+            aulong,
+            unsigned long long,
+            unsigned long long,
+            double,
+            unsigned long long
+        );
+
+        /*********
+         * float *
+         *********/
+        CHECK_RESULT_TYPE_FOR_ALL(afloat, float, float);
+#ifndef SKIP_ON_WERROR
+        // final conversion to int may imply conversion loss
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(afloat, int, float, float, float);
+#endif
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(afloat, float, float, float, float);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(afloat, double, double, double, double);
+
+        /**********
+         * double *
+         **********/
+        CHECK_RESULT_TYPE_FOR_ALL(adouble, double, double);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(adouble, float, double, double, double);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(adouble, double, double, double, double);
+        CHECK_TEMPLATED_RESULT_TYPE_FOR_ALL(adouble, long double, long double, long double, long double);
+    }
 }
diff --git a/test/test_xnoalias.cpp b/test/test_xnoalias.cpp
index 133f1fecc..18e4e0c0b 100644
--- a/test/test_xnoalias.cpp
+++ b/test/test_xnoalias.cpp
@@ -1,16 +1,18 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xview.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 #include "test_xsemantic.hpp"
 
 namespace xt
@@ -23,347 +25,349 @@ namespace xt
         using storage_type = C;
     };
 
-    using testing_types = ::testing::Types<xarray_dynamic, xtensor_dynamic>;
-    TYPED_TEST_CASE(xnoalias, testing_types);
+#define XNOALIAS_TEST_TYPES xarray_dynamic, xtensor_dynamic
 
-    TYPED_TEST(xnoalias, a_plus_b)
+    TEST_SUITE("xnoalias")
     {
-        operation_tester<std::plus<>, TypeParam> tester;
+        TEST_CASE_TEMPLATE("a_plus_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::plus<>, TypeParam> tester;
+
+            SUBCASE("row_major + row_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a + tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major + column_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a + tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major + central_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a + tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major + unit_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a + tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_minus_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::minus<>, TypeParam> tester;
+
+            SUBCASE("row_major - row_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a - tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major - column_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a - tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major - central_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a - tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major - unit_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a - tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_multiplies_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::multiplies<>, TypeParam> tester;
+
+            SUBCASE("row_major * row_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a * tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major * column_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a * tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major * central_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a * tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major * unit_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a * tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_divides_by_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::divides<>, TypeParam> tester;
+
+            SUBCASE("row_major / row_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a / tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major / column_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a / tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major / central_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a / tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major / unit_major")
+            {
+                TypeParam b(tester.ca.shape(), 0);
+                noalias(b) = tester.a / tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_plus_equal_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::plus<>, TypeParam> tester;
+
+            SUBCASE("row_major += row_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) += tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major += column_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) += tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major += central_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) += tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major += unit_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) += tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_minus_equal_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::minus<>, TypeParam> tester;
+
+            SUBCASE("row_major -= row_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) -= tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major -= column_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) -= tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major -= central_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) -= tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major -= unit_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) -= tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_times_equal_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::multiplies<>, TypeParam> tester;
+
+            SUBCASE("row_major *= row_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) *= tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major *= column_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) *= tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major *= central_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) *= tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major *= unit_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) *= tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_divide_by_equal_b", TypeParam, XNOALIAS_TEST_TYPES)
+        {
+            operation_tester<std::divides<>, TypeParam> tester;
+
+            SUBCASE("row_major /= row_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) /= tester.ra;
+                EXPECT_EQ(tester.res_rr, b);
+            }
+
+            SUBCASE("row_major /= column_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) /= tester.ca;
+                EXPECT_EQ(tester.res_rc, b);
+            }
+
+            SUBCASE("row_major /= central_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) /= tester.cta;
+                EXPECT_EQ(tester.res_rct, b);
+            }
+
+            SUBCASE("row_major /= unit_major")
+            {
+                TypeParam b = tester.a;
+                noalias(b) /= tester.ua;
+                EXPECT_EQ(tester.res_ru, b);
+            }
+        }
+
+        TEST_CASE("scalar_ops")
+        {
+            xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+            xarray<int> b = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+            xarray<int> c = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+
+            xscalar<int> one(1), five(5), twelve(12), seven(7), bhalf(0b00001111), bxor(0b01001111);
+
+            xt::noalias(a) += 1;
+            b += 1;
+            xt::noalias(c) += one;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) -= 5;
+            b -= 5;
+            xt::noalias(c) -= five;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) *= 12;
+            b *= 12;
+            xt::noalias(c) *= twelve;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) /= 7;
+            b /= 7;
+            xt::noalias(c) /= seven;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) %= 7;
+            b %= 7;
+            xt::noalias(c) %= seven;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) &= 0b00001111;
+            b &= 0b00001111;
+            xt::noalias(c) &= bhalf;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) |= 0b00001111;
+            b |= 0b00001111;
+            xt::noalias(c) |= bhalf;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) ^= 0b01001111;
+            b ^= 0b01001111;
+            xt::noalias(c) ^= bxor;
+            EXPECT_EQ(a, b);
+            EXPECT_EQ(a, c);
+
+            xt::noalias(a) = 123;
+            b = 123;
 
-        {
-            SCOPED_TRACE("row_major + row_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a + tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major + column_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a + tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major + central_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a + tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
+            EXPECT_EQ(a, b);
+        }
 
+        TEST_CASE("rvalue")
         {
-            SCOPED_TRACE("row_major + unit_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a + tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TYPED_TEST(xnoalias, a_minus_b)
-    {
-        operation_tester<std::minus<>, TypeParam> tester;
+            xarray<int> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+            xarray<int> b = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
 
-        {
-            SCOPED_TRACE("row_major - row_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a - tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major - column_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a - tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major - central_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a - tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major - unit_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a - tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TYPED_TEST(xnoalias, a_multiplies_b)
-    {
-        operation_tester<std::multiplies<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major * row_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a * tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major * column_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a * tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major * central_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a * tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major * unit_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a * tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TYPED_TEST(xnoalias, a_divides_by_b)
-    {
-        operation_tester<std::divides<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major / row_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a / tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major / column_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a / tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major / central_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a / tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major / unit_major");
-            TypeParam b(tester.ca.shape(), 0);
-            noalias(b) = tester.a / tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TYPED_TEST(xnoalias, a_plus_equal_b)
-    {
-        operation_tester<std::plus<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major += row_major");
-            TypeParam b = tester.a;
-            noalias(b) += tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major += column_major");
-            TypeParam b = tester.a;
-            noalias(b) += tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
+            xt::noalias(xt::view(a, 1)) += 10;
+            xt::view(b, 1) += 10;
+
+            EXPECT_EQ(a, b);
+
+            xt::noalias(xt::view(a, 1)) = 10;
+            xt::view(b, 1) = 10;
+            EXPECT_EQ(a, b);
         }
-
-        {
-            SCOPED_TRACE("row_major += central_major");
-            TypeParam b = tester.a;
-            noalias(b) += tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major += unit_major");
-            TypeParam b = tester.a;
-            noalias(b) += tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TYPED_TEST(xnoalias, a_minus_equal_b)
-    {
-        operation_tester<std::minus<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major -= row_major");
-            TypeParam b = tester.a;
-            noalias(b) -= tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major -= column_major");
-            TypeParam b = tester.a;
-            noalias(b) -= tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major -= central_major");
-            TypeParam b = tester.a;
-            noalias(b) -= tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major -= unit_major");
-            TypeParam b = tester.a;
-            noalias(b) -= tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TYPED_TEST(xnoalias, a_times_equal_b)
-    {
-        operation_tester<std::multiplies<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major *= row_major");
-            TypeParam b = tester.a;
-            noalias(b) *= tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major *= column_major");
-            TypeParam b = tester.a;
-            noalias(b) *= tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major *= central_major");
-            TypeParam b = tester.a;
-            noalias(b) *= tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major *= unit_major");
-            TypeParam b = tester.a;
-            noalias(b) *= tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TYPED_TEST(xnoalias, a_divide_by_equal_b)
-    {
-        operation_tester<std::divides<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major /= row_major");
-            TypeParam b = tester.a;
-            noalias(b) /= tester.ra;
-            EXPECT_EQ(tester.res_rr, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major /= column_major");
-            TypeParam b = tester.a;
-            noalias(b) /= tester.ca;
-            EXPECT_EQ(tester.res_rc, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major /= central_major");
-            TypeParam b = tester.a;
-            noalias(b) /= tester.cta;
-            EXPECT_EQ(tester.res_rct, b);
-        }
-
-        {
-            SCOPED_TRACE("row_major /= unit_major");
-            TypeParam b = tester.a;
-            noalias(b) /= tester.ua;
-            EXPECT_EQ(tester.res_ru, b);
-        }
-    }
-
-    TEST(xnoalias, scalar_ops)
-    {
-        xarray<int> a = {{1,2,3}, {4,5,6}, {7,8,9}};
-        xarray<int> b = {{1,2,3}, {4,5,6}, {7,8,9}};
-        xarray<int> c = {{1,2,3}, {4,5,6}, {7,8,9}};
-
-        xscalar<int> one(1), five(5), twelve(12), seven(7), bhalf(0b00001111), bxor(0b01001111);
-
-        xt::noalias(a) += 1;
-        b += 1;
-        xt::noalias(c) += one;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) -= 5;
-        b -= 5;
-        xt::noalias(c) -= five;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) *= 12;
-        b *= 12;
-        xt::noalias(c) *= twelve;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) /= 7;
-        b /= 7;
-        xt::noalias(c) /= seven;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) %= 7;
-        b %= 7;
-        xt::noalias(c) %= seven;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) &= 0b00001111;
-        b &= 0b00001111;
-        xt::noalias(c) &= bhalf;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) |= 0b00001111;
-        b |= 0b00001111;
-        xt::noalias(c) |= bhalf;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) ^= 0b01001111;
-        b ^= 0b01001111;
-        xt::noalias(c) ^= bxor;
-        EXPECT_EQ(a, b);
-        EXPECT_EQ(a, c);
-
-        xt::noalias(a) = 123;
-        b = 123;
-
-        EXPECT_EQ(a, b);
-    }
-
-    TEST(xnoalias, rvalue)
-    {
-        xarray<int> a = {{1,2,3}, {4,5,6}, {7,8,9}};
-        xarray<int> b = {{1,2,3}, {4,5,6}, {7,8,9}};
-
-        xt::noalias(xt::view(a, 1)) += 10;
-        xt::view(b, 1) += 10;
-
-        EXPECT_EQ(a, b);
-
-        xt::noalias(xt::view(a, 1)) = 10;
-        xt::view(b, 1) = 10;
-        EXPECT_EQ(a, b);
     }
 }
diff --git a/test/test_xnorm.cpp b/test/test_xnorm.cpp
index 9242b0318..632114530 100644
--- a/test/test_xnorm.cpp
+++ b/test/test_xnorm.cpp
@@ -1,22 +1,43 @@
 /***************************************************************************
-* Copyright (c) 2017, Ullrich Koethe                                       *
-*                                                                          *
-* Distributed under the terms of the BSD 3-Clause License.                 *
-*                                                                          *
-* The full license is in the file LICENSE, distributed with this software. *
-****************************************************************************/
-
-#include "gtest/gtest.h"
-#include "xtensor/xnorm.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xview.hpp"
-#include "xtensor/xnoalias.hpp"
+ * 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. *
+ ****************************************************************************/
 
 #include <limits>
 
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/reducers/xnorm.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
+
 namespace xt
 {
+    TEST(xnorm, norm_traits)
+    {
+        EXPECT_TRUE((std::is_same<norm_type_t<uint8_t>, int>::value));
+        EXPECT_TRUE((std::is_same<norm_type_t<int>, int>::value));
+        EXPECT_TRUE((std::is_same<norm_type_t<double>, double>::value));
+        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<uint8_t>>, double>::value));
+        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<int>>, double>::value));
+        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<double>>, double>::value));
+        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<long double>>, long double>::value));
+
+        EXPECT_TRUE((std::is_same<squared_norm_type_t<uint8_t>, int>::value));
+        EXPECT_TRUE((std::is_same<squared_norm_type_t<int>, int>::value));
+        EXPECT_TRUE((std::is_same<squared_norm_type_t<double>, double>::value));
+        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<uint8_t>>, uint64_t>::value));
+        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<int>>, uint64_t>::value));
+        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<double>>, double>::value));
+        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<long double>>, long double>::value));
+    }
+
     TEST(xnorm, scalar)
     {
         EXPECT_EQ(norm_l0(2), 1u);
@@ -86,52 +107,69 @@ namespace xt
         EXPECT_EQ(norm_lp(a, 2.0)(), 3.0);
         EXPECT_EQ(norm_linf(a)(), 1);
 
-        EXPECT_EQ(norm_l0(a, evaluation_strategy::immediate())(), 9u);
-        EXPECT_EQ(norm_lp_to_p(a, 0.0, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_l1(a, evaluation_strategy::immediate())(), 9);
-        EXPECT_EQ(norm_lp(a, 1.0, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_sq(a, evaluation_strategy::immediate())(), 9);
-        EXPECT_EQ(norm_l2(a, evaluation_strategy::immediate())(), 3.0);
-        EXPECT_EQ(norm_lp(a, 2.0, evaluation_strategy::immediate())(), 3.0);
-        EXPECT_EQ(norm_linf(a, evaluation_strategy::immediate())(), 1);
+        EXPECT_EQ(norm_l0(a, evaluation_strategy::immediate)(), 9u);
+        EXPECT_EQ(norm_lp_to_p(a, 0.0, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_l1(a, evaluation_strategy::immediate)(), 9);
+        EXPECT_EQ(norm_lp(a, 1.0, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_sq(a, evaluation_strategy::immediate)(), 9);
+        EXPECT_EQ(norm_l2(a, evaluation_strategy::immediate)(), 3.0);
+        EXPECT_EQ(norm_lp(a, 2.0, evaluation_strategy::immediate)(), 3.0);
+        EXPECT_EQ(norm_linf(a, evaluation_strategy::immediate)(), 1);
     }
 
     TEST(xnorm, complex_array)
     {
         xarray<std::complex<double>> a = -ones<std::complex<double>>({9});
 
-        EXPECT_EQ(norm_l0(a)(), 9u);
-        EXPECT_EQ(norm_lp_to_p(a, 0.0)(), 9.0);
-        EXPECT_EQ(norm_l1(a)(), 9.0);
-        EXPECT_EQ(norm_lp(a, 1.0)(), 9.0);
-        EXPECT_EQ(norm_sq(a)(), 9.0);
-        EXPECT_EQ(norm_l2(a)(), 3.0);
-        EXPECT_EQ(norm_lp(a, 2.0)(), 3.0);
-        EXPECT_EQ(norm_linf(a)(), 1.0);
-
-        EXPECT_EQ(norm_l0(a, {0}, evaluation_strategy::immediate())(), 9u);
-        EXPECT_EQ(norm_lp_to_p(a, 0.0, {0}, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_l1(a, {0}, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_lp(a, 1.0, {0}, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_sq(a, {0}, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_l2(a, {0}, evaluation_strategy::immediate())(), 3.0);
-        EXPECT_EQ(norm_lp(a, 2.0, {0}, evaluation_strategy::immediate())(), 3.0);
-        EXPECT_EQ(norm_linf(a, {0}, evaluation_strategy::immediate())(), 1.0);
-
-        EXPECT_EQ(norm_l0(a, {0}, evaluation_strategy::immediate())(), 9u);
-        EXPECT_EQ(norm_lp_to_p(a, 0.0, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_l1(a, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_lp(a, 1.0, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_sq(a, evaluation_strategy::immediate())(), 9.0);
-        EXPECT_EQ(norm_l2(a, evaluation_strategy::immediate())(), 3.0);
-        EXPECT_EQ(norm_lp(a, 2.0, evaluation_strategy::immediate())(), 3.0);
-        EXPECT_EQ(norm_linf(a, evaluation_strategy::immediate())(), 1.0);
+        auto l0_res = norm_l0(a)();
+        auto lp_to_p_res = norm_lp_to_p(a, 0.0)();
+        auto l1_res = norm_l1(a)();
+        auto lp_res1 = norm_lp(a, 1.0)();
+        auto sq_res = norm_sq(a)();
+        auto l2_res = norm_l2(a)();
+        auto lp_res2 = norm_lp(a, 2.0)();
+        auto linf_res = norm_linf(a)();
+
+        EXPECT_TRUE((std::is_same<decltype(l0_res), long long unsigned int>::value));
+        EXPECT_TRUE((std::is_same<decltype(lp_to_p_res), double>::value));
+        EXPECT_TRUE((std::is_same<decltype(l1_res), double>::value));
+        EXPECT_TRUE((std::is_same<decltype(lp_res1), double>::value));
+        EXPECT_TRUE((std::is_same<decltype(sq_res), double>::value));
+        EXPECT_TRUE((std::is_same<decltype(l2_res), double>::value));
+        EXPECT_TRUE((std::is_same<decltype(lp_res2), double>::value));
+        EXPECT_TRUE((std::is_same<decltype(linf_res), double>::value));
+
+        EXPECT_EQ(l0_res, 9u);
+        EXPECT_EQ(lp_to_p_res, 9.0);
+        EXPECT_EQ(l1_res, 9.0);
+        EXPECT_EQ(lp_res1, 9.0);
+        EXPECT_EQ(sq_res, 9.0);
+        EXPECT_EQ(l2_res, 3.0);
+        EXPECT_EQ(lp_res2, 3.0);
+        EXPECT_EQ(linf_res, 1.0);
+
+        EXPECT_EQ(norm_l0(a, {0}, evaluation_strategy::immediate)(), 9u);
+        EXPECT_EQ(norm_lp_to_p(a, 0.0, {0}, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_l1(a, {0}, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_lp(a, 1.0, {0}, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_sq(a, {0}, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_l2(a, {0}, evaluation_strategy::immediate)(), 3.0);
+        EXPECT_EQ(norm_lp(a, 2.0, {0}, evaluation_strategy::immediate)(), 3.0);
+        EXPECT_EQ(norm_linf(a, {0}, evaluation_strategy::immediate)(), 1.0);
+
+        EXPECT_EQ(norm_l0(a, {0}, evaluation_strategy::immediate)(), 9u);
+        EXPECT_EQ(norm_lp_to_p(a, 0.0, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_l1(a, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_lp(a, 1.0, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_sq(a, evaluation_strategy::immediate)(), 9.0);
+        EXPECT_EQ(norm_l2(a, evaluation_strategy::immediate)(), 3.0);
+        EXPECT_EQ(norm_lp(a, 2.0, evaluation_strategy::immediate)(), 3.0);
+        EXPECT_EQ(norm_linf(a, evaluation_strategy::immediate)(), 1.0);
     }
 
     TEST(xnorm, matrix)
     {
-        xarray<double> a = {{ -1.0, 2.0},
-                            { -3.0, 4.0}};
+        xarray<double> a = {{-1.0, 2.0}, {-3.0, 4.0}};
 
         EXPECT_EQ(norm_l0(a)(), 4u);
         EXPECT_EQ(norm_l1(a)(), 10.0);
@@ -140,11 +178,11 @@ namespace xt
         EXPECT_EQ(norm_induced_l1(a)(), 6.0);
         EXPECT_EQ(norm_induced_linf(a)(), 7.0);
 
-        EXPECT_EQ(norm_l0(a, evaluation_strategy::immediate())(), 4u);
-        EXPECT_EQ(norm_l1(a, evaluation_strategy::immediate())(), 10.0);
-        EXPECT_EQ(norm_sq(a, evaluation_strategy::immediate())(), 30.0);
-        EXPECT_EQ(norm_linf(a, evaluation_strategy::immediate())(), 4.0);
-        EXPECT_EQ(norm_induced_l1(a, evaluation_strategy::immediate())(), 6.0);
-        EXPECT_EQ(norm_induced_linf(a, evaluation_strategy::immediate())(), 7.0);
+        EXPECT_EQ(norm_l0(a, evaluation_strategy::immediate)(), 4u);
+        EXPECT_EQ(norm_l1(a, evaluation_strategy::immediate)(), 10.0);
+        EXPECT_EQ(norm_sq(a, evaluation_strategy::immediate)(), 30.0);
+        EXPECT_EQ(norm_linf(a, evaluation_strategy::immediate)(), 4.0);
+        EXPECT_EQ(norm_induced_l1(a, evaluation_strategy::immediate)(), 6.0);
+        EXPECT_EQ(norm_induced_linf(a, evaluation_strategy::immediate)(), 7.0);
     }
 }  // namespace xt
diff --git a/test/test_xnpy.cpp b/test/test_xnpy.cpp
index 1d89ace51..ea40fd989 100644
--- a/test/test_xnpy.cpp
+++ b/test/test_xnpy.cpp
@@ -1,119 +1,179 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
+#include <cstdint>
+#include <fstream>
 
-#include "xtensor/xnpy.hpp"
-#include "xtensor/xarray.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/io/xnpy.hpp"
 
-#include <fstream>
-#include <cstdint>
+#include "test_common_macros.hpp"
 
 namespace xt
 {
+    std::string get_load_filename(const std::string& npy_prefix, layout_type lt = layout_type::row_major)
+    {
+        std::string lts = lt == layout_type::row_major ? "" : "_fortran";
+        std::string endianness;
+        switch (xtl::endianness())
+        {
+            case xtl::endian::big_endian:
+                endianness = ".be";
+                break;
+            case xtl::endian::little_endian:
+                endianness = ".le";
+                break;
+            case xtl::endian::mixed:
+                endianness = ".unsupported";
+                break;
+        }
+        return npy_prefix + lts + endianness + ".npy";
+    }
+
     TEST(xnpy, load)
     {
-        xarray<double> darr = {{{ 0.29731723,  0.04380157,  0.94748308},
-                                { 0.85020643,  0.52958618,  0.0598172 },
-                                { 0.77253259,  0.47564231,  0.70274005}},
-                               {{ 0.85998447,  0.61160158,  0.44432939},
-                                { 0.25506765,  0.97420976,  0.15455842},
-                                { 0.05873659,  0.66191764,  0.01448838}},
-                               {{ 0.175919  ,  0.13850365,  0.94059426},
-                                { 0.79941809,  0.5124432 ,  0.51364796},
-                                { 0.25721979,  0.41608858,  0.06255319}}};
-
-        xarray<bool> barr = {{{ 0, 0, 1},
-                              { 1, 1, 0},
-                              { 1, 0, 1}},
-                             {{ 1, 1, 0},
-                              { 0, 1, 0},
-                              { 0, 1, 0}},
-                             {{ 0, 0, 1},
-                              { 1, 1, 1},
-                              { 0, 0, 0}}};
-
-        auto darr_loaded = load_npy<double>("files/xnpy_files/double.npy");
+        xarray<double> darr = {
+            {{0.29731723, 0.04380157, 0.94748308},
+             {0.85020643, 0.52958618, 0.0598172},
+             {0.77253259, 0.47564231, 0.70274005}},
+            {{0.85998447, 0.61160158, 0.44432939},
+             {0.25506765, 0.97420976, 0.15455842},
+             {0.05873659, 0.66191764, 0.01448838}},
+            {{0.175919, 0.13850365, 0.94059426},
+             {0.79941809, 0.5124432, 0.51364796},
+             {0.25721979, 0.41608858, 0.06255319}}
+        };
+
+        xarray<bool> barr = {
+            {{0, 0, 1}, {1, 1, 0}, {1, 0, 1}},
+            {{1, 1, 0}, {0, 1, 0}, {0, 1, 0}},
+            {{0, 0, 1}, {1, 1, 1}, {0, 0, 0}}
+        };
+
+        xarray<int> iarr1d = {3, 4, 5, 6, 7};
+
+        auto darr_loaded = load_npy<double>(get_load_filename("files/xnpy_files/double"));
         EXPECT_TRUE(all(isclose(darr, darr_loaded)));
 
-        auto barr_loaded = load_npy<bool>("files/xnpy_files/bool.npy");
+        std::ifstream dstream(get_load_filename("files/xnpy_files/double"));
+        auto darr_loaded_stream = load_npy<double>(dstream);
+        CHECK_MESSAGE(all(isclose(darr, darr_loaded_stream)), "Loading double NumPy array from stream failed");
+        dstream.close();
+
+        auto barr_loaded = load_npy<bool>(get_load_filename("files/xnpy_files/bool"));
         EXPECT_TRUE(all(equal(barr, barr_loaded)));
 
-        auto dfarr_loaded = load_npy<double, layout_type::column_major>("files/xnpy_files/double_fortran.npy");
+        std::ifstream bstream(get_load_filename("files/xnpy_files/bool"));
+        auto barr_loaded_stream = load_npy<bool>(bstream);
+        CHECK_MESSAGE(all(equal(barr, barr_loaded_stream)), "Loading boolean NumPy array from stream failed");
+        bstream.close();
+
+        auto dfarr_loaded = load_npy<double, layout_type::column_major>(
+            get_load_filename("files/xnpy_files/double_fortran")
+        );
         EXPECT_TRUE(all(isclose(darr, dfarr_loaded)));
+
+        auto iarr1d_loaded = load_npy<int>(get_load_filename("files/xnpy_files/int"));
+        EXPECT_TRUE(all(equal(iarr1d, iarr1d_loaded)));
+    }
+
+    TEST(xnpy, npy_file_move)
+    {
+        xarray<bool> barr = {
+            {{0, 0, 1}, {1, 1, 0}, {1, 0, 1}},
+            {{1, 1, 0}, {0, 1, 0}, {0, 1, 0}},
+            {{0, 0, 1}, {1, 1, 1}, {0, 0, 0}}
+        };
+
+        std::ifstream bstream(get_load_filename("files/xnpy_files/bool"));
+        detail::npy_file npy = detail::load_npy_file(bstream);
+        auto barr_cast = npy.cast<bool>(true);
+        EXPECT_TRUE(all(equal(barr, barr_cast)));
+
+        detail::npy_file npy_move;
+        npy_move = std::move(npy);
+        auto barr_cast_move = npy_move.cast<bool>(true);
+        EXPECT_TRUE(all(equal(barr, barr_cast_move)));
     }
 
     bool compare_binary_files(std::string fn1, std::string fn2)
     {
         std::ifstream stream1(fn1, std::ios::in | std::ios::binary);
-        std::vector<uint8_t> fn1_contents((std::istreambuf_iterator<char>(stream1)),
-                                          std::istreambuf_iterator<char>());
+        std::vector<uint8_t> fn1_contents(
+            (std::istreambuf_iterator<char>(stream1)),
+            std::istreambuf_iterator<char>()
+        );
 
         std::ifstream stream2(fn2, std::ios::in | std::ios::binary);
-        std::vector<uint8_t> fn2_contents((std::istreambuf_iterator<char>(stream2)),
-                                          std::istreambuf_iterator<char>());
-        return std::equal(fn1_contents.begin(), fn1_contents.end(), fn2_contents.begin()) &&
-            fn1_contents.size() == fn2_contents.size();
+        std::vector<uint8_t> fn2_contents(
+            (std::istreambuf_iterator<char>(stream2)),
+            std::istreambuf_iterator<char>()
+        );
+        return std::equal(fn1_contents.begin(), fn1_contents.end(), fn2_contents.begin())
+               && fn1_contents.size() == fn2_contents.size();
     }
 
-    std::string get_filename()
+    std::string get_dump_filename(int n)
     {
-        std::string filename = std::tmpnam(nullptr);
-        filename += ".npy";
+        std::string filename = "files/xnpy_files/test_dump_" + std::to_string(n) + ".npy";
         return filename;
     }
 
+    std::string read_file(const std::string& name)
+    {
+        return static_cast<const std::stringstream&>(std::stringstream() << std::ifstream(name).rdbuf()).str();
+    }
+
     TEST(xnpy, dump)
     {
-        std::string filename = get_filename();
-        xarray<bool> barr = {{{0, 0, 1},
-                              {1, 1, 0},
-                              {1, 0, 1}},
-                             {{1, 1, 0},
-                              {0, 1, 0},
-                              {0, 1, 0}},
-                             {{0, 0, 1},
-                              {1, 1, 1},
-                              {0, 0, 0}}};
+        std::string filename = get_dump_filename(0);
+        xarray<bool> barr = {
+            {{0, 0, 1}, {1, 1, 0}, {1, 0, 1}},
+            {{1, 1, 0}, {0, 1, 0}, {0, 1, 0}},
+            {{0, 0, 1}, {1, 1, 1}, {0, 0, 0}}
+        };
 
         xtensor<uint64_t, 1> ularr = {12ul, 14ul, 16ul, 18ul, 1234321ul};
         dump_npy(filename, barr);
 
-        std::string compare_name = "files/xnpy_files/bool.npy";
-        if (barr.layout() == layout_type::column_major)
-        {
-            compare_name = "files/xnpy_files/bool_fortran.npy";
-        }
+        std::string compare_name = get_load_filename("files/xnpy_files/bool", barr.layout());
 
         EXPECT_TRUE(compare_binary_files(filename, compare_name));
+
+        std::string barr_str = dump_npy(barr);
+        std::string barr_disk = read_file(compare_name);
+        CHECK_MESSAGE(barr_str == barr_disk, "Dumping boolean NumPy file to string failed");
+
         std::remove(filename.c_str());
 
-        filename = get_filename();
+        filename = get_dump_filename(1);
         dump_npy(filename, ularr);
         auto ularrcpy = load_npy<uint64_t>(filename);
         EXPECT_TRUE(all(equal(ularr, ularrcpy)));
 
-        compare_name = "files/xnpy_files/unsignedlong.npy";
-        if (barr.layout() == layout_type::column_major)
-        {
-            compare_name = "files/xnpy_files/unsignedlong_fortran.npy";
-        }
+        compare_name = get_load_filename("files/xnpy_files/unsignedlong", barr.layout());
 
         EXPECT_TRUE(compare_binary_files(filename, compare_name));
+
+        std::string ularr_str = dump_npy(ularr);
+        std::string ularr_disk = read_file(compare_name);
+        CHECK_MESSAGE(ularr_str == ularr_disk, "Dumping boolean NumPy file to string failed");
+
         std::remove(filename.c_str());
     }
 
     TEST(xnpy, xfunction_cast)
     {
-        // compilation test, cf: https://github.com/QuantStack/xtensor/issues/1070
-        auto dc = cast<char>(load_npy<double>("files/xnpy_files/double.npy"));
+        // compilation test, cf: https://github.com/xtensor-stack/xtensor/issues/1070
+        auto dc = cast<char>(load_npy<double>(get_load_filename("files/xnpy_files/double")));
         EXPECT_EQ(dc(0, 0), 0);
         xarray<char> adc = dc;
         EXPECT_EQ(adc(0, 0), 0);
     }
-}
\ No newline at end of file
+}
diff --git a/test/test_xoperation.cpp b/test/test_xoperation.cpp
index 3998e0677..21a9c77bd 100644
--- a/test/test_xoperation.cpp
+++ b/test/test_xoperation.cpp
@@ -1,16 +1,21 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
 
 #include <cstddef>
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/optional/xoptional_assembly.hpp"
+
+#include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -50,112 +55,40 @@ namespace xt
         using rebind_container_t = typename rebind_container<C, T>::type;
     }
 
-    template <class C>
-    class operation : public ::testing::Test
+    class my_double
     {
     public:
-        using storage_type = C;
-    };
-
-    using testing_types = ::testing::Types<xarray<double>, xtensor<double, 2>>;
-    TYPED_TEST_CASE(operation, testing_types);
-
-    TYPED_TEST(operation, plus)
-    {
-        using shape_type = typename TypeParam::shape_type;
-        shape_type shape = {3, 2};
-        TypeParam a(shape, 4.5);
-        double ref = +(a(0, 0));
-        double actual = (+a)(0, 0);
-        EXPECT_EQ(ref, actual);
-    }
-
-    TYPED_TEST(operation, minus)
-    {
-        using shape_type = typename TypeParam::shape_type;
-        shape_type shape = {3, 2};
-        TypeParam a(shape, 4.5);
-        double ref = -(a(0, 0));
-        double actual = (-a)(0, 0);
-        EXPECT_EQ(ref, actual);
-    }
-
-    TYPED_TEST(operation, add)
-    {
-        using shape_type = typename TypeParam::shape_type;
-        shape_type shape = {3, 2};
-        TypeParam a(shape, 4.5);
-        TypeParam b(shape, 1.3);
-        EXPECT_EQ((a + b)(0, 0), a(0, 0) + b(0, 0));
-
-        double sb = 1.2;
-        EXPECT_EQ((a + sb)(0, 0), a(0, 0) + sb);
 
-        double sa = 4.6;
-        EXPECT_EQ((sa + b)(0, 0), sa + b(0, 0));
-    }
-
-    TYPED_TEST(operation, subtract)
-    {
-        using shape_type = typename TypeParam::shape_type;
-        shape_type shape = {3, 2};
-        TypeParam a(shape, 4.5);
-        TypeParam b(shape, 1.3);
-        EXPECT_EQ((a - b)(0, 0), a(0, 0) - b(0, 0));
-
-        double sb = 1.2;
-        EXPECT_EQ((a - sb)(0, 0), a(0, 0) - sb);
-
-        double sa = 4.6;
-        EXPECT_EQ((sa - b)(0, 0), sa - b(0, 0));
-    }
+        my_double(double d = 0.)
+            : m_value(d)
+        {
+        }
 
-    TYPED_TEST(operation, multiply)
-    {
-        using shape_type = typename TypeParam::shape_type;
-        shape_type shape = {3, 2};
-        TypeParam a(shape, 4.5);
-        TypeParam b(shape, 1.3);
-        EXPECT_EQ((a * b)(0, 0), a(0, 0) * b(0, 0));
+        double& operator+=(double rhs)
+        {
+            m_value += rhs;
+            return m_value;
+        }
 
-        double sb = 1.2;
-        EXPECT_EQ((a * sb)(0, 0), a(0, 0) * sb);
+    private:
 
-        double sa = 4.6;
-        EXPECT_EQ((sa * b)(0, 0), sa * b(0, 0));
-    }
+        double m_value;
+    };
 
-    TYPED_TEST(operation, divide)
+    double operator+(double rhs, my_double lhs)
     {
-        using shape_type = typename TypeParam::shape_type;
-        shape_type shape = {3, 2};
-        TypeParam a(shape, 4.5);
-        TypeParam b(shape, 1.3);
-        EXPECT_EQ((a / b)(0, 0), a(0, 0) / b(0, 0));
-
-        double sb = 1.2;
-        EXPECT_EQ((a / sb)(0, 0), a(0, 0) / sb);
-
-        double sa = 4.6;
-        EXPECT_EQ((sa / b)(0, 0), sa / b(0, 0));
+        my_double tmp(lhs);
+        return tmp += rhs;
     }
 
-    TYPED_TEST(operation, modulus)
+    template <class C>
+    class operation : public ::testing::Test
     {
-        using int_container = xop_test::rebind_container_t<TypeParam, int>;
-        using shape_type = typename int_container::shape_type;
-
-        shape_type shape = {3, 2};
-        int_container a(shape, 11);
-        int_container b(shape, 3);
-        EXPECT_EQ((a % b)(0, 0), a(0, 0) % b(0, 0));
+    public:
 
-        int sb = 3;
-        EXPECT_EQ((a % sb)(0, 0), a(0, 0) % sb);
+        using storage_type = C;
+    };
 
-        int sa = 11;
-        EXPECT_EQ((sa % b)(0, 0), sa % b(0, 0));
-    }
 
     template <class T>
     struct int_rebind;
@@ -175,510 +108,781 @@ namespace xt
     template <class T>
     using int_rebind_t = typename int_rebind<T>::type;
 
-    TYPED_TEST(operation, bitwise_and)
+    struct vtype
     {
-        using int_tensor = int_rebind_t<TypeParam>;
-        using shape_type = typename int_tensor::shape_type;
-        shape_type shape = {3, 2};
-        int_tensor a(shape, 14);
-        int_tensor b(shape, 15);
-        EXPECT_EQ((a & b)(0, 0), a(0, 0) & b(0, 0));
-
-        int sb = 48;
-        EXPECT_EQ((a & sb)(0, 0), a(0, 0) & sb);
-
-        int sa = 24;
-        EXPECT_EQ((sa & b)(0, 0), sa & b(0, 0));
-    }
+        double a = 0;
+        size_t b = 0;
 
-    TYPED_TEST(operation, bitwise_or)
-    {
-        using int_tensor = int_rebind_t<TypeParam>;
-        using shape_type = typename int_tensor::shape_type;
-        shape_type shape = {3, 2};
-        int_tensor a(shape, 14);
-        int_tensor b(shape, 15);
-        EXPECT_EQ((a | b)(0, 0), a(0, 0) | b(0, 0));
-
-        int sb = 48;
-        EXPECT_EQ((a | sb)(0, 0), a(0, 0) | sb);
-
-        int sa = 24;
-        EXPECT_EQ((sa | b)(0, 0), sa | b(0, 0));
-    }
+        explicit operator double() const
+        {
+            return a;
+        }
+    };
 
-    TYPED_TEST(operation, bitwise_xor)
-    {
-        using int_tensor = int_rebind_t<TypeParam>;
-        using shape_type = typename int_tensor::shape_type;
-        shape_type shape = {3, 2};
-        int_tensor a(shape, 14);
-        int_tensor b(shape, 15);
-        EXPECT_EQ((a ^ b)(0, 0), a(0, 0) ^ b(0, 0));
-
-        int sb = 48;
-        EXPECT_EQ((a ^ sb)(0, 0), a(0, 0) ^ sb);
-
-        int sa = 24;
-        EXPECT_EQ((sa ^ b)(0, 0), sa ^ b(0, 0));
-    }
+    using xarray_type = xarray<double>;
+    using xtensor_2_type = xtensor<double, 2>;
 
-    TYPED_TEST(operation, bitwise_not)
-    {
-        using int_tensor = int_rebind_t<TypeParam>;
-        using shape_type = typename int_tensor::shape_type;
-        shape_type shape = {3, 2};
-        int_tensor a(shape, 15);
-        EXPECT_EQ((~a)(0, 0), ~(a(0, 0)));
-    }
+#define XOPERATION_TEST_TYPES xarray_type, xtensor_2_type
 
-    TYPED_TEST(operation, less)
+    TEST_SUITE("operation")
     {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        container_1d a = {1, 2, 3, 4, 5};
-        bool_container expected = {1, 1, 1, 0, 0};
-        bool_container b = a < 4;
-        EXPECT_EQ(expected, b);
-    }
+        TEST_CASE_TEMPLATE("plus", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using shape_type = typename TypeParam::shape_type;
+            shape_type shape = {3, 2};
+            TypeParam a(shape, 4.5);
+            double ref = +(a(0, 0));
+            double actual = (+a)(0, 0);
+            EXPECT_EQ(ref, actual);
+        }
 
-    TYPED_TEST(operation, less_equal)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        container_1d a = {1, 2, 3, 4, 5};
-        bool_container expected = {1, 1, 1, 1, 0};
-        bool_container b = a <= 4;
-        EXPECT_EQ(expected, b);
-    }
+        TEST_CASE_TEMPLATE("minus", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using shape_type = typename TypeParam::shape_type;
+            shape_type shape = {3, 2};
+            TypeParam a(shape, 4.5);
+            double ref = -(a(0, 0));
+            double actual = (-a)(0, 0);
+            EXPECT_EQ(ref, actual);
+        }
 
-    TYPED_TEST(operation, greater)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        container_1d a = {1, 2, 3, 4, 5};
-        bool_container expected = {0, 0, 0, 0, 1};
-        bool_container b = a > 4;
-        EXPECT_EQ(expected, b);
-    }
+        TEST_CASE_TEMPLATE("add", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using shape_type = typename TypeParam::shape_type;
+            shape_type shape = {3, 2};
+            TypeParam a(shape, 4.5);
+            TypeParam b(shape, 1.3);
+            EXPECT_EQ((a + b)(0, 0), a(0, 0) + b(0, 0));
 
-    TYPED_TEST(operation, greater_equal)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        container_1d a = {1, 2, 3, 4, 5};
-        bool_container expected = {0, 0, 0, 1, 1};
-        bool_container b = a >= 4;
-        EXPECT_EQ(expected, b);
-    }
+            double sb = 1.2;
+            EXPECT_EQ((a + sb)(0, 0), a(0, 0) + sb);
 
-    TYPED_TEST(operation, negate)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        container_1d a = {1, 2, 3, 4, 5};
-        bool_container expected = {1, 1, 1, 0, 0};
-        bool_container b = !(a >= 4);
-        EXPECT_EQ(expected, b);
-    }
+            double sa = 4.6;
+            EXPECT_EQ((sa + b)(0, 0), sa + b(0, 0));
+        }
 
-    TYPED_TEST(operation, equal)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        container_1d a = {1, 2, 3, 4, 5};
-        bool_container expected = {0, 0, 0, 1, 0};
-        bool_container b = equal(a, 4);
-        EXPECT_EQ(expected, b);
-
-        container_1d other = {1, 2, 3, 0, 0};
-        bool_container b_2 = equal(a, other);
-        bool_container expected_2 = {1, 1, 1, 0, 0};
-        EXPECT_EQ(expected_2, b_2);
-    }
+        TEST_CASE_TEMPLATE("subtract", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using shape_type = typename TypeParam::shape_type;
+            shape_type shape = {3, 2};
+            TypeParam a(shape, 4.5);
+            TypeParam b(shape, 1.3);
+            EXPECT_EQ((a - b)(0, 0), a(0, 0) - b(0, 0));
 
-    TYPED_TEST(operation, not_equal)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        container_1d a = {1, 2, 3, 4, 5};
-        bool_container expected = {1, 1, 1, 0, 1};
-        bool_container b = not_equal(a, 4);
-        EXPECT_EQ(expected, b);
-
-        container_1d other = {1, 2, 3, 0, 0};
-        bool_container b_2 = not_equal(a, other);
-        bool_container expected_2 = {0, 0, 0, 1, 1};
-        EXPECT_EQ(expected_2, b_2);
-    }
+            double sb = 1.2;
+            EXPECT_EQ((a - sb)(0, 0), a(0, 0) - sb);
 
-    TYPED_TEST(operation, logical_and)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        bool_container a = {0, 0, 0, 1, 0};
-        bool_container expected = {0, 0, 0, 0, 0};
-        bool_container b = a && false;
-        bool_container c = a && a;
-        EXPECT_EQ(expected, b);
-        EXPECT_EQ(c, a);
-    }
+            double sa = 4.6;
+            EXPECT_EQ((sa - b)(0, 0), sa - b(0, 0));
+        }
 
-    TYPED_TEST(operation, logical_or)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using bool_container = xop_test::rebind_container_t<container_1d, bool>;
-        bool_container a = {0, 0, 0, 1, 0};
-        bool_container other = {0, 0, 0, 0, 0};
-        bool_container b = a || other;
-        bool_container c = a || false;
-        bool_container d = a || true;
-        EXPECT_EQ(b, a);
-        EXPECT_EQ(c, a);
-
-        bool_container expected = {1, 1, 1, 1, 1};
-        EXPECT_EQ(expected, d);
-    }
+        TEST_CASE_TEMPLATE("multiply", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using shape_type = typename TypeParam::shape_type;
+            shape_type shape = {3, 2};
+            TypeParam a(shape, 4.5);
+            TypeParam b(shape, 1.3);
+            EXPECT_EQ((a * b)(0, 0), a(0, 0) * b(0, 0));
 
-    TYPED_TEST(operation, any)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container = xop_test::rebind_container_t<container_1d, int>;
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        int_container a = {0, 0, 3};
-        EXPECT_EQ(true, any(a));
-        int_container_2d b = {{0, 0, 0}, {0, 0, 0}};
-        EXPECT_EQ(false, any(b));
-    }
+            double sb = 1.2;
+            EXPECT_EQ((a * sb)(0, 0), a(0, 0) * sb);
 
-    TYPED_TEST(operation, minimum)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container = xop_test::rebind_container_t<container_1d, int>;
-        int_container a = {0, 0, 3};
-        int_container b = {-1, 0, 10};
-        int_container expected = {-1, 0, 3};
-        EXPECT_TRUE(all(equal(minimum(a, b), expected)));
-    }
+            double sa = 4.6;
+            EXPECT_EQ((sa * b)(0, 0), sa * b(0, 0));
+        }
 
-    TYPED_TEST(operation, maximum)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container = xop_test::rebind_container_t<container_1d, int>;
-        int_container a = {0, 0, 3};
-        int_container b = {-1, 0, 10};
-        int_container expected = {0, 0, 10};
-        int_container expected_2 = {0, 1, 10};
-        EXPECT_TRUE(all(equal(maximum(a, b), expected)));
-        EXPECT_TRUE(all(equal(maximum(arange(0, 3), b), expected_2)));
-    }
+        TEST_CASE_TEMPLATE("divide", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using shape_type = typename TypeParam::shape_type;
+            shape_type shape = {3, 2};
+            TypeParam a(shape, 4.5);
+            TypeParam b(shape, 1.3);
+            EXPECT_EQ((a / b)(0, 0), a(0, 0) / b(0, 0));
 
-    TYPED_TEST(operation, amax)
-    {
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
-        int_container_2d a = {{0, 0, 3}, {1, 2, 10}};
-        EXPECT_EQ(10, amax(a)());
-        int_container_1d e1 = {1, 2, 10};
-        EXPECT_EQ(e1, amax(a, {0}));
-        int_container_1d e2 = {3, 10};
-        EXPECT_EQ(e2, amax(a, {1}));
-    }
+            double sb = 1.2;
+            EXPECT_EQ((a / sb)(0, 0), a(0, 0) / sb);
 
-    TYPED_TEST(operation, amin)
-    {
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
-        int_container_2d a = {{0, 0, 3}, {1, 2, 10}};
-        EXPECT_EQ(0, amin(a)());
-        int_container_1d e1 = {0, 0, 3};
-        EXPECT_EQ(e1, amin(a, {0}));
-        int_container_1d e2 = {0, 1};
-        EXPECT_EQ(e2, amin(a, {1}));
-    }
+            double sa = 4.6;
+            EXPECT_EQ((sa / b)(0, 0), sa / b(0, 0));
+        }
 
-    TYPED_TEST(operation, all)
-    {
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
-        int_container_1d a = {1, 1, 3};
-        EXPECT_EQ(true, all(a));
-        int_container_2d b = {{0, 2, 1}, {2, 1, 0}};
-        EXPECT_EQ(false, all(b));
-    }
+        TEST_CASE_TEMPLATE("modulus", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container = xop_test::rebind_container_t<TypeParam, int>;
+            using shape_type = typename int_container::shape_type;
 
-    TYPED_TEST(operation, all_layout)
-    {
-        xarray<int, layout_type::row_major> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
-        xarray<int, layout_type::column_major> b = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
-        EXPECT_EQ(a(0, 1), b(0, 1));
-        EXPECT_TRUE(all(equal(a, b)));
-    }
+            shape_type shape = {3, 2};
+            int_container a(shape, 11);
+            int_container b(shape, 3);
+            EXPECT_EQ((a % b)(0, 0), a(0, 0) % b(0, 0));
 
-    TYPED_TEST(operation, nonzero)
-    {
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
-        using container_3d = redim_container_t<TypeParam, 3>;
-        using bool_container = xop_test::rebind_container_t<container_3d, bool>;
-        using shape_type = typename container_3d::shape_type;
-
-        int_container_1d a = {1, 0, 3};
-        std::vector<std::vector<std::size_t>> expected = {{0, 2}};
-        EXPECT_EQ(expected, nonzero(a));
-
-        int_container_2d b = {{0, 2, 1}, {2, 1, 0}};
-        std::vector<std::vector<std::size_t>> expected_b = {{0, 0, 1, 1}, {1, 2, 0, 1}};
-        EXPECT_EQ(expected_b, nonzero(b));
-
-        auto c = equal(b, 0);
-        std::vector<std::vector<std::size_t>> expected_c = {{0, 1}, {0, 2}};
-        EXPECT_EQ(expected_c, nonzero(c));
-
-        shape_type s = {3, 3, 3};
-        bool_container d(s);
-        std::fill(d.begin(), d.end(), true);
-
-        auto d_nz = nonzero(d);
-        EXPECT_EQ(size_t(3), d_nz.size());
-        EXPECT_EQ(size_t(27 * 27 * 27), d_nz[0].size() * d_nz[1].size() * d_nz[2].size());
-    }
+            int sb = 3;
+            EXPECT_EQ((a % sb)(0, 0), a(0, 0) % sb);
 
-    TYPED_TEST(operation, flatnonzero)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
+            int sa = 11;
+            EXPECT_EQ((sa % b)(0, 0), sa % b(0, 0));
+        }
 
-        int_container_1d a = arange(-2, 3);
-        std::vector<std::size_t> expected_a = {0, 1, 3, 4};
-        EXPECT_EQ(expected_a, flatnonzero<layout_type::row_major>(a));
-    }
 
-    TYPED_TEST(operation, where_only_condition)
-    {
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        int_container_2d a = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
-        std::vector<std::vector<std::size_t>> expected = {{0, 1, 2}, {0, 1, 2}};
-        EXPECT_EQ(expected, where(a));
-    }
+        TEST_CASE_TEMPLATE("bitwise_and", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_tensor = int_rebind_t<TypeParam>;
+            using shape_type = typename int_tensor::shape_type;
+            shape_type shape = {3, 2};
+            int_tensor a(shape, 14);
+            int_tensor b(shape, 15);
+            EXPECT_EQ((a & b)(0, 0), a(0, 0) & b(0, 0));
+
+            int sb = 48;
+            EXPECT_EQ((a & sb)(0, 0), a(0, 0) & sb);
+
+            int sa = 24;
+            EXPECT_EQ((sa & b)(0, 0), sa & b(0, 0));
+        }
 
-    TYPED_TEST(operation, where)
-    {
-        TypeParam a = { { 1, 2, 3 },{ 0, 1, 0 },{ 0, 4, 1 } };
-        double b = 1.0;
-        TypeParam res = where(a > b, b, a);
-        TypeParam expected = { { 1, 1, 1 },{ 0, 1, 0 },{ 0, 1, 1 } };
-        EXPECT_EQ(expected, res);
+        TEST_CASE_TEMPLATE("bitwise_or", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_tensor = int_rebind_t<TypeParam>;
+            using shape_type = typename int_tensor::shape_type;
+            shape_type shape = {3, 2};
+            int_tensor a(shape, 14);
+            int_tensor b(shape, 15);
+            EXPECT_EQ((a | b)(0, 0), a(0, 0) | b(0, 0));
+
+            int sb = 48;
+            EXPECT_EQ((a | sb)(0, 0), a(0, 0) | sb);
+
+            int sa = 24;
+            EXPECT_EQ((sa | b)(0, 0), sa | b(0, 0));
+        }
+
+        TEST_CASE_TEMPLATE("bitwise_xor", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_tensor = int_rebind_t<TypeParam>;
+            using shape_type = typename int_tensor::shape_type;
+            shape_type shape = {3, 2};
+            int_tensor a(shape, 14);
+            int_tensor b(shape, 15);
+            EXPECT_EQ((a ^ b)(0, 0), a(0, 0) ^ b(0, 0));
+
+            int sb = 48;
+            EXPECT_EQ((a ^ sb)(0, 0), a(0, 0) ^ sb);
+
+            int sa = 24;
+            EXPECT_EQ((sa ^ b)(0, 0), sa ^ b(0, 0));
+        }
+
+        TEST_CASE_TEMPLATE("bitwise_not", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_tensor = int_rebind_t<TypeParam>;
+            using shape_type = typename int_tensor::shape_type;
+            shape_type shape = {3, 2};
+            int_tensor a(shape, 15);
+            EXPECT_EQ((~a)(0, 0), ~(a(0, 0)));
+        }
+
+        TEST_CASE_TEMPLATE("less", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            container_1d a = {1, 2, 3, 4, 5};
+            bool_container expected = {1, 1, 1, 0, 0};
+            bool_container b = a < 4;
+            EXPECT_EQ(expected, b);
+            bool_container b2 = less(a, 4);
+            EXPECT_EQ(expected, b2);
+        }
+
+        TEST_CASE_TEMPLATE("less_equal", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            container_1d a = {1, 2, 3, 4, 5};
+            bool_container expected = {1, 1, 1, 1, 0};
+            bool_container b = a <= 4;
+            EXPECT_EQ(expected, b);
+            bool_container b2 = less_equal(a, 4);
+            EXPECT_EQ(expected, b2);
+        }
+
+        TEST_CASE_TEMPLATE("greater", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            container_1d a = {1, 2, 3, 4, 5};
+            bool_container expected = {0, 0, 0, 0, 1};
+            bool_container b = a > 4;
+            EXPECT_EQ(expected, b);
+            bool_container b2 = greater(a, 4);
+            EXPECT_EQ(expected, b2);
+        }
+
+        TEST_CASE_TEMPLATE("greater_equal", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            container_1d a = {1, 2, 3, 4, 5};
+            bool_container expected = {0, 0, 0, 1, 1};
+            bool_container b = a >= 4;
+            EXPECT_EQ(expected, b);
+            bool_container b2 = greater_equal(a, 4);
+            EXPECT_EQ(expected, b2);
+        }
+
+        TEST_CASE_TEMPLATE("negate", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            container_1d a = {1, 2, 3, 4, 5};
+            bool_container expected = {1, 1, 1, 0, 0};
+            bool_container b = !(a >= 4);
+            EXPECT_EQ(expected, b);
+        }
+
+        TEST_CASE_TEMPLATE("equal", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            container_1d a = {1, 2, 3, 4, 5};
+            bool_container expected = {0, 0, 0, 1, 0};
+            bool_container b = equal(a, 4);
+            EXPECT_EQ(expected, b);
+
+            container_1d other = {1, 2, 3, 0, 0};
+            bool_container b_2 = equal(a, other);
+            bool_container expected_2 = {1, 1, 1, 0, 0};
+            EXPECT_EQ(expected_2, b_2);
+        }
+
+        TEST_CASE_TEMPLATE("not_equal", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            container_1d a = {1, 2, 3, 4, 5};
+            bool_container expected = {1, 1, 1, 0, 1};
+            bool_container b = not_equal(a, 4);
+            EXPECT_EQ(expected, b);
+
+            container_1d other = {1, 2, 3, 0, 0};
+            bool_container b_2 = not_equal(a, other);
+            bool_container expected_2 = {0, 0, 0, 1, 1};
+            EXPECT_EQ(expected_2, b_2);
+        }
+
+        TEST_CASE_TEMPLATE("logical_and", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            bool_container a = {0, 0, 0, 1, 0};
+            bool_container expected = {0, 0, 0, 0, 0};
+            bool_container b = a && false;
+            bool_container c = a && a;
+            EXPECT_EQ(expected, b);
+            EXPECT_EQ(c, a);
+        }
+
+        TEST_CASE_TEMPLATE("logical_or", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using bool_container = xop_test::rebind_container_t<container_1d, bool>;
+            bool_container a = {0, 0, 0, 1, 0};
+            bool_container other = {0, 0, 0, 0, 0};
+            bool_container b = a || other;
+            bool_container c = a || false;
+            bool_container d = a || true;
+            EXPECT_EQ(b, a);
+            EXPECT_EQ(c, a);
+
+            bool_container expected = {1, 1, 1, 1, 1};
+            EXPECT_EQ(expected, d);
+        }
+
+        TEST_CASE_TEMPLATE("any", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container = xop_test::rebind_container_t<container_1d, int>;
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            int_container a = {0, 0, 3};
+            EXPECT_EQ(true, any(a));
+            int_container_2d b = {{0, 0, 0}, {0, 0, 0}};
+            EXPECT_EQ(false, any(b));
+        }
+
+        TEST_CASE_TEMPLATE("minimum", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container = xop_test::rebind_container_t<container_1d, int>;
+            int_container a = {0, 0, 3};
+            int_container b = {-1, 0, 10};
+            int_container expected = {-1, 0, 3};
+            EXPECT_TRUE(all(equal(minimum(a, b), expected)));
+        }
+
+        TEST_CASE_TEMPLATE("maximum", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container = xop_test::rebind_container_t<container_1d, int>;
+            int_container a = {0, 0, 3};
+            int_container b = {-1, 0, 10};
+            int_container expected = {0, 0, 10};
+            int_container expected_2 = {0, 1, 10};
+            EXPECT_TRUE(all(equal(maximum(a, b), expected)));
+            EXPECT_TRUE(all(equal(maximum(arange(0, 3), b), expected_2)));
+        }
+
+        TEST_CASE_TEMPLATE("amax", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
+            int_container_2d a = {{0, 0, 3}, {1, 2, 10}};
+            EXPECT_EQ(10, amax(a)());
+            int_container_1d e1 = {1, 2, 10};
+            EXPECT_EQ(e1, amax(a, {0}));
+            int_container_1d e2 = {3, 10};
+            EXPECT_EQ(e2, amax(a, {1}));
+        }
+
+        TEST_CASE_TEMPLATE("amin", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
+            int_container_2d a = {{0, 0, 3}, {1, 2, 10}};
+            EXPECT_EQ(0, amin(a)());
+            int_container_1d e1 = {0, 0, 3};
+            EXPECT_EQ(e1, amin(a, {0}));
+            int_container_1d e2 = {0, 1};
+            EXPECT_EQ(e2, amin(a, {1}));
+        }
+
+        TEST_CASE_TEMPLATE("all", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
+            int_container_1d a = {1, 1, 3};
+            EXPECT_EQ(true, all(a));
+            int_container_2d b = {{0, 2, 1}, {2, 1, 0}};
+            EXPECT_EQ(false, all(b));
+        }
+
+        TEST_CASE_TEMPLATE("all_layout", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            xarray<int, layout_type::row_major> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+            xarray<int, layout_type::column_major> b = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+            EXPECT_EQ(a(0, 1), b(0, 1));
+            EXPECT_TRUE(all(equal(a, b)));
+        }
+
+        TEST_CASE_TEMPLATE("nonzero", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
+            using container_3d = redim_container_t<TypeParam, 3>;
+            using bool_container = xop_test::rebind_container_t<container_3d, bool>;
+            using shape_type = typename container_3d::shape_type;
+
+            int_container_1d a = {1, 0, 3};
+            std::vector<std::vector<std::size_t>> expected = {{0, 2}};
+            EXPECT_EQ(expected, nonzero(a));
+
+            int_container_2d b = {{0, 2, 1}, {2, 1, 0}};
+            std::vector<std::vector<std::size_t>> expected_b = {{0, 0, 1, 1}, {1, 2, 0, 1}};
+            EXPECT_EQ(expected_b, nonzero(b));
+
+            auto c = equal(b, 0);
+            std::vector<std::vector<std::size_t>> expected_c = {{0, 1}, {0, 2}};
+            EXPECT_EQ(expected_c, nonzero(c));
+
+            shape_type s = {3, 3, 3};
+            bool_container d(s);
+            std::fill(d.begin(), d.end(), true);
+
+            auto d_nz = nonzero(d);
+            EXPECT_EQ(size_t(3), d_nz.size());
+            EXPECT_EQ(size_t(27 * 27 * 27), d_nz[0].size() * d_nz[1].size() * d_nz[2].size());
+        }
+
+        TEST_CASE_TEMPLATE("where_only_condition", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            int_container_2d a = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+            std::vector<std::vector<std::size_t>> expected = {{0, 1, 2}, {0, 1, 2}};
+            EXPECT_EQ(expected, where(a));
+        }
+
+        TEST_CASE_TEMPLATE("where", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            TypeParam a = {{1, 2, 3}, {0, 1, 0}, {0, 4, 1}};
+            double b = 1.0;
+            TypeParam res = where(a > b, b, a);
+            TypeParam expected = {{1, 1, 1}, {0, 1, 0}, {0, 1, 1}};
+            EXPECT_EQ(expected, res);
 
 #ifdef XTENSOR_USE_XSIMD
-        // This will fail to compile if simd is broken for conditional_ternary
-        auto func = where(a > b, b, a);
-        auto s = func.template load_simd<xsimd::aligned_mode>(0);
-        (void)s;
+            // This will fail to compile if simd is broken for conditional_ternary
+            auto func = where(a > b, b, a);
+            auto s = func.template load_simd<xsimd::aligned_mode>(0);
+            (void) s;
+
+            using assign_traits = xassign_traits<TypeParam, decltype(func)>;
+
+            EXPECT_TRUE(assign_traits::simd_linear_assign());
 #endif
-    }
+        }
 
-    TYPED_TEST(operation, where_cast)
-    {
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        int_container_2d a = {{0, 1, 0}, {3, 0, 5}};
-        double res1 = 1.2;
-        TypeParam b = where(equal(a, 0.0), res1, 0.0);
-        TypeParam expected = { {1.2, 0., 1.2}, {0., 1.2, 0.} };
-        EXPECT_EQ(b, expected);
-    }
+        TEST_CASE_TEMPLATE("where_optional", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using opt_type = xoptional_assembly<TypeParam, xtensor<bool, 2>>;
+            auto missing = xtl::missing<double>();
+            opt_type a = {{1, missing, 3}, {0, 1, 0}, {missing, 4, 1}};
+            double b = 1.0;
+
+            opt_type res = where(a > b, b, a);
+            opt_type expected = {{1, missing, 1}, {0, 1, 0}, {missing, 1, 1}};
+            EXPECT_EQ(expected, res);
+
+            opt_type res1 = where(true, a + 3, a);
+            opt_type expected1 = {{4, missing, 6}, {3, 4, 3}, {missing, 7, 4}};
+            EXPECT_EQ(expected1, res1);
+        }
 
-    TYPED_TEST(operation, argwhere)
-    {
-        using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
-        using container_3d = redim_container_t<TypeParam, 3>;
-        using bool_container = xop_test::rebind_container_t<container_3d, bool>;
-        using shape_type = typename container_3d::shape_type;
-
-        int_container_1d a = {1, 0, 3};
-        std::vector<xindex_type_t<typename int_container_1d::shape_type>> expected = {{0}, {2}};
-        EXPECT_EQ(expected, argwhere(a));
-
-        int_container_2d b = {{0, 2, 1}, {2, 1, 0}};
-        std::vector<xindex_type_t<typename int_container_2d::shape_type>> expected_b = {{0, 1}, {0, 2}, {1, 0}, {1, 1}};
-        EXPECT_EQ(expected_b, argwhere(b));
-
-        auto c = equal(b, 0);
-        std::vector<xindex_type_t<typename int_container_2d::shape_type>> expected_c = {{0, 0}, {1, 2}};
-        EXPECT_EQ(expected_c, argwhere(c));
-
-        shape_type s = {3, 3, 3};
-        bool_container d(s);
-        std::fill(d.begin(), d.end(), true);
-
-        auto d_nz = argwhere(d);
-        EXPECT_EQ(size_t(3 * 3 * 3), d_nz.size());
-        xindex_type_t<typename container_3d::shape_type> last_idx = {2, 2, 2};
-        EXPECT_EQ(last_idx, d_nz.back());
-    }
+        TEST_CASE_TEMPLATE("where_cast", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            int_container_2d a = {{0, 1, 0}, {3, 0, 5}};
+            double res1 = 1.2;
+            TypeParam b = where(equal(a, 0.0), res1, 0.0);
+            TypeParam expected = {{1.2, 0., 1.2}, {0., 1.2, 0.}};
+            EXPECT_EQ(b, expected);
+        }
 
-    TYPED_TEST(operation, cast)
-    {
-        using int_container_t = xop_test::rebind_container_t<TypeParam, int>;
-        using shape_type = typename int_container_t::shape_type;
-        shape_type shape = {3, 2};
-        int_container_t a(shape, 5);
-        auto ref = static_cast<double>(a(0, 0)) / 2;
-        auto actual = (cast<double>(a) / 2)(0, 0);
-        EXPECT_EQ(ref, actual);
-    }
+        TEST_CASE_TEMPLATE("argwhere", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_2d = xop_test::rebind_container_t<TypeParam, int>;
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using int_container_1d = xop_test::rebind_container_t<container_1d, int>;
+            using container_3d = redim_container_t<TypeParam, 3>;
+            using bool_container = xop_test::rebind_container_t<container_3d, bool>;
+            using shape_type = typename container_3d::shape_type;
+
+            int_container_1d a = {1, 0, 3};
+            std::vector<xindex_type_t<typename int_container_1d::shape_type>> expected = {{0}, {2}};
+            EXPECT_EQ(expected, argwhere(a));
+
+            int_container_2d b = {{0, 2, 1}, {2, 1, 0}};
+            std::vector<xindex_type_t<typename int_container_2d::shape_type>> expected_b =
+                {{0, 1}, {0, 2}, {1, 0}, {1, 1}};
+            EXPECT_EQ(expected_b, argwhere(b));
+
+            auto c = equal(b, 0);
+            std::vector<xindex_type_t<typename int_container_2d::shape_type>> expected_c = {{0, 0}, {1, 2}};
+            EXPECT_EQ(expected_c, argwhere(c));
+
+            shape_type s = {3, 3, 3};
+            bool_container d(s);
+            std::fill(d.begin(), d.end(), true);
+
+            auto d_nz = argwhere(d);
+            EXPECT_EQ(size_t(3 * 3 * 3), d_nz.size());
+            xindex_type_t<typename container_3d::shape_type> last_idx = {2, 2, 2};
+            EXPECT_EQ(last_idx, d_nz.back());
+        }
 
-    TYPED_TEST(operation, mixed_arithmetic)
-    {
-        using int_container_t = xop_test::rebind_container_t<TypeParam, int>;
-        TypeParam a = {{0., 1., 2.}, {3., 4., 5.}};
-        int_container_t b = {{0, 1, 2}, {3, 4, 5}};
-        int_container_t c = b;
-        TypeParam res = a + (b + c);
-        TypeParam expected = {{0., 3., 6.}, {9., 12., 15.}};
-        EXPECT_EQ(res, expected);
-    }
+        TEST_CASE_TEMPLATE("cast", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_t = xop_test::rebind_container_t<TypeParam, int>;
+            using shape_type = typename int_container_t::shape_type;
+            shape_type shape = {3, 2};
+            int_container_t a(shape, 5);
+            auto ref = static_cast<double>(a(0, 0)) / 2;
+            auto actual = (cast<double>(a) / 2)(0, 0);
+            EXPECT_EQ(ref, actual);
+        }
 
-    TYPED_TEST(operation, assign_traits)
-    {
-        TypeParam a = { { 0., 1., 2. },{ 3., 4., 5. } };
-        TypeParam b = { { 0., 1., 2. },{ 3., 4., 5. } };
+        TEST_CASE_TEMPLATE("cast_custom_type", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using vtype_container_t = xop_test::rebind_container_t<TypeParam, vtype>;
+            using shape_type = typename vtype_container_t::shape_type;
+            shape_type shape = {3, 2};
+            vtype_container_t a(shape);
+            auto ref = static_cast<double>(a(0, 0));
+            auto actual = (cast<double>(a))(0, 0);
+            EXPECT_EQ(ref, actual);
+        }
+
+        TEST_CASE_TEMPLATE("mixed_arithmetic", TypeParam, XOPERATION_TEST_TYPES)
+        {
+            using int_container_t = xop_test::rebind_container_t<TypeParam, int>;
+            TypeParam a = {{0., 1., 2.}, {3., 4., 5.}};
+            int_container_t b = {{0, 1, 2}, {3, 4, 5}};
+            int_container_t c = b;
+            TypeParam res = a + (b + c);
+            TypeParam expected = {{0., 3., 6.}, {9., 12., 15.}};
+            EXPECT_EQ(res, expected);
+        }
 
+        TEST_CASE_TEMPLATE("assign_traits", TypeParam, XOPERATION_TEST_TYPES)
         {
-            SCOPED_TRACE("xarray<double> + xarray<double>");
-            auto fd = a + b;
-            using assign_traits_double = xassign_traits<TypeParam, decltype(fd)>;
+            TypeParam a = {{0., 1., 2.}, {3., 4., 5.}};
+            TypeParam b = {{0., 1., 2.}, {3., 4., 5.}};
+
+            SUBCASE("xarray<double> + xarray<double>")
+            {
+                auto fd = a + b;
+                using assign_traits_double = xassign_traits<TypeParam, decltype(fd)>;
 #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits_double::convertible_types());
-            EXPECT_TRUE(assign_traits_double::simd_size());
-            EXPECT_FALSE(assign_traits_double::forbid_simd());
-            EXPECT_TRUE(assign_traits_double::simd_assign());
+                EXPECT_TRUE(assign_traits_double::simd_linear_assign());
 #else
-            // SFINAE on load_simd is broken on mingw when xsimd is disabled. This using
-            // triggers the same error as the one caught by mingw.
-            using return_type = decltype(fd.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits_double::convertible_types());
-            EXPECT_FALSE(assign_traits_double::simd_size());
-            EXPECT_TRUE(assign_traits_double::forbid_simd());
-            EXPECT_FALSE(assign_traits_double::simd_assign());
-            EXPECT_TRUE((std::is_same<return_type, double>::value));
+                // SFINAE on load_simd is broken on mingw when xsimd is disabled. This using
+                // triggers the same error as the one caught by mingw.
+                using return_type = decltype(fd.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_double::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, double>::value));
 #endif
-        }
+            }
 
-        {
-            SCOPED_TRACE("double * xarray<double>");
-            xscalar<double> sd = 2.;
-            auto fsd = sd * a;
-            using assign_traits_scalar_double = xassign_traits<TypeParam, decltype(fsd)>;
+            SUBCASE("double * xarray<double>")
+            {
+                xscalar<double> sd = 2.;
+                auto fsd = sd * a;
+                using assign_traits_scalar_double = xassign_traits<TypeParam, decltype(fsd)>;
 #if XTENSOR_USE_XSIMD
-            auto batch = fsd.template load_simd<double>(0);
-            EXPECT_TRUE((std::is_same<decltype(batch), xsimd::simd_type<double>>::value));
-            EXPECT_TRUE(assign_traits_scalar_double::convertible_types());
-            EXPECT_TRUE(assign_traits_scalar_double::simd_size());
-            EXPECT_FALSE(assign_traits_scalar_double::forbid_simd());
-            EXPECT_TRUE(assign_traits_scalar_double::simd_assign());
+                auto batch = fsd.template load_simd<double>(0);
+                (void) batch;
+                EXPECT_TRUE(assign_traits_scalar_double::simd_linear_assign());
 #else
-            using return_type = decltype(fsd.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits_scalar_double::convertible_types());
-            EXPECT_FALSE(assign_traits_scalar_double::simd_size());
-            EXPECT_TRUE(assign_traits_scalar_double::forbid_simd());
-            EXPECT_FALSE(assign_traits_scalar_double::simd_assign());
-            EXPECT_TRUE((std::is_same<return_type, double>::value));
+                using return_type = decltype(fsd.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_scalar_double::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, double>::value));
 #endif
-        }
+            }
+
+            SUBCASE("xarray<double> + xarray<int>")
+            {
+                using int_container_t = xop_test::rebind_container_t<TypeParam, int>;
+                int_container_t c = {{0, 1, 2}, {3, 4, 5}};
+                auto fm = a + c;
+                using assign_traits_mixed = xassign_traits<TypeParam, decltype(fm)>;
+#if XTENSOR_USE_XSIMD
+                EXPECT_TRUE(assign_traits_mixed::simd_linear_assign());
+#else
+                using return_type = decltype(fm.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_mixed::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, double>::value));
+#endif
+            }
 
-        {
-            SCOPED_TRACE("xarray<double> + xarray<int>");
-            using int_container_t = xop_test::rebind_container_t<TypeParam, int>;
-            int_container_t c = { { 0, 1, 2 },{ 3, 4, 5 } };
-            auto fm = a + c;
-            using assign_traits_mixed = xassign_traits<TypeParam, decltype(fm)>;
+            SUBCASE("int * xarray<double>")
+            {
+                xscalar<int> si = 2;
+                auto fsm = si * a;
+                using assign_traits_scalar_mixed = xassign_traits<TypeParam, decltype(fsm)>;
 #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits_mixed::convertible_types());
-            EXPECT_TRUE(assign_traits_mixed::simd_size());
-            EXPECT_FALSE(assign_traits_mixed::forbid_simd());
-            EXPECT_TRUE(assign_traits_mixed::simd_assign());
+                EXPECT_TRUE(assign_traits_scalar_mixed::simd_linear_assign());
 #else
-            using return_type = decltype(fm.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits_mixed::convertible_types());
-            EXPECT_FALSE(assign_traits_mixed::simd_size());
-            EXPECT_TRUE(assign_traits_mixed::forbid_simd());
-            EXPECT_FALSE(assign_traits_mixed::simd_assign());
-            EXPECT_TRUE((std::is_same<return_type, double>::value));
+                using return_type = decltype(fsm.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_scalar_mixed::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, double>::value));
 #endif
-        }
+            }
+
+            SUBCASE("xarray<double> + xarray<char>")
+            {
+                using char_container_t = xop_test::rebind_container_t<TypeParam, char>;
+                char_container_t d = {{0, 1, 2}, {3, 4, 5}};
+                auto fdc = a + d;
+                using assign_traits_char_double = xassign_traits<TypeParam, decltype(fdc)>;
+#if XTENSOR_USE_XSIMD
+                EXPECT_TRUE(assign_traits_char_double::simd_linear_assign());
+#else
+                using return_type = decltype(fdc.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_char_double::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, double>::value));
+#endif
+            }
+
+            SUBCASE("xarray<double> + xarray<my_double>")
+            {
+                using md_container_t = xop_test::rebind_container_t<TypeParam, my_double>;
+                md_container_t d = {{0, 1, 2}, {3, 4, 5}};
+                auto fdm = a + d;
+                using assign_traits_md_double = xassign_traits<TypeParam, decltype(fdm)>;
+#if XTENSOR_USE_XSIMD
+                EXPECT_FALSE(assign_traits_md_double::simd_linear_assign());
+#else
+                using return_type = decltype(fdm.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_md_double::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, double>::value));
+#endif
+            }
 
-        {
-            SCOPED_TRACE("int * xarray<double>");
-            xscalar<int> si = 2;
-            auto fsm = si * a;
-            using assign_traits_scalar_mixed = xassign_traits<TypeParam, decltype(fsm)>;
+            SUBCASE("xarray<double> > xarray<double>")
+            {
+                auto fgt = a > b;
+                using bool_container_t = xop_test::rebind_container_t<TypeParam, bool>;
+                using assign_traits_gt = xassign_traits<bool_container_t, decltype(fgt)>;
+#if XTENSOR_USE_XSIMD
+                EXPECT_TRUE(assign_traits_gt::simd_linear_assign());
+#else
+                using return_type = decltype(fgt.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_gt::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, bool>::value));
+#endif
+            }
+
+            SUBCASE("xarray<bool> || xarray<bool>")
+            {
+                using bool_container_t = xop_test::rebind_container_t<TypeParam, bool>;
+                bool_container_t b0 = {{true, false, true}, {false, false, true}};
+                bool_container_t b1 = {{true, true, false}, {false, true, true}};
+                auto fb = b0 || b1;
+                using assign_traits_bool_bool = xassign_traits<bool_container_t, decltype(fb)>;
 #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits_scalar_mixed::convertible_types());
-            EXPECT_TRUE(assign_traits_scalar_mixed::simd_size());
-            EXPECT_FALSE(assign_traits_scalar_mixed::forbid_simd());
-            EXPECT_TRUE(assign_traits_scalar_mixed::simd_assign());
+                EXPECT_TRUE(assign_traits_bool_bool::simd_linear_assign());
 #else
-            using return_type = decltype(fsm.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits_scalar_mixed::convertible_types());
-            EXPECT_FALSE(assign_traits_scalar_mixed::simd_size());
-            EXPECT_TRUE(assign_traits_scalar_mixed::forbid_simd());
-            EXPECT_FALSE(assign_traits_scalar_mixed::simd_assign());
-            EXPECT_TRUE((std::is_same<return_type, double>::value));
+                using return_type = decltype(fb.template load_simd<aligned_mode>(std::size_t(0)));
+                EXPECT_FALSE(assign_traits_bool_bool::simd_linear_assign());
+                EXPECT_TRUE((std::is_same<return_type, bool>::value));
 #endif
+            }
+        }
+
+
+        TEST(operation, mixed_assign)
+        {
+            xt::xarray<double> asrc = {1., 2.};
+            xt::xarray<std::size_t> bsrc = {std::size_t(3), std::size_t(4)};
+
+            xt::xarray<double> a(asrc);
+            xt::xarray<double> aexp = {3., 4.};
+            a = bsrc;
+
+            xt::xarray<std::size_t> b(bsrc);
+            xt::xarray<std::size_t> bexp = {std::size_t(1), std::size_t(2)};
+            b = asrc;
+            EXPECT_EQ(b, bexp);
+        }
+
+        TEST(operation, mixed_bool_assign)
+        {
+            xt::xarray<double> a = {1., 6.};
+            xt::xarray<double> b = {2., 3.};
+            using uchar = unsigned char;
+            xt::xarray<uchar> res = a > b;
+            xt::xarray<uchar> exp = {uchar(0), uchar(1)};
+            EXPECT_EQ(res, exp);
         }
 
+        TEST(operation, dynamic_simd_assign)
         {
-            SCOPED_TRACE("xarray<double> + xarray<char>");
-            using char_container_t = xop_test::rebind_container_t<TypeParam, char>;
-            char_container_t d = { { 0, 1, 2 },{ 3, 4, 5 } };
-            auto fdc = a + d;
-            using assign_traits_char_double = xassign_traits<TypeParam, decltype(fdc)>;
+            using array_type = xt::xarray<double, layout_type::dynamic>;
+            array_type a({2, 3}, layout_type::row_major);
+            array_type b({2, 3}, layout_type::column_major);
+
+            auto frr = a + a;
+            auto frc = a + b;
+            auto fcc = b + b;
+
+            using frr_traits = xassign_traits<array_type, decltype(frr)>;
+            using frc_traits = xassign_traits<array_type, decltype(frc)>;
+            using fcc_traits = xassign_traits<array_type, decltype(fcc)>;
+
+            EXPECT_FALSE(frr_traits::simd_linear_assign());
+            EXPECT_FALSE(frc_traits::simd_linear_assign());
+            EXPECT_FALSE(fcc_traits::simd_linear_assign());
+
+            SUBCASE("row_major + row_major")
+            {
+#if XTENSOR_USE_XSIMD
+                EXPECT_TRUE(frr_traits::simd_linear_assign(a, frr));
+#else
+                EXPECT_FALSE(frr_traits::simd_linear_assign(a, frr));
+#endif
+                EXPECT_FALSE(frr_traits::simd_linear_assign(b, frr));
+            }
+
+            SUBCASE("row_major + column_major")
+            {
+                EXPECT_FALSE(frc_traits::simd_linear_assign(a, frc));
+                EXPECT_FALSE(frc_traits::simd_linear_assign(b, frc));
+            }
+
+            SUBCASE("row_major + column_major")
+            {
+                EXPECT_FALSE(fcc_traits::simd_linear_assign(a, fcc));
 #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits_char_double::convertible_types());
-            EXPECT_TRUE(assign_traits_char_double::simd_size());
-            EXPECT_TRUE(assign_traits_char_double::forbid_simd());
-            EXPECT_FALSE(assign_traits_char_double::simd_assign());
+                EXPECT_TRUE(fcc_traits::simd_linear_assign(b, fcc));
 #else
-            using return_type = decltype(fdc.template load_simd<aligned_mode>(std::size_t(0)));
-            EXPECT_TRUE(assign_traits_char_double::convertible_types());
-            EXPECT_FALSE(assign_traits_char_double::simd_size());
-            EXPECT_TRUE(assign_traits_char_double::forbid_simd());
-            EXPECT_FALSE(assign_traits_char_double::simd_assign());
-            EXPECT_TRUE((std::is_same<return_type, double>::value));
+                EXPECT_FALSE(fcc_traits::simd_linear_assign(b, fcc));
 #endif
+            }
         }
-    }
 
-    TEST(operation, left_shift)
-    {
-        xarray<int> arr({5,1, 1000});
-        xarray<int> res1 = left_shift(arr, 4);
-        xarray<int> res2 = left_shift(arr, arr);
-        EXPECT_EQ(left_shift(arr, 4)(1), 16);
-        xarray<int> expected1 = {80, 16, 16000};
-        xarray<int> expected2 = {160, 2, 256000};
-
-        EXPECT_EQ(expected1, res1);
-        EXPECT_EQ(expected2, res2);
-    }
+        TEST_CASE("left_shift")
+        {
+            xarray<int> arr({5, 1, 1000});
+            xarray<int> arr2({2, 1, 3});
+            xarray<int> res1 = left_shift(arr, 4);
+            xarray<int> res2 = left_shift(arr, arr2);
+            EXPECT_EQ(left_shift(arr, 4)(1), 16);
+            xarray<int> expected1 = {80, 16, 16000};
+            xarray<int> expected2 = {20, 2, 8000};
+
+            EXPECT_EQ(expected1, res1);
+            EXPECT_EQ(expected2, res2);
+
+            xarray<int> res3 = arr << 4;
+            xarray<int> res4 = arr << arr2;
+            EXPECT_EQ(expected1, res3);
+            EXPECT_EQ(expected2, res4);
+        }
 
-    TEST(operation, right_shift)
-    {
-        xarray<int> arr({5,1, 1000});
-        xarray<int> res1 = right_shift(arr, 4);
-        xarray<int> res2 = right_shift(arr, arr);
-        EXPECT_EQ(right_shift(arr, 4)(1), 0);
-        xarray<int> expected1 = {0, 0, 62};
-        xarray<int> expected2 = {0, 0, 3};
-
-        EXPECT_EQ(expected1, res1);
-        EXPECT_EQ(expected2, res2);
+        TEST_CASE("right_shift")
+        {
+            xarray<int> arr({5, 1, 1000});
+            xarray<int> arr2({2, 1, 3});
+            xarray<int> res1 = right_shift(arr, 4);
+            xarray<int> res2 = right_shift(arr, arr2);
+            EXPECT_EQ(right_shift(arr, 4)(1), 0);
+            xarray<int> expected1 = {0, 0, 62};
+            xarray<int> expected2 = {1, 0, 125};
+
+            EXPECT_EQ(expected1, res1);
+            EXPECT_EQ(expected2, res2);
+
+            xarray<int> res3 = arr >> 4;
+            xarray<int> res4 = arr >> arr2;
+            EXPECT_EQ(expected1, res3);
+            EXPECT_EQ(expected2, res4);
+        }
+
+        TEST_CASE("divide_4d")
+        {
+            using T4 = xt::xtensor<float, 4, xt::layout_type::row_major>;
+            using shape_type = typename T4::shape_type;
+
+            shape_type shape = {2, 3, 2, 2};
+            T4 a(shape, 4.5f);
+            T4 b(shape, 1.3f);
+
+            EXPECT_EQ((a / b)(0, 0, 0, 0), a(0, 0, 0, 0) / b(0, 0, 0, 0));
+
+            float sb = 1.2f;
+            EXPECT_EQ((a / sb)(0, 0, 0, 0), a(0, 0, 0, 0) / sb);
+
+            float sa = 4.6f;
+            EXPECT_EQ((sa / b)(0, 0, 0, 0), sa / b(0, 0, 0, 0));
+
+            // self-divide assignment: a = a / b (no zeros in b)
+            auto a_before = a(1, 2, 1, 1);
+            a = a / b;
+            EXPECT_EQ(a(1, 2, 1, 1), a_before / b(1, 2, 1, 1));
+        }
     }
+
+#undef XOPERATION_TEST_TYPES
+
 }
diff --git a/test/test_xoptional.cpp b/test/test_xoptional.cpp
index 1a36ee3f3..74d5aea97 100644
--- a/test/test_xoptional.cpp
+++ b/test/test_xoptional.cpp
@@ -1,28 +1,27 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
 
-#include "xtensor/xio.hpp"
-#include "xtensor/xoptional.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/optional/xoptional.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     TEST(xoptional, tensor)
     {
-        xtensor_optional<double, 2> m
-            {{ 1.0 ,       2.0         },
-             { 3.0 , xtl::missing<double>() }};
+        xtensor_optional<double, 2> m{{1.0, 2.0}, {3.0, xtl::missing<double>()}};
 
         ASSERT_EQ(m(0, 0).value(), 1.0);
         ASSERT_EQ(m(1, 0).value(), 3.0);
@@ -30,15 +29,35 @@ namespace xt
         ASSERT_EQ((m[{0, 0}].value()), 1.0);
     }
 
+    TEST(xoptional, adaptor)
+    {
+        using vtype = xtl::xoptional_vector<double>;
+        vtype v(4, 0.);
+        v[0] = 1.;
+        v[1] = 2.;
+        v[2] = 3.;
+        v[3] = xtl::missing<double>();
+
+        using tadaptor = xtensor_adaptor<vtype&, 2, layout_type::row_major, xoptional_expression_tag>;
+        tadaptor ta(v, {2, 2});
+        ASSERT_EQ(ta(0, 0).value(), 1.0);
+        ASSERT_EQ(ta(1, 0).value(), 3.0);
+        ASSERT_FALSE(ta(1, 1).has_value());
+        ASSERT_EQ((ta[{0, 0}].value()), 1.0);
+
+        using aadaptor = xarray_adaptor<vtype&, layout_type::row_major, dynamic_shape<std::size_t>, xoptional_expression_tag>;
+        aadaptor aa(v, {2, 2});
+        ASSERT_EQ(aa(0, 0).value(), 1.0);
+        ASSERT_EQ(aa(1, 0).value(), 3.0);
+        ASSERT_FALSE(aa(1, 1).has_value());
+        ASSERT_EQ((aa[{0, 0}].value()), 1.0);
+    }
+
     TEST(xoptional, operation)
     {
-        xtensor_optional<double, 2> m1
-            {{ 0.0 ,       2.0         },
-             { 3.0 , xtl::missing<double>() }};
+        xtensor_optional<double, 2> m1{{0.0, 2.0}, {3.0, xtl::missing<double>()}};
 
-        xtensor<double, 2> m2
-            {{ 1.0 , 2.0 },
-             { 3.0 , 1.0 }};
+        xtensor<double, 2> m2{{1.0, 2.0}, {3.0, 1.0}};
 
         auto res_add = m1 + m2;
         ASSERT_EQ(res_add(0, 0).value(), 1.0);
@@ -62,13 +81,17 @@ namespace xt
         ASSERT_EQ(res(0, 0).value(), 1.0);
         ASSERT_EQ(res(1, 0).value(), 6.0);
         ASSERT_FALSE(res(1, 1).has_value());
+
+        xtensor_optional<double, 2> res_neg = -m1;
+        ASSERT_EQ(res_neg(0, 0).value(), 0.0);
+        ASSERT_EQ(res_neg(0, 1).value(), -2.0);
+        ASSERT_EQ(res_neg(1, 0).value(), -3.0);
+        ASSERT_FALSE(res_neg(1, 1).has_value());
     }
 
     TEST(xoptional, bool_operation)
     {
-        xtensor_optional<bool, 2> m1
-            {{ false ,       true },
-             { false , xtl::missing<bool>() }};
+        xtensor_optional<bool, 2> m1{{false, true}, {false, xtl::missing<bool>()}};
 
         xtensor_optional<bool, 2> res = m1 && m1;
         EXPECT_FALSE(res(0, 0).value());
@@ -80,9 +103,7 @@ namespace xt
     TEST(xoptional, xio)
     {
         std::ostringstream oss;
-        xtensor_optional<double, 2> m
-            {{ 0.0 ,       2.0         },
-             { 3.0 , xtl::missing<double>() }};
+        xtensor_optional<double, 2> m{{0.0, 2.0}, {3.0, xtl::missing<double>()}};
 
         oss << m;
         std::string expect = "{{  0,   2},\n {  3, N/A}}";
@@ -91,9 +112,7 @@ namespace xt
 
     TEST(xoptional, ufunc)
     {
-        xtensor_optional<double, 2> m
-            {{ 0.0 ,       2.0         },
-             { 3.0 , xtl::missing<double>() }};
+        xtensor_optional<double, 2> m{{0.0, 2.0}, {3.0, xtl::missing<double>()}};
 
         auto flag_view = xt::has_value(m);
 
@@ -115,9 +134,7 @@ namespace xt
 
     TEST(xoptional, ufunc_nonoptional)
     {
-        xtensor<double, 2> m
-            {{ 0.0 , 2.0 },
-             { 3.0 , 1.0 }};
+        xtensor<double, 2> m{{0.0, 2.0}, {3.0, 1.0}};
 
         auto flag_view = has_value(m);
 
@@ -130,16 +147,14 @@ namespace xt
 
     TEST(xoptional, dynamic_view)
     {
-        xarray_optional<int> a = {{{0, 1, 2, 3},
-                                   {4, 5, 6, 7},
-                                   {8, 9, 10, 11}},
-                                  {{12, 13, 14, 15},
-                                   {16, 17, 18, 19},
-                                   {20, 21, 22, 23}}};
+        xarray_optional<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
         a(1, 0, 1).has_value() = false;
         a(1, 2, 3).has_value() = false;
 
-        auto view0 = dynamic_view(a, xdynamic_slice_vector({ 1, keep(0, 2), range(1, 4) }));
+        auto view0 = dynamic_view(a, xdynamic_slice_vector({1, keep(0, 2), range(1, 4)}));
         auto v_view = view0.value();
         auto hv_view = view0.has_value();
 
@@ -165,43 +180,40 @@ namespace xt
 
     TEST(xoptional, function_on_view)
     {
-        xarray_optional<int> a = {{{0, 1, 2, 3},
-                                   {4, 5, 6, 7},
-                                   {8, 9, 10, 11}},
-                                  {{12, 13, 14, 15},
-                                   {16, 17, 18, 19},
-                                   {20, 21, 22, 23}}};
+        xarray_optional<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
 
         a(1, 0, 1).has_value() = false;
         a(1, 2, 3).has_value() = false;
 
-        auto va = dynamic_view(a, xdynamic_slice_vector({ 1, keep(0, 2), range(1, 4) }));
+        auto va = dynamic_view(a, xdynamic_slice_vector({1, keep(0, 2), range(1, 4)}));
 
-        xarray_optional<int> b = {{0, 1, 2},
-                                  {3, 4, 5}};
+        xarray_optional<int> b = {{0, 1, 2}, {3, 4, 5}};
 
         auto f = va + b;
         auto vf = f.value();
         auto hvf = f.has_value();
 
-        EXPECT_EQ(vf(0,0), 13);
-        EXPECT_EQ(vf(0,1), 15);
-        EXPECT_EQ(vf(0,2), 17);
-        EXPECT_EQ(vf(1,0), 24);
-        EXPECT_EQ(vf(1,1), 26);
-        EXPECT_EQ(vf(1,2), 28);
+        EXPECT_EQ(vf(0, 0), 13);
+        EXPECT_EQ(vf(0, 1), 15);
+        EXPECT_EQ(vf(0, 2), 17);
+        EXPECT_EQ(vf(1, 0), 24);
+        EXPECT_EQ(vf(1, 1), 26);
+        EXPECT_EQ(vf(1, 2), 28);
 
-        EXPECT_FALSE(hvf(0,0));
-        EXPECT_TRUE(hvf(0,1));
-        EXPECT_TRUE(hvf(0,2));
-        EXPECT_TRUE(hvf(1,0));
-        EXPECT_TRUE(hvf(1,1));
-        EXPECT_FALSE(hvf(1,2));
+        EXPECT_FALSE(hvf(0, 0));
+        EXPECT_TRUE(hvf(0, 1));
+        EXPECT_TRUE(hvf(0, 2));
+        EXPECT_TRUE(hvf(1, 0));
+        EXPECT_TRUE(hvf(1, 1));
+        EXPECT_FALSE(hvf(1, 2));
 
         xarray_optional<int> res = f;
-        for(size_t i = 0; i < f.shape()[0]; ++i)
+        for (size_t i = 0; i < f.shape()[0]; ++i)
         {
-            for(size_t j = 0; j < f.shape()[1]; ++j)
+            for (size_t j = 0; j < f.shape()[1]; ++j)
             {
                 EXPECT_EQ(f(i, j), res(i, j));
             }
@@ -210,8 +222,7 @@ namespace xt
 
     TEST(xoptional, broadcast)
     {
-        xarray_optional<int> a = {{1, 2, 3},
-                                  {4, 5, 6}};
+        xarray_optional<int> a = {{1, 2, 3}, {4, 5, 6}};
         a(0, 1).has_value() = false;
         a(1, 2).has_value() = false;
 
@@ -219,11 +230,11 @@ namespace xt
         auto vbr = br.value();
         auto hvbr = br.has_value();
 
-        for(size_t i = 0; i < br.shape()[0]; ++i)
+        for (size_t i = 0; i < br.shape()[0]; ++i)
         {
-            for(size_t j = 0; j < br.shape()[1]; ++j)
+            for (size_t j = 0; j < br.shape()[1]; ++j)
             {
-                for(size_t k = 0; k < br.shape()[2]; ++k)
+                for (size_t k = 0; k < br.shape()[2]; ++k)
                 {
                     EXPECT_EQ(vbr(i, j, k), a(0, j, k).value());
                     EXPECT_EQ(hvbr(i, j, k), a(0, j, k).has_value());
@@ -237,16 +248,32 @@ namespace xt
     public:
 
         point() = default;
+
         point(int x, int y)
-            : m_x(x), m_y(y)
+            : m_x(x)
+            , m_y(y)
         {
         }
 
-        int& x() noexcept { return m_x; }
-        int& y() noexcept { return m_y; }
+        int& x() noexcept
+        {
+            return m_x;
+        }
 
-        const int& x() const noexcept { return m_x; }
-        const int& y() const noexcept { return m_y; }
+        int& y() noexcept
+        {
+            return m_y;
+        }
+
+        const int& x() const noexcept
+        {
+            return m_x;
+        }
+
+        const int& y() const noexcept
+        {
+            return m_y;
+        }
 
     private:
 
@@ -262,14 +289,27 @@ namespace xt
         using pointer = int*;
         using const_pointer = const int*;
 
-        reference operator()(point& p) const noexcept { return p.x(); }
-        const_reference operator()(const point& p) const noexcept { return p.x(); }
+        reference operator()(point& p) const noexcept
+        {
+            return p.x();
+        }
+
+        const_reference operator()(const point& p) const noexcept
+        {
+            return p.x();
+        }
+
+        // Compilation trick: a functor view on xarray_optional<point> expects the functor
+        // to provide operator() accepting reference and const_reference from xarray_optional<point>
+        // Since we never use these overloads, no need to declare the right one, nor to provide
+        // any implementation.
+        template <class T>
+        T&& operator()(T&&) const noexcept;
     };
 
     TEST(xoptional, functor_view)
     {
-        xarray_optional<point> a = {{point(0, 0), point(0, 1)},
-                                    {point(1, 0), point(1, 1)}};
+        xarray_optional<point> a = {{point(0, 0), point(0, 1)}, {point(1, 0), point(1, 1)}};
         a(0, 0).has_value() = false;
         a(1, 0).has_value() = false;
 
@@ -296,12 +336,11 @@ namespace xt
 
     TEST(xoptional, index_view)
     {
-        xarray_optional<int> a = {{1, 2, 3},
-                                  {4, 5, 6}};
+        xarray_optional<int> a = {{1, 2, 3}, {4, 5, 6}};
         a(0, 0).has_value() = false;
         a(1, 2).has_value() = false;
 
-        auto iv = index_view(a, {{0ul,0ul}, {0ul,2ul}, {1ul,1ul}, {1ul,2ul}});
+        auto iv = index_view(a, {{0ul, 0ul}, {0ul, 2ul}, {1ul, 1ul}, {1ul, 2ul}});
         auto viv = iv.value();
         auto hviv = iv.has_value();
 
@@ -318,8 +357,7 @@ namespace xt
 
     TEST(xoptional, reducer)
     {
-        xarray_optional<int> a = {{1, 2, 3},
-                                  {4, 5, 6}};
+        xarray_optional<int> a = {{1, 2, 3}, {4, 5, 6}};
         a(1, 2).has_value() = false;
 
         auto red = sum(a, {1});
@@ -335,12 +373,10 @@ namespace xt
 
     TEST(xoptional, strided_view)
     {
-        xarray_optional<int> a = {{{0, 1, 2, 3},
-                                   {4, 5, 6, 7},
-                                   {8, 9, 10, 11}},
-                                  {{12, 13, 14, 15},
-                                   {16, 17, 18, 19},
-                                   {20, 21, 22, 23}}};
+        xarray_optional<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
         a(1, 0, 1).has_value() = false;
         a(1, 2, 3).has_value() = false;
 
@@ -353,24 +389,22 @@ namespace xt
         EXPECT_EQ(hv_view.shape()[0], std::size_t(2));
         EXPECT_EQ(hv_view.shape()[1], std::size_t(3));
 
-        for(size_t i = 0; i < v_view.shape()[0]; ++i)
+        for (size_t i = 0; i < v_view.shape()[0]; ++i)
         {
-            for(size_t j = 0; j < v_view.shape()[1]; ++j)
+            for (size_t j = 0; j < v_view.shape()[1]; ++j)
             {
-                EXPECT_EQ(v_view(i, j), a(1, i, j+1).value());
-                EXPECT_EQ(hv_view(i, j), a(1, i, j+1).has_value());
+                EXPECT_EQ(v_view(i, j), a(1, i, j + 1).value());
+                EXPECT_EQ(hv_view(i, j), a(1, i, j + 1).has_value());
             }
         }
     }
 
     TEST(xoptional, view)
     {
-        xarray_optional<int> a = {{{0, 1, 2, 3},
-                                   {4, 5, 6, 7},
-                                   {8, 9, 10, 11}},
-                                  {{12, 13, 14, 15},
-                                   {16, 17, 18, 19},
-                                   {20, 21, 22, 23}}};
+        xarray_optional<int> a = {
+            {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}},
+            {{12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23}}
+        };
         a(1, 0, 1).has_value() = false;
         a(1, 2, 3).has_value() = false;
 
@@ -383,12 +417,12 @@ namespace xt
         EXPECT_EQ(hv_view.shape()[0], std::size_t(2));
         EXPECT_EQ(hv_view.shape()[1], std::size_t(3));
 
-        for(size_t i = 0; i < v_view.shape()[0]; ++i)
+        for (size_t i = 0; i < v_view.shape()[0]; ++i)
         {
-            for(size_t j = 0; j < v_view.shape()[1]; ++j)
+            for (size_t j = 0; j < v_view.shape()[1]; ++j)
             {
-                EXPECT_EQ(v_view(i, j), a(1, i, j+1).value());
-                EXPECT_EQ(hv_view(i, j), a(1, i, j+1).has_value());
+                EXPECT_EQ(v_view(i, j), a(1, i, j + 1).value());
+                EXPECT_EQ(hv_view(i, j), a(1, i, j + 1).has_value());
             }
         }
     }
@@ -401,13 +435,13 @@ namespace xt
             return static_cast<int>(t);
         }
     };
-    
+
     struct bool_even
     {
         template <class T>
         bool operator()(T t) const
         {
-            return t%2 == 0;
+            return t % 2 == 0;
         }
     };
 
@@ -429,14 +463,23 @@ namespace xt
         template <class T>
         xtl::xoptional<int, bool> operator()(T t) const
         {
-            return xtl::xoptional<int, bool>(m_value_functor(t),
-                                             m_flag_functor(t));
+            return xtl::xoptional<int, bool>(m_value_functor(t), m_flag_functor(t));
         }
 
         value_functor_type m_value_functor;
         flag_functor_type m_flag_functor;
     };
 
+    TEST(xoptional, cast)
+    {
+        xarray_optional<double> a = {{1.2, 2.3, 3.4}, {4.5, 5.6, 6.7}};
+        a(1, 2).has_value() = false;
+        auto b = cast<xtl::xoptional<int>>(a);
+        EXPECT_TRUE(b(0, 2).has_value());
+        EXPECT_EQ(b(0, 2), 3);
+        EXPECT_FALSE(b(1, 2).has_value());
+    }
+
     TEST(xoptional, generator)
     {
         using gen_type = xgenerator<opt_func_tester, xtl::xoptional<int, bool>, dynamic_shape<std::size_t>>;
diff --git a/test/test_xoptional_assembly.cpp b/test/test_xoptional_assembly.cpp
index 5a081724e..cd44c1eae 100644
--- a/test/test_xoptional_assembly.cpp
+++ b/test/test_xoptional_assembly.cpp
@@ -1,45 +1,47 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-
-#include "xtensor/xarray.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xoptional_assembly.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/optional/xoptional_assembly.hpp"
 
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
     using array_type = xarray<int>;
     using flag_array_type = xarray<bool>;
     using opt_ass_type = xoptional_assembly<array_type, flag_array_type>;
-    using cm_opt_ass_type = xoptional_assembly<xarray<int, layout_type::column_major>, xarray<bool, layout_type::column_major>>;
+    using cm_opt_ass_type = xoptional_assembly<
+        xarray<int, layout_type::column_major>,
+        xarray<bool, layout_type::column_major>>;
     using dyn_opt_ass_type = xoptional_assembly<xarray<int, layout_type::dynamic>, xarray<bool, layout_type::dynamic>>;
 
     TEST(xoptional_assembly, shaped_constructor)
     {
+        SUBCASE("row_major constructor")
         {
-            SCOPED_TRACE("row_major constructor");
             row_major_result<> rm;
             dyn_opt_ass_type ra(rm.m_shape, layout_type::row_major);
             compare_shape(ra, rm);
         }
 
+        SUBCASE("column_major constructor")
         {
-            SCOPED_TRACE("column_major constructor");
             column_major_result<> cm;
             cm_opt_ass_type ca(cm.m_shape);
             compare_shape(ca, cm);
         }
 
+        SUBCASE("from shape")
         {
-            SCOPED_TRACE("from shape");
             std::array<std::size_t, 3> shp = {5, 4, 2};
             std::vector<std::size_t> shp_as_vec = {5, 4, 2};
             auto ca = cm_opt_ass_type::from_shape({3, 2, 1});
@@ -59,8 +61,8 @@ namespace xt
 
     TEST(xoptional_assembly, valued_constructor)
     {
+        SUBCASE("row_major valued constructor")
         {
-            SCOPED_TRACE("row_major valued constructor");
             row_major_result<> rm;
             int value = 2;
             dyn_opt_ass_type ra(rm.m_shape, value, layout_type::row_major);
@@ -69,8 +71,8 @@ namespace xt
             EXPECT_EQ(ra.value().storage(), vec);
         }
 
+        SUBCASE("column_major valued constructor")
         {
-            SCOPED_TRACE("column_major valued constructor");
             column_major_result<> cm;
             int value = 2;
             cm_opt_ass_type ca(cm.m_shape, value);
@@ -126,7 +128,7 @@ namespace xt
         EXPECT_EQ(a2(1, 0), opt(3, true));
         EXPECT_EQ(a2(1, 1), opt(4, true));
 
-        array_type value2 = { {1, 2}, {3, 4} };
+        array_type value2 = {{1, 2}, {3, 4}};
         opt_ass_type a3(std::move(value2));
         EXPECT_EQ(a3(0, 0), opt(1, true));
         EXPECT_EQ(a3(0, 1), opt(2, true));
@@ -140,15 +142,15 @@ namespace xt
         int value = 2;
         dyn_opt_ass_type a(res.m_shape, res.m_strides, value);
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             dyn_opt_ass_type b(a);
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("assignment operator")
         {
-            SCOPED_TRACE("assignment operator");
             row_major_result<> r;
             dyn_opt_ass_type c(r.m_shape, dyn_opt_ass_type::value_type(0, false));
             EXPECT_NE(a.storage(), c.storage());
@@ -164,16 +166,16 @@ namespace xt
         int value = 2;
         dyn_opt_ass_type a(res.m_shape, res.m_strides, value);
 
+        SUBCASE("move constructor")
         {
-            SCOPED_TRACE("move constructor");
             dyn_opt_ass_type tmp(a);
             dyn_opt_ass_type b(std::move(tmp));
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("move assignment")
         {
-            SCOPED_TRACE("move assignment");
             row_major_result<> r;
             dyn_opt_ass_type c(r.m_shape, dyn_opt_ass_type::value_type(0, false));
             EXPECT_NE(a.value().storage(), c.value().storage());
@@ -228,7 +230,7 @@ namespace xt
     TEST(xoptional_assembly, unchecked)
     {
         using opt = xtl::xoptional<int>;
-        opt_ass_type a = { { opt(1), opt(2, false) },{ opt(3, false), opt(4) } };
+        opt_ass_type a = {{opt(1), opt(2, false)}, {opt(3, false), opt(4)}};
         EXPECT_EQ(a.unchecked(0, 0), opt(1, true));
         EXPECT_EQ(a.unchecked(0, 1), opt(2, false));
         EXPECT_EQ(a.unchecked(1, 0), opt(3, false));
@@ -243,7 +245,7 @@ namespace xt
         EXPECT_EQ(a.at(0, 1), opt(2, false));
         EXPECT_EQ(a.at(1, 0), opt(3, false));
         EXPECT_EQ(a.at(1, 1), opt(4, true));
-        EXPECT_ANY_THROW(a.at(2, 2));
+        XT_EXPECT_ANY_THROW(a.at(2, 2));
     }
 
     TEST(xoptional_assembly, element)
@@ -279,16 +281,16 @@ namespace xt
         shape_type s = {3, 1, 4, 2};
         opt_ass_type vec(s);
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             shape_type s1 = s;
             bool res = vec.broadcast_shape(s1);
             EXPECT_EQ(s1, s);
             EXPECT_TRUE(res);
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             shape_type s2 = {3, 5, 1, 2};
             shape_type s2r = {3, 5, 4, 2};
             bool res = vec.broadcast_shape(s2);
@@ -296,16 +298,16 @@ namespace xt
             EXPECT_FALSE(res);
         }
 
+        SUBCASE("incompatible shapes")
         {
-            SCOPED_TRACE("incompatible shapes");
             shape_type s4 = {2, 1, 3, 2};
-            EXPECT_THROW(vec.broadcast_shape(s4), broadcast_error);
+            XT_EXPECT_THROW(vec.broadcast_shape(s4), broadcast_error);
         }
 
         {
             shape_type s2 = {3, 1, 4, 2};
+            SUBCASE("different dimensions")
             vec.resize(s2);
-            SCOPED_TRACE("different dimensions");
             shape_type s3 = {5, 3, 1, 4, 2};
             shape_type s3r = s3;
             bool res = vec.broadcast_shape(s3);
@@ -319,26 +321,34 @@ namespace xt
         using opt = xtl::xoptional<int>;
         std::vector<opt> vec = {opt(1), opt(2, false), opt(3, false), opt(4)};
 
+        SUBCASE("row_major storage iterator")
         {
-            SCOPED_TRACE("row_major storage iterator");
             opt_ass_type rma(opt_ass_type::shape_type({2, 2}));
             std::copy(vec.cbegin(), vec.cend(), rma.begin<layout_type::row_major>());
             EXPECT_EQ(vec[0], rma(0, 0));
             EXPECT_EQ(vec[1], rma(0, 1));
             EXPECT_EQ(vec[2], rma(1, 0));
             EXPECT_EQ(vec[3], rma(1, 1));
-            EXPECT_EQ(vec.size(), std::size_t(std::distance(rma.begin<layout_type::row_major>(), rma.end<layout_type::row_major>())));
+            EXPECT_EQ(
+                vec.size(),
+                std::size_t(std::distance(rma.begin<layout_type::row_major>(), rma.end<layout_type::row_major>()))
+            );
         }
 
+        SUBCASE("column_major storage iterator")
         {
-            SCOPED_TRACE("column_major storage iterator");
             cm_opt_ass_type cma(opt_ass_type::shape_type({2, 2}));
             std::copy(vec.cbegin(), vec.cend(), cma.begin<layout_type::column_major>());
             EXPECT_EQ(vec[0], cma(0, 0));
             EXPECT_EQ(vec[1], cma(1, 0));
             EXPECT_EQ(vec[2], cma(0, 1));
             EXPECT_EQ(vec[3], cma(1, 1));
-            EXPECT_EQ(vec.size(), std::size_t(std::distance(cma.begin<layout_type::column_major>(), cma.end<layout_type::column_major>())));
+            EXPECT_EQ(
+                vec.size(),
+                std::size_t(
+                    std::distance(cma.begin<layout_type::column_major>(), cma.end<layout_type::column_major>())
+                )
+            );
         }
     }
 
@@ -492,12 +502,18 @@ namespace xt
 
     TEST(xoptional_assembly, mixed_semantic)
     {
-        using d_opt_ass_type = xoptional_assembly<xarray<double, layout_type::row_major>, xarray<bool, layout_type::row_major>>;
+        using d_opt_ass_type = xoptional_assembly<
+            xarray<double, layout_type::row_major>,
+            xarray<bool, layout_type::row_major>>;
         using opt = xtl::xoptional<double>;
-        d_opt_ass_type a = {{opt(1.), opt(2., false), opt(3., false), opt(4.)},
-                            {opt(5., false), opt(6.), opt(7.), opt(8., false)}};
-        xarray_optional<double> b = {{opt(1.), opt(2.), opt(3., false), opt(4., false)},
-                                     {opt(5., false), opt(6.), opt(7.), opt(8.)}};
+        d_opt_ass_type a = {
+            {opt(1.), opt(2., false), opt(3., false), opt(4.)},
+            {opt(5., false), opt(6.), opt(7.), opt(8., false)}
+        };
+        xarray_optional<double> b = {
+            {opt(1.), opt(2.), opt(3., false), opt(4., false)},
+            {opt(5., false), opt(6.), opt(7.), opt(8.)}
+        };
 
         d_opt_ass_type res = a + b;
         EXPECT_EQ(res(0, 0), opt(2.));
@@ -513,13 +529,17 @@ namespace xt
     TEST(xoptional_assembly, mixed_expression)
     {
         using opt = xtl::xoptional<int>;
-        dyn_opt_ass_type a = { { opt(1), opt(2, false), opt(3, false), opt(4) },
-                               { opt(5, false), opt(6), opt(7), opt(8, false) } };
-        xarray<int> b = { { 1, 2, 3, 4}, { 5, 6, 7, 8} };
+        dyn_opt_ass_type a = {
+            {opt(1), opt(2, false), opt(3, false), opt(4)},
+            {opt(5, false), opt(6), opt(7), opt(8, false)}
+        };
+        xarray<int> b = {{1, 2, 3, 4}, {5, 6, 7, 8}};
 
         dyn_opt_ass_type c = a + b;
-        dyn_opt_ass_type res = { { opt(2), opt(4, false), opt(6, false), opt(8) },
-                                 { opt(10, false), opt(12), opt(14), opt(16, false) } };
+        dyn_opt_ass_type res = {
+            {opt(2), opt(4, false), opt(6, false), opt(8)},
+            {opt(10, false), opt(12), opt(14), opt(16, false)}
+        };
         EXPECT_EQ(res, c);
 
         dyn_opt_ass_type d = 2 * a;
diff --git a/test/test_xoptional_assembly_adaptor.cpp b/test/test_xoptional_assembly_adaptor.cpp
index 1fab2e801..8d27265c9 100644
--- a/test/test_xoptional_assembly_adaptor.cpp
+++ b/test/test_xoptional_assembly_adaptor.cpp
@@ -1,18 +1,18 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-
-#include "xtensor/xarray.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xoptional_assembly.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/optional/xoptional_assembly.hpp"
 
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -34,16 +34,16 @@ namespace xt
         flag_array_type hv = {{true, false, true}, {false, true, false}};
         adaptor_type a(v, hv);
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             adaptor_type b(a);
             compare_shape(a, b);
             EXPECT_EQ(a.value().storage(), b.value().storage());
             EXPECT_EQ(a.has_value().storage(), b.has_value().storage());
         }
 
+        SUBCASE("assignment operator")
         {
-            SCOPED_TRACE("assignment operator");
             array_type v2 = {{1, 2, 13}, {14, 15, 16}};
             flag_array_type hv2 = {{false, true, true}, {false, true, false}};
             adaptor_type c(v2, hv2);
@@ -62,8 +62,8 @@ namespace xt
         flag_array_type hv = {{true, false, true}, {false, true, false}};
         adaptor_type a(v, hv);
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             adaptor_type tmp(a);
             adaptor_type b(std::move(tmp));
             compare_shape(a, b);
@@ -71,8 +71,8 @@ namespace xt
             EXPECT_EQ(a.has_value().storage(), b.has_value().storage());
         }
 
+        SUBCASE("assignment operator")
         {
-            SCOPED_TRACE("assignment operator");
             array_type v2 = {{1, 2, 13}, {14, 15, 16}};
             flag_array_type hv2 = {{false, true, true}, {false, true, false}};
             adaptor_type c(v2, hv2);
@@ -138,8 +138,7 @@ namespace xt
         array_type v = {{1, 2, 3}, {4, 5, 6}};
         flag_array_type hv = {{true, false, true}, {false, true, false}};
         adaptor_type a(v, hv);
-        std::vector<std::size_t> v00({0, 0}), v01({0, 1}), v02({0, 2}),
-            v10({1, 0}), v11({1, 1}), v12({1, 2});
+        std::vector<std::size_t> v00({0, 0}), v01({0, 1}), v02({0, 2}), v10({1, 0}), v11({1, 1}), v12({1, 2});
 
         EXPECT_EQ(a.element(v00.begin(), v00.end()), opt(1, true));
         EXPECT_EQ(a.element(v01.begin(), v01.end()), opt(2, false));
@@ -155,8 +154,7 @@ namespace xt
         array_type v = {{1, 2, 3}, {4, 5, 6}};
         flag_array_type hv = {{true, false, true}, {false, true, false}};
         adaptor_type a(v, hv);
-        xindex i00({0, 0}), i01({0, 1}), i02({0, 2}),
-            i10({1, 0}), i11({1, 1}), i12({1, 2});
+        xindex i00({0, 0}), i01({0, 1}), i02({0, 2}), i10({1, 0}), i11({1, 1}), i12({1, 2});
 
         EXPECT_EQ(a[i00], opt(1, true));
         EXPECT_EQ((a[{0, 0}]), opt(1, true));
@@ -180,16 +178,16 @@ namespace xt
         flag_array_type hv(s);
         adaptor_type a(v, hv);
 
+        SUBCASE("same shape")
         {
-            SCOPED_TRACE("same shape");
             shape_type s1 = s;
             bool res = a.broadcast_shape(s1);
             EXPECT_EQ(s1, s);
             EXPECT_TRUE(res);
         }
 
+        SUBCASE("different shape")
         {
-            SCOPED_TRACE("different shape");
             shape_type s2 = {3, 5, 1, 2};
             shape_type s2r = {3, 5, 4, 2};
             bool res = a.broadcast_shape(s2);
@@ -197,16 +195,16 @@ namespace xt
             EXPECT_FALSE(res);
         }
 
+        SUBCASE("incompatible shapes")
         {
-            SCOPED_TRACE("incompatible shapes");
             shape_type s4 = {2, 1, 3, 2};
-            EXPECT_THROW(a.broadcast_shape(s4), broadcast_error);
+            XT_EXPECT_THROW(a.broadcast_shape(s4), broadcast_error);
         }
 
         {
             shape_type s2 = {3, 1, 4, 2};
+            SUBCASE("different dimensions")
             a.resize(s2);
-            SCOPED_TRACE("different dimensions");
             shape_type s3 = {5, 3, 1, 4, 2};
             shape_type s3r = s3;
             bool res = a.broadcast_shape(s3);
@@ -220,8 +218,8 @@ namespace xt
         using opt = xtl::xoptional<int>;
         std::vector<opt> vec = {opt(1), opt(2, false), opt(3, false), opt(4)};
 
+        SUBCASE("row_major storage iterator")
         {
-            SCOPED_TRACE("row_major storage iterator");
             xarray<int, layout_type::row_major> v;
             xarray<bool, layout_type::row_major> hv;
             xoptional_assembly_adaptor<decltype(v)&, decltype(hv)&> rma(v, hv);
@@ -231,11 +229,14 @@ namespace xt
             EXPECT_EQ(vec[1], rma(0, 1));
             EXPECT_EQ(vec[2], rma(1, 0));
             EXPECT_EQ(vec[3], rma(1, 1));
-            EXPECT_EQ(vec.size(), std::size_t(std::distance(rma.begin<layout_type::row_major>(), rma.end<layout_type::row_major>())));
+            EXPECT_EQ(
+                vec.size(),
+                std::size_t(std::distance(rma.begin<layout_type::row_major>(), rma.end<layout_type::row_major>()))
+            );
         }
 
+        SUBCASE("column_major storage iterator")
         {
-            SCOPED_TRACE("column_major storage iterator");
             xarray<int, layout_type::row_major> v;
             xarray<bool, layout_type::row_major> hv;
             xoptional_assembly_adaptor<decltype(v)&, decltype(hv)&> cma(v, hv);
@@ -245,7 +246,12 @@ namespace xt
             EXPECT_EQ(vec[1], cma(1, 0));
             EXPECT_EQ(vec[2], cma(0, 1));
             EXPECT_EQ(vec[3], cma(1, 1));
-            EXPECT_EQ(vec.size(), std::size_t(std::distance(cma.begin<layout_type::column_major>(), cma.end<layout_type::column_major>())));
+            EXPECT_EQ(
+                vec.size(),
+                std::size_t(
+                    std::distance(cma.begin<layout_type::column_major>(), cma.end<layout_type::column_major>())
+                )
+            );
         }
     }
 
diff --git a/test/test_xoptional_assembly_storage.cpp b/test/test_xoptional_assembly_storage.cpp
index afc986c12..60a44752f 100644
--- a/test/test_xoptional_assembly_storage.cpp
+++ b/test/test_xoptional_assembly_storage.cpp
@@ -1,17 +1,17 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
-
-#include "gtest/gtest.h"
-
-#include "xtensor/xstorage.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xoptional_assembly_storage.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xstorage.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/optional/xoptional_assembly_storage.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
diff --git a/test/test_xpad.cpp b/test/test_xpad.cpp
new file mode 100644
index 000000000..32f684f2c
--- /dev/null
+++ b/test/test_xpad.cpp
@@ -0,0 +1,364 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <complex>
+#include <limits>
+
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xpad.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    TEST(xpad, constant_a)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {
+            {0, 0, 0, 0, 0, 0, 0, 0, 0},
+            {0, 0, 0, 0, 0, 0, 0, 0, 0},
+            {0, 0, 0, 0, 1, 2, 0, 0, 0},
+            {0, 0, 0, 3, 4, 5, 0, 0, 0},
+            {0, 0, 0, 0, 0, 0, 0, 0, 0},
+            {0, 0, 0, 0, 0, 0, 0, 0, 0}
+        };
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{2, 2}, {3, 3}}, xt::pad_mode::constant);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, constant_b)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, 0, xt::pad_mode::constant);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, constant_c)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2, 0, 0}, {3, 4, 5, 0, 0}, {0, 0, 0, 0, 0}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{0, 1}, {0, 2}}, xt::pad_mode::constant);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, constant_d)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 0, 0, 0, 0}, {0, 0, 0, 1, 2}, {0, 0, 3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{1, 0}, {2, 0}}, xt::pad_mode::constant);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, edge_a)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {
+            {0, 0, 0, 0, 1, 2, 2, 2, 2},
+            {0, 0, 0, 0, 1, 2, 2, 2, 2},
+            {0, 0, 0, 0, 1, 2, 2, 2, 2},
+            {3, 3, 3, 3, 4, 5, 5, 5, 5},
+            {3, 3, 3, 3, 4, 5, 5, 5, 5},
+            {3, 3, 3, 3, 4, 5, 5, 5, 5}
+        };
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{2, 2}, {3, 3}}, xt::pad_mode::edge);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, edge_b)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, 0, xt::pad_mode::edge);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, edge_c)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2, 2, 2}, {3, 4, 5, 5, 5}, {3, 4, 5, 5, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{0, 1}, {0, 2}}, xt::pad_mode::edge);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, edge_d)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 0, 0, 1, 2}, {0, 0, 0, 1, 2}, {3, 3, 3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{1, 0}, {2, 0}}, xt::pad_mode::edge);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, wrap_a)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {
+            {0, 1, 2, 0, 1, 2, 0, 1, 2},
+            {3, 4, 5, 3, 4, 5, 3, 4, 5},
+            {0, 1, 2, 0, 1, 2, 0, 1, 2},
+            {3, 4, 5, 3, 4, 5, 3, 4, 5},
+            {0, 1, 2, 0, 1, 2, 0, 1, 2},
+            {3, 4, 5, 3, 4, 5, 3, 4, 5}
+        };
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{2, 2}, {3, 3}}, xt::pad_mode::wrap);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, wrap_b)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, 0, xt::pad_mode::wrap);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, wrap_c)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2, 0, 1}, {3, 4, 5, 3, 4}, {0, 1, 2, 0, 1}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{0, 1}, {0, 2}}, xt::pad_mode::wrap);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, wrap_d)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{4, 5, 3, 4, 5}, {1, 2, 0, 1, 2}, {4, 5, 3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{1, 0}, {2, 0}}, xt::pad_mode::wrap);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, symmetric_a)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {
+            {5, 4, 3, 3, 4, 5, 5, 4, 3},
+            {2, 1, 0, 0, 1, 2, 2, 1, 0},
+            {2, 1, 0, 0, 1, 2, 2, 1, 0},
+            {5, 4, 3, 3, 4, 5, 5, 4, 3},
+            {5, 4, 3, 3, 4, 5, 5, 4, 3},
+            {2, 1, 0, 0, 1, 2, 2, 1, 0}
+        };
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{2, 2}, {3, 3}}, xt::pad_mode::symmetric);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, symmetric_b)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, 0, xt::pad_mode::symmetric);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, symmetric_c)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2, 2, 1}, {3, 4, 5, 5, 4}, {3, 4, 5, 5, 4}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{0, 1}, {0, 2}}, xt::pad_mode::symmetric);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, symmetric_d)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{1, 0, 0, 1, 2}, {1, 0, 0, 1, 2}, {4, 3, 3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{1, 0}, {2, 0}}, xt::pad_mode::symmetric);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, reflect_a)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b =
+            {{5, 4, 3, 4, 5, 4, 3}, {2, 1, 0, 1, 2, 1, 0}, {5, 4, 3, 4, 5, 4, 3}, {2, 1, 0, 1, 2, 1, 0}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{1, 1}, {2, 2}}, xt::pad_mode::reflect);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, reflect_b)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, 0, xt::pad_mode::reflect);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, reflect_c)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2, 1, 0}, {3, 4, 5, 4, 3}, {0, 1, 2, 1, 0}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{0, 1}, {0, 2}}, xt::pad_mode::reflect);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, reflect_d)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+
+        xt::xtensor<size_t, 2> b = {{5, 4, 3, 4, 5}, {2, 1, 0, 1, 2}, {5, 4, 3, 4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::pad(a, {{1, 0}, {2, 0}}, xt::pad_mode::reflect);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, tile_a)
+    {
+        xt::xtensor<size_t, 1> a = xt::arange<size_t>(3);
+
+        xt::xtensor<size_t, 1> b = {0, 1, 2, 0, 1, 2, 0, 1, 2};
+
+        xt::xtensor<size_t, 1> c = xt::tile(a, 3u);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, tile_b)
+    {
+        xt::xtensor<size_t, 2> a = xt::arange<size_t>(3 * 2).reshape({3, 2});
+
+        xt::xtensor<size_t, 2> b = {{0, 1}, {2, 3}, {4, 5}, {0, 1}, {2, 3}, {4, 5}, {0, 1}, {2, 3}, {4, 5}};
+
+        xt::xtensor<size_t, 2> c = xt::tile(a, 3u);
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, tile_c)
+    {
+        xt::xtensor<size_t, 2> a = xt::arange<size_t>(3 * 2).reshape({3, 2});
+
+        xt::xtensor<size_t, 2> b = {
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5},
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5},
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5}
+        };
+
+        xt::xtensor<size_t, 2> c = xt::tile(a, {3u, 4u});
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, tile_d)
+    {
+        xt::xtensor<size_t, 2> a = xt::arange<size_t>(3 * 2).reshape({3, 2});
+
+        xt::xtensor<size_t, 2> b = {
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5},
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5},
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5}
+        };
+
+        xt::xtensor<size_t, 2> c = xt::tile(a, std::array<size_t, 2>{{3u, 4u}});
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, tile_e)
+    {
+        xt::xarray<size_t> a = xt::arange<size_t>(3 * 2).reshape({3, 2});
+
+        xt::xtensor<size_t, 2> b = {
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5},
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5},
+            {0, 1, 0, 1, 0, 1, 0, 1},
+            {2, 3, 2, 3, 2, 3, 2, 3},
+            {4, 5, 4, 5, 4, 5, 4, 5}
+        };
+
+        xt::xtensor<size_t, 2> c = xt::tile(a, std::vector<size_t>{{3u, 4u}});
+
+        EXPECT_EQ(b, c);
+    }
+
+    TEST(xpad, tile_f)
+    {
+        xt::xarray<double> m = xt::tile(xt::expand_dims(xt::eye<double>(4), 0), 3u);
+        xt::xarray<double> expected = {
+            {{1., 0., 0., 0.}, {0., 1., 0., 0.}, {0., 0., 1., 0.}, {0., 0., 0., 1.}},
+            {{1., 0., 0., 0.}, {0., 1., 0., 0.}, {0., 0., 1., 0.}, {0., 0., 0., 1.}},
+            {{1., 0., 0., 0.}, {0., 1., 0., 0.}, {0., 0., 1., 0.}, {0., 0., 0., 1.}}
+        };
+        EXPECT_EQ(m, expected);
+    }
+}
diff --git a/test/test_xrandom.cpp b/test/test_xrandom.cpp
index 0c68c0926..0d824a794 100644
--- a/test/test_xrandom.cpp
+++ b/test/test_xrandom.cpp
@@ -1,15 +1,27 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xview.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include <type_traits>
+
+#if (defined(__GNUC__) && !defined(__clang__))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#include "xtensor/generators/xrandom.hpp"
+#pragma GCC diagnostic pop
+#else
+#include "xtensor/generators/xrandom.hpp"
+#endif
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/misc/xset_operation.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -37,8 +49,90 @@ namespace xt
 
         ASSERT_EQ(same_a, same_b);
 
-        // check that it compiles
+        // check that it compiles and generates same random numbers for the same seed
+        random::seed(0);
         xarray<int> q = random::randint<int>({3, 3});
+        random::seed(0);
+        xarray<int> same_q = random::randint<int>({3, 3});
+        ASSERT_EQ(q, same_q);
+
+        random::seed(0);
+        xarray<int> binom = random::binomial<int>({3, 3});
+        random::seed(0);
+        xarray<int> same_binom = random::binomial<int>({3, 3});
+        ASSERT_EQ(binom, same_binom);
+
+        random::seed(0);
+        xarray<int> geom = random::geometric<int>({3, 3});
+        random::seed(0);
+        xarray<int> same_geom = random::geometric<int>({3, 3});
+        ASSERT_EQ(geom, same_geom);
+
+        random::seed(0);
+        xarray<int> neg_binom = random::negative_binomial<int>({3, 3});
+        random::seed(0);
+        xarray<int> same_neg_binom = random::negative_binomial<int>({3, 3});
+        ASSERT_EQ(neg_binom, same_neg_binom);
+
+        random::seed(0);
+        xarray<int> poisson = random::poisson<int>({3, 3});
+        random::seed(0);
+        xarray<int> same_poisson = random::poisson<int>({3, 3});
+        ASSERT_EQ(poisson, same_poisson);
+
+        random::seed(0);
+        xarray<double> exp = random::exponential<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_exp = random::exponential<double>({3, 3});
+        ASSERT_EQ(exp, same_exp);
+
+        random::seed(0);
+        xarray<double> gamma = random::gamma<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_gamma = random::gamma<double>({3, 3});
+        ASSERT_EQ(gamma, same_gamma);
+
+        random::seed(0);
+        xarray<double> weibull = random::weibull<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_weibull = random::weibull<double>({3, 3});
+        ASSERT_EQ(weibull, same_weibull);
+
+        random::seed(0);
+        xarray<double> extreme_val = random::extreme_value<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_extreme_val = random::extreme_value<double>({3, 3});
+        ASSERT_EQ(extreme_val, same_extreme_val);
+
+        random::seed(0);
+        xarray<double> lnormal = random::lognormal<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_lnormal = random::lognormal<double>({3, 3});
+        ASSERT_EQ(lnormal, same_lnormal);
+
+        random::seed(0);
+        xarray<double> xsqr = random::chi_squared<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_xsqr = random::chi_squared<double>({3, 3});
+        ASSERT_EQ(xsqr, same_xsqr);
+
+        random::seed(0);
+        xarray<double> cauchy = random::cauchy<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_cauchy = random::cauchy<double>({3, 3});
+        ASSERT_EQ(cauchy, same_cauchy);
+
+        random::seed(0);
+        xarray<double> fisher_f = random::fisher_f<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_fisher_f = random::fisher_f<double>({3, 3});
+        ASSERT_EQ(fisher_f, same_fisher_f);
+
+        random::seed(0);
+        xarray<double> student_t = random::student_t<double>({3, 3});
+        random::seed(0);
+        xarray<double> same_student_t = random::student_t<double>({3, 3});
+        ASSERT_EQ(student_t, same_student_t);
 
         // checking if internal state needs reset
         auto n_dist = random::randn<double>({3, 3});
@@ -67,13 +161,29 @@ namespace xt
         auto acr3 = xt::random::choice(a, 5, true);
         ASSERT_EQ(acr1, acr3);
         ASSERT_NE(acr1, acr2);
+    }
 
-        xarray<double> b = {-1, 1};
-        xt::random::seed(42);
-        ASSERT_THROW(xt::random::choice(b, 5, false), std::runtime_error);
-        ASSERT_NO_THROW(xt::random::choice(b, 5, true));
-        xarray<double> multidim_input = { {1,2,3}, {3,4,5} };
-        ASSERT_THROW(xt::random::choice(multidim_input, 5, true), std::runtime_error);
+    TEST(xrandom, weighted_choice)
+    {
+        xarray<int> a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        xarray<double> w = {1, 0, 2, 0, 1, 0, 1, 0, 2, 0, 1, 0};
+
+        for (bool replace : {true, false})
+        {
+            xt::random::seed(42);
+            auto ac1 = xt::random::choice(a, 6, w, replace);
+            auto ac2 = xt::random::choice(a, 6, w, replace);
+            xt::random::seed(42);
+            auto ac3 = xt::random::choice(a, 6, w, replace);
+            static_assert(
+                std::is_same<decltype(a)::value_type, decltype(ac1)::value_type>::value,
+                "Elements must be same type"
+            );
+            ASSERT_EQ(ac1, ac3);
+            ASSERT_NE(ac1, ac2);
+            ASSERT_TRUE(all(isin(ac1, a)));
+            ASSERT_TRUE(all(equal(ac1 % 2, 1)));
+        }
     }
 
     TEST(xrandom, shuffle)
@@ -96,9 +206,9 @@ namespace xt
         auto ar = a;
 
         xt::random::seed(123);
-        // Unfortunately MSVC & OS X seem to produce different shuffles even though the
-        // generated integer sequence should be the same ...
-#ifdef __linux__
+        // Unfortunately MSVC, OS X, and Clang on Linux seem to produce different
+        // shuffles even though the generated integer sequence should be the same ...
+#if defined(__linux__) && (!defined(__clang__) || (__clang_major__ < 11))
         xt::random::shuffle(a);
         EXPECT_EQ(xt::view(ar, keep(0, 1, 2)), a);
         xt::random::shuffle(a);
@@ -125,7 +235,20 @@ namespace xt
         xt::random::shuffle(a);
         EXPECT_FALSE(std::is_sorted(a.begin(), a.end()));
 #endif
+    }
+
+    TEST(xrandom, poisson_geometric_default_type)
+    {
+        // poisson and geometric have no parameter from which T can be deduced,
+        // so they require a default T (= int) to be callable without explicit template arg.
+        auto p = random::poisson({3, 3}, 1.0);
+        static_assert(std::is_same<decltype(p)::value_type, int>::value, "poisson default T must be int");
+
+        auto g = random::geometric({3, 3}, 0.5);
+        static_assert(std::is_same<decltype(g)::value_type, int>::value, "geometric default T must be int");
 
+        auto p2 = random::poisson({3, 3});
+        static_assert(std::is_same<decltype(p2)::value_type, int>::value, "poisson default T must be int");
     }
 
     TEST(xrandom, permutation)
diff --git a/test/test_xreducer.cpp b/test/test_xreducer.cpp
index 8145b8c0b..aa0a824b5 100644
--- a/test/test_xreducer.cpp
+++ b/test/test_xreducer.cpp
@@ -1,41 +1,78 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xutils.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xmath.hpp"
-#include "xtensor/xreducer.hpp"
-#include "xtensor/xview.hpp"
-#include "xtensor/xmanipulation.hpp"
-#include "xtensor/xrandom.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "test_common_macros.hpp"
+#if (defined(__GNUC__) && !defined(__clang__))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wfloat-conversion"
+#include "xtensor/core/xmath.hpp"
+#pragma GCC diagnostic pop
+#else
+#include "xtensor/core/xmath.hpp"
+#endif
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/optional/xoptional.hpp"
+#include "xtensor/optional/xoptional_assembly.hpp"
+#include "xtensor/reducers/xreducer.hpp"
+#include "xtensor/utils/xutils.hpp"
+#include "xtensor/views/xview.hpp"
 
 namespace xt
 {
+
+#define CHECK_RESULT_TYPE(EXPRESSION, EXPECTED_TYPE)                                 \
+    {                                                                                \
+        using result_type = typename std::decay_t<decltype(EXPRESSION)>::value_type; \
+        EXPECT_TRUE((std::is_same<result_type, EXPECTED_TYPE>::value));              \
+    }
+
+#define CHECK_TAG_TYPE(EXPRESSION, EXPECTED_TYPE)                                        \
+    {                                                                                    \
+        using result_type = typename std::decay_t<decltype(EXPRESSION)>::expression_tag; \
+        EXPECT_TRUE((std::is_same<result_type, EXPECTED_TYPE>::value));                  \
+    }
+
+#define CHECK_TYPE(VALUE, EXPECTED_TYPE)                                \
+    {                                                                   \
+        using result_type = typename std::decay_t<decltype(VALUE)>;     \
+        EXPECT_TRUE((std::is_same<result_type, EXPECTED_TYPE>::value)); \
+    }
+
     struct xreducer_features
     {
         using axes_type = std::array<std::size_t, 2>;
-        axes_type m_axes;
-        xarray<double> m_a;
         using shape_type = xarray<double>::shape_type;
-
+        using xarray_type = xarray<double>;
         using func = xreducer_functors<std::plus<double>>;
-        xreducer<func, const xarray<double>&, axes_type> m_red;
+
+        axes_type m_axes;
+
+        xarray_type m_a;
+
+        xreducer<func, const xarray_type&, axes_type, xt::reducer_options<double, std::tuple<xt::evaluation_strategy::lazy_type>>>
+            m_red;
 
         xreducer_features();
     };
 
     xreducer_features::xreducer_features()
-        : m_axes({1, 3}), m_a(ones<double>({3, 2, 4, 6, 5})),
-          m_red(func(), m_a, m_axes)
+        : m_axes({1, 3})
+        , m_a(ones<double>({3, 2, 4, 6, 5}))
+        , m_red(func(), m_a, m_axes, xt::evaluation_strategy::lazy)
     {
         for (std::size_t i = 0; i < 2; ++i)
         {
@@ -46,9 +83,121 @@ namespace xt
         }
     }
 
+    struct xreducer_opt_features
+    {
+        using axes_type = std::array<std::size_t, 2>;
+        using shape_type = typename xarray_optional<double>::shape_type;
+
+        using xarray_of_optional_type = xarray<xtl::xoptional<double>>;
+        using xarray_optional_type = xarray_optional<double>;
+        using optional_assembly_type = xoptional_assembly<xarray<double>, xarray<bool>>;
+
+        axes_type m_axes;
+
+        xarray_of_optional_type m_array_of_optional, m_simple_array_of_optional;
+
+        xarray_optional_type m_array_optional, m_simple_array_optional;
+
+        optional_assembly_type m_optional_assembly, m_simple_optional_assembly;
+
+        xreducer_opt_features()
+            : m_axes({1, 3})
+            , m_array_of_optional(ones<xtl::xoptional<double>>({3, 2, 4, 6, 5}))
+            , m_array_optional(ones<xtl::xoptional<double>>({3, 2, 4, 6, 5}))
+            , m_optional_assembly(ones<xtl::xoptional<double>>({3, 2, 4, 6, 5}))
+        {
+            for (std::size_t i = 0; i < 2; ++i)
+            {
+                for (std::size_t j = 0; j < 6; ++j)
+                {
+                    m_array_of_optional(1, i, 1, j, 1) = 2;
+                    m_array_optional(1, i, 1, j, 1) = 2;
+                    m_optional_assembly(1, i, 1, j, 1) = 2;
+                }
+            }
+            m_array_of_optional(0, 0, 0, 0, 0) = xtl::missing<double>();
+            m_array_optional(0, 0, 0, 0, 0) = xtl::missing<double>();
+            m_optional_assembly(0, 0, 0, 0, 0) = xtl::missing<double>();
+
+            m_simple_array_of_optional = xarray_of_optional_type({{1, 2, 0}, {4, 8, xtl::missing<double>()}});
+            m_simple_array_optional = xarray_optional_type({{1, 2, 0}, {4, 8, xtl::missing<double>()}});
+            m_simple_optional_assembly = optional_assembly_type({{1, 2, 0}, {4, 8, xtl::missing<double>()}});
+        }
+    };
+
+#define TEST_EXPRESSION_TAG(INPUT, EXPECTED) \
+    auto res = xt::sum(INPUT, feats.m_axes); \
+    CHECK_TAG_TYPE(res, EXPECTED);
+
+    TEST(xreducer, expression_tag)
+    {
+        xreducer_features feats;
+        TEST_EXPRESSION_TAG(feats.m_a, xtensor_expression_tag);
+    }
+
+    TEST(xreducer_array_of_optional, expression_tag)
+    {
+        xreducer_opt_features feats;
+        TEST_EXPRESSION_TAG(feats.m_array_of_optional, xtensor_expression_tag);
+    }
+
+    TEST(xreducer_array_optional, expression_tag)
+    {
+        xreducer_opt_features feats;
+        TEST_EXPRESSION_TAG(feats.m_array_optional, xoptional_expression_tag);
+    }
+
+    TEST(xreducer_optional_assembly, expression_tag)
+    {
+        xreducer_opt_features feats;
+        TEST_EXPRESSION_TAG(feats.m_optional_assembly, xoptional_expression_tag);
+    }
+
+#undef TEST_EXPRESSION_TAG
+
+#define TEST_VALUE_HAS_VALUE(INPUT, V_TYPE, OPTIONAL)                                 \
+    using result_type = std::conditional_t<OPTIONAL, xtl::xoptional<double>, double>; \
+                                                                                      \
+    auto res = xt::sum(INPUT, feats.m_axes);                                          \
+    CHECK_RESULT_TYPE(res, result_type);                                              \
+    CHECK_TYPE(xt::value(res)(1, 1, 1), V_TYPE);                                      \
+    EXPECT_EQ(!OPTIONAL, xt::has_value(res)(0, 0, 0));                                \
+    EXPECT_TRUE(xt::has_value(res)(1, 1, 1));
+
+    TEST(xreducer, value_has_value)
+    {
+        xreducer_features feats;
+        TEST_VALUE_HAS_VALUE(feats.m_a, double, false);
+    }
+
+    /*
+        TEST(xreducer_array_of_optional, value_has_value)
+        {
+            xreducer_opt_features feats;
+            TEST_VALUE_HAS_VALUE(feats.m_array_of_optional, xtl::xoptional<double>, true);  // TODO: fail, the
+       mask is not reflecting the missing values
+        }
+    */
+    TEST(xreducer_array_optional, value_has_value)
+    {
+        xreducer_opt_features feats;
+        TEST_VALUE_HAS_VALUE(feats.m_array_optional, double, true);
+    }
+
+    TEST(xreducer_optional_assembly, value_has_value)
+    {
+        xreducer_opt_features feats;
+        TEST_VALUE_HAS_VALUE(feats.m_optional_assembly, double, true);
+    }
+
+#undef TEST_VALUE_HAS_VALUE
+
     TEST(xreducer, functor_type)
     {
-        auto sum = [](auto const& left, auto const& right) { return left + right; };
+        auto sum = [](const auto& left, const auto& right)
+        {
+            return left + right;
+        };
         auto sum_functor = xt::make_xreducer_functor(sum);
         xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
         xt::xarray<int> a_sums = xt::reduce(std::move(sum_functor), a, {1});
@@ -56,15 +205,18 @@ namespace xt
         xt::xarray<int> expect = {6, 15};
         EXPECT_EQ(a_sums, expect);
         EXPECT_EQ(a_sums2, expect);
+
+        xt::xarray<int> a_sums3 = xt::reduce(sum, a, {1});
+        EXPECT_EQ(a_sums3, expect);
     }
 
     TEST(xreducer, errors)
     {
         xt::xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
-        EXPECT_THROW(xt::sum(a, {1, 0}), std::runtime_error);
-        EXPECT_THROW(xt::sum(a, {0, 2}), std::runtime_error);
-        EXPECT_THROW(xt::sum(a, {1, 0}, evaluation_strategy::immediate()), std::runtime_error);
-        EXPECT_THROW(xt::sum(a, {0, 2}, evaluation_strategy::immediate()), std::runtime_error);
+        XT_EXPECT_THROW(xt::sum(a, {1, 0}), std::runtime_error);
+        XT_EXPECT_THROW(xt::sum(a, {0, 2}), std::runtime_error);
+        XT_EXPECT_THROW(xt::sum(a, {1, 0}, evaluation_strategy::immediate), std::runtime_error);
+        XT_EXPECT_THROW(xt::sum(a, {0, 2}, evaluation_strategy::immediate), std::runtime_error);
     }
 
     TEST(xreducer, shape)
@@ -82,6 +234,9 @@ namespace xt
         EXPECT_EQ(24, features.m_red(1, 1, 1));
         EXPECT_EQ(features.m_red(0, 1), features.m_red(0, 0, 1));
         EXPECT_EQ(features.m_red(1, 2, 1, 0, 1), features.m_red(1, 0, 1));
+
+        EXPECT_EQ(12, features.m_red(2, 0, 0, 0));
+        EXPECT_EQ(12, features.m_red());
     }
 
     TEST(xreducer, unchecked)
@@ -103,8 +258,8 @@ namespace xt
         xreducer_features features;
         EXPECT_EQ(12, features.m_red.at(0, 0, 0));
         EXPECT_EQ(24, features.m_red.at(1, 1, 1));
-        EXPECT_ANY_THROW(features.m_red.at(10, 10, 10));
-        EXPECT_ANY_THROW(features.m_red.at(0, 0, 0, 0));
+        XT_EXPECT_ANY_THROW(features.m_red.at(10, 10, 10));
+        XT_EXPECT_ANY_THROW(features.m_red.at(0, 0, 0, 0));
     }
 
     TEST(xreducer, iterator)
@@ -115,7 +270,7 @@ namespace xt
         const xreducer_features::shape_type& s = features.m_red.shape();
         std::size_t nb_iter = 1;
         nb_iter = std::accumulate(s.cbegin(), s.cend(), nb_iter, std::multiplies<std::size_t>());
-        std::advance(iter, nb_iter);
+        std::advance(iter, static_cast<std::ptrdiff_t>(nb_iter));
         EXPECT_EQ(iter_end, iter);
     }
 
@@ -126,8 +281,77 @@ namespace xt
         xarray<double> expected = 12 * ones<double>({3, 4, 5});
         expected(1, 1, 1) = 24;
         EXPECT_EQ(expected, res);
+
+        xarray_optional<double> opt_expected = 12 * ones<double>({3, 4, 5});
+        opt_expected(1, 1, 1) = 24;
+
+// TODO: fix the reducer assignment issue in multithreaded env and enable
+// these tests again.
+#if !defined(XTENSOR_USE_TBB) && !defined(XTENSOR_USE_OPENMP)
+        xreducer_opt_features::xarray_of_optional_type opt_res1 = res;
+        CHECK_RESULT_TYPE(opt_res1, xtl::xoptional<double>);
+        CHECK_TYPE(xt::value(opt_res1)(1, 1, 1), xtl::xoptional<double>);
+        EXPECT_EQ(xt::has_value(opt_res1), xt::full_like(res, true));
+        EXPECT_EQ(opt_expected, opt_res1);
+
+        xreducer_opt_features::xarray_optional_type opt_res2 = res;
+        CHECK_RESULT_TYPE(opt_res2, xtl::xoptional<double>);
+        CHECK_TYPE(xt::value(opt_res2)(1, 1, 1), double);
+        EXPECT_EQ(xt::has_value(opt_res2), xt::full_like(res, true));
+        EXPECT_EQ(opt_expected, opt_res2);
+
+        xreducer_opt_features::optional_assembly_type opt_res3 = res;
+        CHECK_RESULT_TYPE(opt_res3, xtl::xoptional<double>);
+        CHECK_TYPE(xt::value(opt_res3)(1, 1, 1), double);
+        EXPECT_EQ(xt::has_value(opt_res3), xt::full_like(res, true));
+        EXPECT_EQ(opt_expected, opt_res3);
+#endif
+    }
+
+#define TEST_OPT_ASSIGNMENT(INPUT)                                \
+    auto res = xt::sum(INPUT, feats.m_axes);                      \
+                                                                  \
+    xreducer_opt_features::xarray_of_optional_type res1 = res;    \
+    CHECK_RESULT_TYPE(res1, xtl::xoptional<double>);              \
+    CHECK_TYPE(xt::value(res1)(1, 1, 1), xtl::xoptional<double>); \
+    EXPECT_EQ(res1(1, 1, 1), 24.);                                \
+    /* EXPECT_FALSE(xt::has_value(res1)(0, 0, 0)); */             \
+    EXPECT_TRUE(xt::has_value(res1)(1, 1, 1));                    \
+                                                                  \
+    xreducer_opt_features::xarray_optional_type res2 = res;       \
+    CHECK_RESULT_TYPE(res2, xtl::xoptional<double>);              \
+    CHECK_TYPE(xt::value(res2)(1, 1, 1), double);                 \
+    EXPECT_EQ(res2(1, 1, 1), 24.);                                \
+    EXPECT_FALSE(xt::has_value(res2)(0, 0, 0));                   \
+    EXPECT_TRUE(xt::has_value(res2)(1, 1, 1));                    \
+                                                                  \
+    xreducer_opt_features::optional_assembly_type res3 = res;     \
+    CHECK_RESULT_TYPE(res3, xtl::xoptional<double>);              \
+    CHECK_TYPE(xt::value(res3)(1, 1, 1), double);                 \
+    EXPECT_EQ(res3(1, 1, 1), 24.);                                \
+    EXPECT_FALSE(xt::has_value(res3)(0, 0, 0));                   \
+    EXPECT_TRUE(xt::has_value(res3)(1, 1, 1));
+
+    TEST(xreducer_array_of_optional, assign)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_ASSIGNMENT(feats.m_array_of_optional)
     }
 
+    TEST(xreducer_array_optional, assign)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_ASSIGNMENT(feats.m_array_optional)
+    }
+
+    TEST(xreducer_optional_assembly, assign)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_ASSIGNMENT(feats.m_optional_assembly)
+    }
+
+#undef TEST_OPT_ASSIGNMENT
+
     TEST(xreducer, sum)
     {
         xreducer_features features;
@@ -137,6 +361,32 @@ namespace xt
         EXPECT_EQ(expected, res);
     }
 
+#define TEST_OPT_SUM(INPUT)                          \
+    auto res = xt::sum(INPUT, feats.m_axes);         \
+    EXPECT_EQ(res.dimension(), std::size_t(3));      \
+    EXPECT_EQ(res(0, 0, 0), xtl::missing<double>()); \
+    EXPECT_EQ(res(1, 1, 1), 24.);
+
+    TEST(xreducer_array_of_optional, sum)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SUM(feats.m_array_of_optional);
+    }
+
+    TEST(xreducer_array_optional, sum)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SUM(feats.m_array_optional);
+    }
+
+    TEST(xreducer_optional_assembly, sum)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SUM(feats.m_optional_assembly);
+    }
+
+#undef TEST_OPT_SUM
+
     TEST(xreducer, sum_tensor)
     {
         xtensor<double, 2> m = {{1, 2}, {3, 4}};
@@ -150,8 +400,8 @@ namespace xt
     {
         xarray<double> m = {{1, 0}, {3, 4}};
 
-        xarray<double> res1 = xt::count_nonzero(m, {1});
-        xarray<double> res2 = xt::count_nonzero(m, 1);
+        xarray<std::size_t> res1 = xt::count_nonzero(m, {1});
+        xarray<std::size_t> res2 = xt::count_nonzero(m, 1);
         EXPECT_EQ(res1, res2);
 
         xarray<double> res3 = xt::sum(m, {1});
@@ -159,6 +409,36 @@ namespace xt
         EXPECT_EQ(res3, res4);
     }
 
+#define TEST_OPT_SINGLE_AXIS(INPUT)                                    \
+    auto res = xt::sum(INPUT, feats.m_axes);                           \
+    xarray_optional<std::size_t> res1 = xt::count_nonzero(INPUT, {1}); \
+    xarray_optional<std::size_t> res2 = xt::count_nonzero(INPUT, 1);   \
+    EXPECT_EQ(res1, res2);                                             \
+                                                                       \
+    xarray_optional<double> res3 = xt::sum(INPUT, {1});                \
+    xarray_optional<double> res4 = xt::sum(INPUT, 1);                  \
+    EXPECT_EQ(res3, res4);
+
+    TEST(xreducer_array_of_optional, single_axis_sugar)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SINGLE_AXIS(feats.m_array_of_optional);
+    }
+
+    TEST(xreducer_array_optional, single_axis_sugar)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SINGLE_AXIS(feats.m_array_optional);
+    }
+
+    TEST(xreducer_optional_assembly, single_axis_sugar)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SINGLE_AXIS(feats.m_optional_assembly);
+    }
+
+#undef TEST_OPT_SINGLE_AXIS
+
     TEST(xreducer, sum2)
     {
         xarray<double> u = ones<double>({2, 4});
@@ -200,17 +480,68 @@ namespace xt
         EXPECT_EQ(res(), expected);
     }
 
+#define TEST_OPT_SUM_ALL(INPUT) \
+    auto res = xt::sum(INPUT);  \
+    EXPECT_EQ(res(), xtl::missing<double>());
+
+    TEST(xreducer_array_of_optional, sum_all)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SUM_ALL(feats.m_array_of_optional);
+    }
+
+    TEST(xreducer_array_optional, sum_all)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SUM_ALL(feats.m_array_optional);
+    }
+
+    TEST(xreducer_optional_assembly, sum_all)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_SUM_ALL(feats.m_optional_assembly);
+    }
+
+#undef TEST_OPT_SUM_ALL
+
     TEST(xreducer, prod)
     {
         // check that there is no overflow
         xarray<uint8_t> c = 2 * ones<uint8_t>({34});
-        EXPECT_EQ(1ULL << 34, prod(c)());
+        EXPECT_EQ(1ULL << 34, prod<long long>(c)());
     }
 
+#define TEST_OPT_PROD(INPUT)                   \
+    auto res1 = xt::prod(INPUT);               \
+    EXPECT_EQ(res1(), xtl::missing<double>()); \
+                                               \
+    auto res2 = xt::prod(INPUT, feats.m_axes); \
+    EXPECT_EQ(res2(), xtl::missing<double>()); \
+    EXPECT_EQ(res2(1, 1, 1), 4096.);
+
+    TEST(xreducer_array_of_optional, prod)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_PROD(feats.m_array_of_optional);
+    }
+
+    TEST(xreducer_array_optional, prod)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_PROD(feats.m_array_optional);
+    }
+
+    TEST(xreducer_optional_assembly, prod)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_PROD(feats.m_optional_assembly);
+    }
+
+#undef TEST_OPT_PROD
+
     TEST(xreducer, mean)
     {
-        xtensor<double, 2> input
-            {{-1.0, 0.0}, {1.0, 0.0}};
+        xtensor<double, 2> input{{-1.0, 0.0}, {1.0, 0.0}};
         auto mean_all = mean(input);
         auto mean0 = mean(input, {0});
         auto mean1 = mean(input, {1});
@@ -223,21 +554,59 @@ namespace xt
         EXPECT_TRUE(all(equal(mean0, expect0)));
         EXPECT_TRUE(all(equal(mean1, expect1)));
 
+#ifndef SKIP_ON_WERROR
+        // may loose precision because uint8_t is casted to long for intermediate
+        // computations and then divided by a double for mean
         xarray<uint8_t> c = {1, 2};
         EXPECT_EQ(mean(c)(), 1.5);
+#endif
+
+        const auto rvalue_xarray = []()
+        {
+            return xtensor<double, 1>({1, 2});
+        };
+        EXPECT_EQ(mean(rvalue_xarray(), {0})(), 1.5);
     }
 
+#define TEST_OPT_MEAN(INPUT)                   \
+    auto res1 = xt::mean(INPUT);               \
+    EXPECT_EQ(res1(), xtl::missing<double>()); \
+                                               \
+    auto res2 = xt::mean(INPUT, feats.m_axes); \
+    EXPECT_EQ(res2(), xtl::missing<double>()); \
+    EXPECT_EQ(res2(1, 1, 1), 2.);
+
+    TEST(xreducer_array_of_optional, mean)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_MEAN(feats.m_array_of_optional);
+    }
+
+    TEST(xreducer_array_optional, mean)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_MEAN(feats.m_array_optional);
+    }
+
+    TEST(xreducer_optional_assembly, mean)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_MEAN(feats.m_optional_assembly);
+    }
+
+#undef TEST_OPT_MEAN
+
     TEST(xreducer, average)
     {
-        xt::xtensor<float, 2> a = {{ 3, 4, 2, 1}, { 1, 1, 3, 2}};
-        xt::xarray<double> all_weights = {{1, 2, 3, 4}, { 5, 6, 7, 8}};
+        xt::xtensor<float, 2> a = {{3, 4, 2, 1}, {1, 1, 3, 2}};
+        xt::xarray<double> all_weights = {{1, 2, 3, 4}, {5, 6, 7, 8}};
         auto avg_all = xt::average(a, all_weights);
         auto avg_all_2 = xt::average(a, all_weights, {0ul, 1ul});
 
         auto avg0 = xt::average(a, xt::xarray<double>{3, 9}, {0});
-        auto avg1 = xt::average(a, xt::xarray<double>{1,2,3,4}, {1});
-        auto avg_m1 = xt::average(a, xt::xarray<double>{1,2,3,4}, {-1});
-        auto avg_d1 = xt::average(a, xt::xarray<double>{1,2,3,4}, {-1}, evaluation_strategy::immediate());
+        auto avg1 = xt::average(a, xt::xarray<double>{1, 2, 3, 4}, {1});
+        auto avg_m1 = xt::average(a, xt::xarray<double>{1, 2, 3, 4}, {-1});
+        auto avg_d1 = xt::average(a, xt::xarray<double>{1, 2, 3, 4}, {-1}, evaluation_strategy::immediate);
 
         xtensor<double, 0> expect_all = 1.9166666666666667;
         xtensor<double, 1> expect0 = {1.5, 1.75, 2.75, 1.75};
@@ -245,18 +614,90 @@ namespace xt
 
         EXPECT_TRUE(allclose(avg_all, expect_all));
         EXPECT_TRUE(allclose(avg_all_2, expect_all));
-        EXPECT_TRUE(all(equal(avg0, expect0)));
-        EXPECT_TRUE(all(equal(avg1, expect1)));
-        EXPECT_TRUE(all(equal(avg_m1, expect1)));
-        EXPECT_TRUE(all(equal(avg_d1, expect1)));
+        EXPECT_TRUE(allclose(avg0, expect0));
+        EXPECT_TRUE(allclose(avg1, expect1));
+        EXPECT_TRUE(allclose(avg_m1, expect1));
+        EXPECT_TRUE(allclose(avg_d1, expect1));
+    }
+
+#define TEST_OPT_AVERAGE(INPUT)                                            \
+    xt::xarray<double> all_weights = {{3, 3, 3}, {1, 1, 1}};               \
+    auto res1 = xt::average(INPUT, all_weights);                           \
+    EXPECT_EQ(res1(), xtl::missing<double>());                             \
+                                                                           \
+    xtensor_optional<double, 1> expect = {1., 2., xtl::missing<double>()}; \
+    xt::xarray<double> weights = {2, 0};                                   \
+    auto res2 = xt::average(INPUT, weights, {0});                          \
+    EXPECT_TRUE(all(equal(res2, expect)));
+
+    TEST(xreducer_array_of_optional, average)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_AVERAGE(feats.m_simple_array_of_optional);
+    }
+
+    TEST(xreducer_array_optional, average)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_AVERAGE(feats.m_simple_array_optional);
+    }
+
+    TEST(xreducer_optional_assembly, average)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_AVERAGE(feats.m_simple_optional_assembly);
+    }
+
+#undef TEST_OPT_AVERAGE
+
+    TEST(xreducer, count_nonzero)
+    {
+        xarray<double> m = {{1, 0}, {3, 4}};
+
+        xarray<std::size_t> res0 = xt::count_nonzero(m, {0});
+        xtensor<std::size_t, 1> expect0 = {2, 1};
+        EXPECT_TRUE(all(equal(res0, expect0)));
+
+        xarray<std::size_t> res1 = xt::count_nonzero(m, {1});
+        xtensor<std::size_t, 1> expect1 = {1, 2};
+        EXPECT_TRUE(all(equal(res1, expect1)));
+    }
+
+#define TEST_OPT_COUNT_NONZEROS(INPUT)                                              \
+    auto res0 = xt::count_nonzero(INPUT, {0});                                      \
+    xtensor_optional<std::size_t, 1> expect0 = {2, 2, xtl::missing<std::size_t>()}; \
+    EXPECT_TRUE(all(equal(res0, expect0)));                                         \
+                                                                                    \
+    auto res1 = xt::count_nonzero(INPUT, {1});                                      \
+    xtensor_optional<std::size_t, 1> expect1 = {2, xtl::missing<std::size_t>()};    \
+    EXPECT_TRUE(all(equal(res1, expect1)));
+
+/*  TODO: fix policy, missing values should lead to a missing value result
+    TEST(xreducer_array_of_optional, count_nonzero)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_COUNT_NONZEROS(feats.m_simple_array_of_optional);
+    }
+
+    TEST(xreducer_array_optional, count_nonzero)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_COUNT_NONZEROS(feats.m_simple_array_optional);
+    }
+
+    TEST(xreducer_optional_assembly, count_nonzero)
+    {
+        xreducer_opt_features feats;
+        TEST_OPT_COUNT_NONZEROS(feats.m_simple_optional_assembly);
     }
+*/
+#undef TEST_OPT_COUNT_NONZEROS
 
     TEST(xreducer, minmax)
     {
         using A = std::array<double, 2>;
 
-        xtensor<double, 2> input
-            {{-1.0, 0.0}, {1.0, 0.0}};
+        xtensor<double, 2> input{{-1.0, 0.0}, {1.0, 0.0}};
         EXPECT_EQ(minmax(input)(), (A{-1.0, 1.0}));
     }
 
@@ -266,76 +707,75 @@ namespace xt
         a.resize({3, 3, 3});
 
         xarray<double> a_lz = sum(a);
-        auto a_gd = sum(a, evaluation_strategy::immediate());
+        auto a_gd = sum(a, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {1});
-        a_gd = sum(a, {1}, evaluation_strategy::immediate());
+        a_gd = sum(a, {1}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {0, 2});
-        a_gd = sum(a, {0, 2}, evaluation_strategy::immediate());
+        a_gd = sum(a, {0, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {1, 2});
-        a_gd = sum(a, {1, 2}, evaluation_strategy::immediate());
+        a_gd = sum(a, {1, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a = xt::arange(4 * 3 * 6 * 2 * 7);
         a.resize({4, 3, 6, 2, 7});
 
         a_lz = sum(a);
-        a_gd = sum(a, evaluation_strategy::immediate());
+        a_gd = sum(a, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {1});
-        a_gd = sum(a, {1}, evaluation_strategy::immediate());
+        a_gd = sum(a, {1}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {0, 2});
-        a_gd = sum(a, {0, 2}, evaluation_strategy::immediate());
+        a_gd = sum(a, {0, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {1, 2});
-        a_gd = sum(a, {1, 2}, evaluation_strategy::immediate());
+        a_gd = sum(a, {1, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {1, 3, 4});
-        a_gd = sum(a, {1, 3, 4}, evaluation_strategy::immediate());
+        a_gd = sum(a, {1, 3, 4}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {0, 1, 4});
-        a_gd = sum(a, {0, 1, 4}, evaluation_strategy::immediate());
+        a_gd = sum(a, {0, 1, 4}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {0, 1, 3});
-        a_gd = sum(a, {0, 1, 3}, evaluation_strategy::immediate());
+        a_gd = sum(a, {0, 1, 3}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {0, 2, 3});
-        a_gd = sum(a, {0, 2, 3}, evaluation_strategy::immediate());
+        a_gd = sum(a, {0, 2, 3}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         a_lz = sum(a, {1, 2, 3});
-        a_gd = sum(a, {1, 2, 3}, evaluation_strategy::immediate());
+        a_gd = sum(a, {1, 2, 3}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
 
         xtensor<short, 3, layout_type::column_major> ct = xt::random::randint<short>({1, 5, 3});
-        EXPECT_EQ(sum(ct, {0, 2}), sum(ct, {0, 2}, evaluation_strategy::immediate()));
+        EXPECT_EQ(sum(ct, {0, 2}), sum(ct, {0, 2}, evaluation_strategy::immediate));
 
         xtensor<short, 5, layout_type::column_major> ct2 = xt::random::randint<short>({1, 5, 1, 2, 3});
-        EXPECT_EQ(sum(ct2, {0, 1, 2}), sum(ct2, {0, 1, 2}, evaluation_strategy::immediate()));
-        EXPECT_EQ(sum(ct2, {2, 3}), sum(ct2, {2, 3}, evaluation_strategy::immediate()));
-        EXPECT_EQ(sum(ct2, {1, 3}), sum(ct2, {1, 3}, evaluation_strategy::immediate()));
+        EXPECT_EQ(sum(ct2, {0, 1, 2}), sum(ct2, {0, 1, 2}, evaluation_strategy::immediate));
+        EXPECT_EQ(sum(ct2, {2, 3}), sum(ct2, {2, 3}, evaluation_strategy::immediate));
+        EXPECT_EQ(sum(ct2, {1, 3}), sum(ct2, {1, 3}, evaluation_strategy::immediate));
     }
 
     TEST(xreducer, chaining_reducers)
     {
-        xt::xarray<double> a = {{ 1., 2. },
-                                { 3., 4. }};
+        xt::xarray<double> a = {{1., 2.}, {3., 4.}};
 
-        auto b = a - xt::sum(a, { 0 });
-        auto c = xt::sum(b, { 0 });
+        auto b = a - xt::sum(a, {0});
+        auto c = xt::sum(b, {0});
         EXPECT_EQ(c(0), -4.);
         EXPECT_EQ(c(1), -6.);
     }
@@ -343,41 +783,37 @@ namespace xt
     TEST(xreducer, immediate_shape)
     {
         xtensor<double, 2> c = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
-        auto xa = xt::sum(c, {0}, evaluation_strategy::immediate());
+        auto xa = xt::sum(c, {0}, evaluation_strategy::immediate);
         auto is_arr = [](const auto& c)
         {
             bool istrue = detail::is_array<std::decay_t<decltype(c)>>::value;
             return istrue;
         };
 
-    #ifndef X_OLD_CLANG
         EXPECT_TRUE(is_arr(xa.shape()));
-    #endif
 
         xtensor<double, 3> a;
         a.resize({3, 3, 3});
         std::iota(a.storage().begin(), a.storage().end(), 0);
 
         xarray<double> a_lz = sum(a);
-        auto a_gd = sum(a, evaluation_strategy::immediate());
+        auto a_gd = sum(a, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
         EXPECT_TRUE(is_arr(a_gd.shape()));
 
         a_lz = sum(a, {1});
-        auto a_gd_1 = sum(a, {1}, evaluation_strategy::immediate());
+        auto a_gd_1 = sum(a, {1}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd_1);
 
         a_lz = sum(a, {0, 2});
-        auto a_gd_2 = sum(a, {0, 2}, evaluation_strategy::immediate());
+        auto a_gd_2 = sum(a, {0, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd_2);
 
-    #ifndef X_OLD_CLANG
         EXPECT_TRUE(is_arr(a_gd_1.shape()));
         EXPECT_TRUE(is_arr(a_gd_2.shape()));
-    #endif
 
         a_lz = sum(a, {1, 2});
-        a_gd_2 = sum(a, {1, 2}, evaluation_strategy::immediate());
+        a_gd_2 = sum(a, {1, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd_2);
     }
 
@@ -397,34 +833,35 @@ namespace xt
         };
 
         xarray<double> a_lz = sum(a);
-        auto a_gd = sum(a, evaluation_strategy::immediate());
+        auto a_gd = sum(a, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd);
-        EXPECT_TRUE(is_arr(a_gd.shape()));
+
+        // EXPECT_TRUE(is_fixed(a_gd.shape())); // this actually evaluates to const_array
 
         a_lz = sum(a, xt::dynamic_shape<std::size_t>{1});
-        auto a_gd_1 = sum(a, xt::dynamic_shape<std::size_t>{1}, evaluation_strategy::immediate());
-        auto b_gd_1 = sum(b, {1}, evaluation_strategy::immediate());
+        auto a_gd_1 = sum(a, xt::dynamic_shape<std::size_t>{1}, evaluation_strategy::immediate);
+        auto b_gd_1 = sum(b, {1}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd_1);
         EXPECT_EQ(a_lz, b_gd_1);
 
         a_lz = sum(a, {0, 2});
-        auto a_gd_2 = sum(a, {0, 2}, evaluation_strategy::immediate());
-        auto b_gd_2 = sum(b, {0, 2}, evaluation_strategy::immediate());
+        auto a_gd_2 = sum(a, {0, 2}, evaluation_strategy::immediate);
+        auto b_gd_2 = sum(b, {0, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd_2);
         EXPECT_EQ(b_gd_2, a_gd_2);
         EXPECT_EQ(a_gd_2.dimension(), std::size_t(1));
 
-    #ifndef X_OLD_CLANG
         // EXPECT_TRUE(is_arr(a_gd_1.shape()));
         EXPECT_TRUE(is_arr(a_gd_2.shape()));
-    #endif
 
         a_lz = sum(a, {1, 2});
-        a_gd_2 = sum(a, {1, 2}, evaluation_strategy::immediate());
+        a_gd_2 = sum(a, {1, 2}, evaluation_strategy::immediate);
         EXPECT_EQ(a_lz, a_gd_2);
 
+        auto a_lx_3 = sum(a, {1, 2});
         auto a_lz_3 = sum(a, xshape<1, 2>());
-        auto a_gd_3 = sum(a, xshape<1, 2>(), evaluation_strategy::immediate());
+        auto a_gd_3 = sum(a, xshape<1, 2>(), evaluation_strategy::immediate);
+        xarray<double> xevd = a_lz_3;
         EXPECT_EQ(a_lz_3, a_gd_2);
         EXPECT_TRUE(a_gd_3 == a_gd_2);
         bool truth = std::is_same<decltype(a_gd_3), xtensor_fixed<double, xshape<3>>>::value;
@@ -432,25 +869,28 @@ namespace xt
 
         xtensor<short, 3> ct = xt::random::randint<short>({1, 5, 3});
         xtensor_fixed<short, xshape<1, 5, 3>> c = ct;
-        auto b_fx_1 = sum(c, xshape<0, 2>(), evaluation_strategy::immediate());
-        auto b_fx_2 = sum(c, xshape<0, 1>(), evaluation_strategy::immediate());
-        auto b_fx_3 = sum(c, xshape<0, 1, 2>(), evaluation_strategy::immediate());
+        auto b_fx_1 = sum(c, xshape<0, 2>(), evaluation_strategy::immediate);
+        auto b_fx_2 = sum(c, xshape<0, 1>(), evaluation_strategy::immediate);
+        auto b_fx_3 = sum(c, xshape<0, 1, 2>(), evaluation_strategy::immediate);
 
-        EXPECT_EQ(sum(ct, {0, 2}, evaluation_strategy::immediate()), sum(c, {0, 2}));
+        EXPECT_EQ(sum(ct, {0, 2}, evaluation_strategy::immediate), sum(c, {0, 2}));
         EXPECT_TRUE(b_fx_1 == sum(c, {0, 2}));
         EXPECT_TRUE(b_fx_2 == sum(c, {0, 1}));
         EXPECT_EQ(b_fx_3, sum(c, {0, 1, 2}));
 
-        truth = std::is_same<std::decay_t<decltype(b_fx_1)>, xtensor_fixed<long long, xshape<5>>>::value;
+        truth = std::is_same<std::decay_t<decltype(b_fx_1)>, xtensor_fixed<int, xshape<5>>>::value;
         EXPECT_TRUE(truth);
-        truth = std::is_same<std::decay_t<decltype(b_fx_3)>, xtensor_fixed<long long, xshape<>>>::value;
+        truth = std::is_same<std::decay_t<decltype(b_fx_3)>, xtensor_fixed<int, xshape<>>>::value;
         EXPECT_TRUE(truth);
 
-        truth = std::is_same<xshape<1, 3>, typename fixed_xreducer_shape_type<xshape<1, 5, 3>, xshape<1>>::type>();
+        truth = std::is_same<xshape<1, 3>, typename fixed_xreducer_shape_type<xshape<1, 5, 3>, xshape<1>>::type>(
+        );
         EXPECT_TRUE(truth);
-        truth = std::is_same<xshape<5>, typename fixed_xreducer_shape_type<xshape<1, 5, 3>, xshape<0, 2>>::type>();
+        truth = std::is_same<xshape<5>, typename fixed_xreducer_shape_type<xshape<1, 5, 3>, xshape<0, 2>>::type>(
+        );
         EXPECT_TRUE(truth);
-        truth = std::is_same<xshape<>, typename fixed_xreducer_shape_type<xshape<1, 5, 3>, xshape<0, 1, 2>>::type>();
+        truth = std::is_same<xshape<>, typename fixed_xreducer_shape_type<xshape<1, 5, 3>, xshape<0, 1, 2>>::type>(
+        );
         EXPECT_TRUE(truth);
         truth = std::is_same<xshape<1, 5>, typename fixed_xreducer_shape_type<xshape<1, 5>, xshape<2>>::type>();
         EXPECT_TRUE(truth);
@@ -475,7 +915,7 @@ namespace xt
         double e = xt::sum(a)();
         double s1 = xt::sum(a)(0);
         EXPECT_EQ(s1, e);
-        double s2 = xt::sum(a)(0, 1, 2, 3, 4, 5);
+        double s2 = xt::sum(a)(0, 1, 2, 3, 4, 5, 0);
         EXPECT_EQ(s2, e);
 
         auto red = xt::sum(a, {0});
@@ -487,7 +927,7 @@ namespace xt
     TEST(xreducer, normalize_axes)
     {
         xt::xtensor<double, 4> x{};
-        std::vector<std::size_t> sva {0, 1, 2, 3};
+        std::vector<std::size_t> sva{0, 1, 2, 3};
         std::vector<std::ptrdiff_t> svb = {-4, 1, -2, -1};
         std::initializer_list<std::ptrdiff_t> initlist = {-4, 1, -2, -1};
         std::array<std::size_t, 4> saa = {0, 1, 2, 3};
@@ -501,4 +941,185 @@ namespace xt
         auto resab = forward_normalize<std::array<std::size_t, 4>>(x, sab);
         EXPECT_EQ(resab, saa);
     }
+
+    TEST(xreducer, input_0d)
+    {
+        xt::xarray<double> a;
+        EXPECT_EQ(0., xt::amin(a)[0]);
+
+        using A = std::array<double, 2>;
+        xt::xarray<double> b(1.2);
+        EXPECT_EQ(b.dimension(), 0u);
+        EXPECT_EQ(minmax(b)(), (A{1.2, 1.2}));
+    }
+
+    template <std::size_t... I, std::size_t... J>
+    bool operator==(fixed_shape<I...>, fixed_shape<J...>)
+    {
+        std::array<std::size_t, sizeof...(I)> ix = {I...};
+        std::array<std::size_t, sizeof...(J)> jx = {J...};
+        return sizeof...(J) == sizeof...(I) && std::equal(ix.begin(), ix.end(), jx.begin());
+    }
+
+    TEST(xreducer, keep_dims)
+    {
+        xt::xtensor<double, 4> a = xt::reshape_view(xt::arange<double>(5 * 5 * 5 * 5), {5, 5, 5, 5});
+
+        auto res = xt::sum(a, {0, 1}, xt::keep_dims | xt::evaluation_strategy::immediate);
+        EXPECT_EQ(res.shape(), (std::array<std::size_t, 4>{1, 1, 5, 5}));
+        auto res2 = xt::sum(a, {0, 1}, xt::keep_dims);
+        EXPECT_EQ(res2.shape(), (std::array<std::size_t, 4>{1, 1, 5, 5}));
+
+        xt::xarray<double> b = a;
+        auto res3 = xt::sum(b, {0, 1}, xt::keep_dims | xt::evaluation_strategy::immediate);
+        EXPECT_EQ(res3.shape(), (xt::dynamic_shape<std::size_t>{1, 1, 5, 5}));
+        auto res4 = xt::sum(b, {0, 1}, xt::keep_dims | xt::evaluation_strategy::lazy);
+        EXPECT_EQ(res4.shape(), (xt::dynamic_shape<std::size_t>{1, 1, 5, 5}));
+
+        xt::xarray<double> resx3 = xt::sum(a, {0, 1});
+        auto exp1 = xt::sum(a, {0, 1});
+
+        EXPECT_EQ(res, res2);
+        EXPECT_EQ(res, res3);
+        EXPECT_EQ(res, res4);
+
+        EXPECT_TRUE(xt::allclose(res, res2));
+        EXPECT_TRUE(xt::allclose(res, res3));
+        EXPECT_TRUE(xt::allclose(res, res4));
+
+        auto res5 = xt::sum(a, xt::keep_dims);
+        EXPECT_EQ(res5.shape(), (xt::static_shape<size_t, 4>{1, 1, 1, 1}));
+        auto res6 = xt::sum(a);
+        EXPECT_EQ(res6.shape(), (xt::static_shape<size_t, 0>{}));
+        xt::xtensor_fixed<double, xshape<5, 5, 5, 5>> c = a;
+        auto res7 = xt::sum(c);
+        EXPECT_EQ(res7.shape(), (xt::xshape<>{}));
+        auto res8 = xt::sum(c, xt::keep_dims);
+        EXPECT_EQ(res8.shape(), (xt::xshape<1, 1, 1, 1>{}));
+    }
+
+    TEST(xreducer, initial_value)
+    {
+        xt::xtensor<double, 4> a = xt::reshape_view(xt::arange<double>(5 * 5 * 5 * 5), {5, 5, 5, 5});
+
+        auto res = xt::sum(a, {0, 2}, xt::keep_dims | xt::evaluation_strategy::immediate | initial(5));
+        auto reso = xt::sum(a, {0, 2}, xt::keep_dims | xt::evaluation_strategy::immediate);
+        EXPECT_EQ(res, reso + 5);
+
+        xt::xarray<double> res2 = xt::sum(a, {0, 2}, xt::keep_dims | initial(5));
+        auto reso2 = xt::sum(a, {0, 2}, xt::keep_dims);
+        EXPECT_EQ(res2, reso2 + 5);
+
+        auto re0 = xt::prod(a, {1, 2}, xt::keep_dims | xt::evaluation_strategy::immediate | initial(0));
+        EXPECT_TRUE(xt::all(equal(re0, 0.)));
+
+        auto rex0 = xt::prod(a, {1, 2}, initial(0));
+        EXPECT_TRUE(xt::all(equal(rex0, 0.)));
+    }
+
+    TEST(xreducer, ones_first)
+    {
+        auto a = xt::ones<int>(std::vector<int>({1, 1, 2, 4}));
+        std::vector<int> arraxis = {1};
+        auto result = xt::sum(a, arraxis, xt::keep_dims | xt::evaluation_strategy::immediate);
+        EXPECT_EQ(a, result);
+
+        std::vector<int> arraxis2 = {1, 2};
+        auto res2 = xt::sum(a, arraxis2, xt::keep_dims | xt::evaluation_strategy::immediate);
+        xt::xarray<int> expected = {{{{2, 2, 2, 2}}}};
+        EXPECT_EQ(expected, res2);
+    }
+
+    TEST(xreducer, empty_axes)
+    {
+        xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+        std::vector<std::size_t> axes = {};
+        auto res0 = xt::sum(a, axes);
+        auto res1 = xt::sum(a, axes, xt::keep_dims | xt::evaluation_strategy::immediate);
+
+        EXPECT_EQ(res0, a);
+        EXPECT_EQ(res1, a);
+    }
+
+    TEST(xreducer, zero_shape)
+    {
+        xt::xarray<int> x = xt::zeros<int>({0, 1});
+
+        auto res0 = xt::sum(x, {0}, xt::keep_dims);
+        EXPECT_EQ(res0.shape()[0], size_t(1));
+        EXPECT_EQ(res0.shape()[1], size_t(1));
+        EXPECT_EQ(res0(0, 0), 0);
+
+        auto res1 = xt::sum(x, {1}, xt::keep_dims);
+        EXPECT_EQ(res1.shape()[0], size_t(0));
+        EXPECT_EQ(res1.shape()[1], size_t(1));
+        EXPECT_EQ(res1.size(), size_t(0));
+
+        auto res2 = xt::sum(x, xt::keep_dims);
+        EXPECT_EQ(res2.shape()[0], size_t(1));
+        EXPECT_EQ(res2.shape()[1], size_t(1));
+        EXPECT_EQ(res2(0, 0), 0);
+    }
+
+    TEST(xreducer, empty_array)
+    {
+        xt::xarray<double> a = xt::ones<double>({1, 2, 0, 1});
+        double result0 = xt::mean(a)();
+        EXPECT_TRUE(std::isnan(result0));
+
+        auto result1 = xt::mean(a, {1});
+        auto expected1 = xt::xarray<double>::from_shape({1, 0, 1});
+        EXPECT_EQ(result1, expected1);
+
+        auto result2 = xt::mean(a, {2});
+        auto expected2 = xt::xarray<double>::from_shape({1, 2, 1});
+        EXPECT_EQ(result2.shape(), expected2.shape());
+        EXPECT_TRUE(std::isnan(result2(0, 0, 0)));
+        EXPECT_TRUE(std::isnan(result2(0, 1, 0)));
+    }
+
+    TEST(xreducer, double_axis)
+    {
+        xt::xarray<int> a = xt::ones<int>({3, 2});
+        XT_EXPECT_NO_THROW(xt::sum(a, {0, 1}));   // correct
+        XT_EXPECT_ANY_THROW(xt::sum(a, {0, 0}));  // duplicate indices
+        XT_EXPECT_ANY_THROW(xt::sum(a, {1, 0}));  // unordered indices
+        XT_EXPECT_ANY_THROW(xt::sum(a, {1, 1}));  // duplicate indices
+    }
+
+    TEST(xreducer, sum_xtensor_of_fixed)
+    {
+        xt::xtensor_fixed<float, xt::xshape<3>> a = {1, 2, 3}, b = {1, 2, 3};
+        xt::xtensor<xt::xtensor_fixed<float, xt::xshape<3>>, 1> c = {a, b};
+
+        auto res = xt::sum(c)();
+        EXPECT_EQ(res, a * 2.);
+
+        xt::xtensor_fixed<float, xt::xshape<3>> res1 = res;
+        EXPECT_EQ(res1, a * 2.);
+    }
+
+    TEST(xreducer, sum_reshape_view_xfunction)
+    {
+        xt::xtensor<double, 1> a = {0, 1, 2, 3, 4, 5, 6, 7};
+        xt::xtensor<double, 1> b = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5};
+        xt::svector<double> sh = {2, 4};
+
+        auto res = xt::sum(xt::reshape_view(a * b, sh), 0);
+
+        xt::xtensor<double, 2> ra = reshape_view(a, sh);
+        xt::xtensor<double, 2> rb = reshape_view(b, sh);
+
+        auto exp = xt::sum(ra * rb, 0);
+
+        auto itres = res.cbegin();
+        auto itexp = exp.cbegin();
+        auto itexp_end = exp.cend();
+        while (itexp != itexp_end)
+        {
+            EXPECT_EQ(*itres, *itexp);
+            ++itres;
+            ++itexp;
+        }
+    }
 }
diff --git a/test/test_xrepeat.cpp b/test/test_xrepeat.cpp
new file mode 100644
index 000000000..89546ff81
--- /dev/null
+++ b/test/test_xrepeat.cpp
@@ -0,0 +1,394 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/views/xrepeat.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+
+    TEST(xrepeat, const_array)
+    {
+        const xarray<size_t> array = {1, 2, 3};
+
+        const auto repeated_array = xt::repeat(array, 1, 0);
+
+        ASSERT_EQ(1, repeated_array(0));
+        ASSERT_EQ(2, repeated_array(1));
+        ASSERT_EQ(3, repeated_array(2));
+    }
+
+    TEST(xrepeat, stepper_begin)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        const auto stepper = repeated_array.stepper_begin();
+
+        ASSERT_EQ(1, *stepper);
+    }
+
+    TEST(xrepeat, stepper_end_row_major_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_end(xt::layout_type::row_major);
+
+        stepper.step_back(1, 1);
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat, stepper_end_row_major_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_end(layout_type::row_major);
+
+        stepper.step_back(1, 1);
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat, stepper_end_column_major_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_end(layout_type::column_major);
+
+        stepper.step_back(0, 1);
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat, stepper_end_column_major_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_end(layout_type::column_major);
+
+        stepper.step_back(0, 1);
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat, assign)
+    {
+        xt::xarray<int> a = {{1, 2}, {3, 4}};
+        xt::xarray<int> b = xt::repeat(a, 3, 1);
+        xt::xarray<int> res = {{1, 1, 1, 2, 2, 2}, {3, 3, 3, 4, 4, 4}};
+        EXPECT_EQ(b, res);
+    }
+
+    TEST(xrepeat_stepper, step_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step(0, 2);
+        stepper.step(1, 2);
+
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat_stepper, step_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step(0, 2);
+        stepper.step(1, 2);
+
+        ASSERT_EQ(6, *stepper);
+    }
+
+    TEST(xrepeat_stepper, step_back_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_begin();
+        stepper.step(0, 2);
+        stepper.step(1, 2);
+
+        stepper.step_back(0, 1);
+        stepper.step_back(1, 1);
+
+        ASSERT_EQ(5, *stepper);
+    }
+
+    TEST(xrepeat_stepper, step_back_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+        stepper.step(0, 2);
+        stepper.step(1, 2);
+
+        stepper.step_back(0, 1);
+        stepper.step_back(1, 1);
+
+        ASSERT_EQ(2, *stepper);
+    }
+
+    TEST(xrepeat_stepper, step_and_reset_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step(0, 2);
+        stepper.step(1, 2);
+        stepper.reset(0);
+        stepper.reset(1);
+
+        ASSERT_EQ(1, *stepper);
+    }
+
+    TEST(xrepeat_stepper, step_and_reset_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step(0, 5);
+        stepper.step(1, 2);
+        stepper.reset(0);
+        stepper.reset(1);
+
+        ASSERT_EQ(1, *stepper);
+    }
+
+    TEST(xrepeat_stepper, reset_back_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.reset_back(0);
+        stepper.reset_back(1);
+
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat_stepper, reset_back_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper0 = repeated_array.stepper_begin();
+        auto stepper1 = repeated_array.stepper_begin();
+
+        stepper0.reset_back(0);
+        stepper1.reset_back(1);
+
+        ASSERT_EQ(7, *stepper0);
+        ASSERT_EQ(3, *stepper1);
+    }
+
+    TEST(xrepeat_stepper, reset_back_and_step_back_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.reset_back(0);
+        stepper.reset_back(1);
+        stepper.step_back(0, 1);
+        stepper.step_back(1, 1);
+
+        ASSERT_EQ(8, *stepper);
+    }
+
+    TEST(xrepeat_stepper, to_begin_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_end(layout_type::row_major);
+
+        stepper.to_begin();
+
+        ASSERT_EQ(1, *stepper);
+    }
+
+    TEST(xrepeat_stepper, to_begin_and_step_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_end(layout_type::row_major);
+
+        stepper.to_begin();
+        stepper.step(0, 1);
+        stepper.step(1, 1);
+
+        ASSERT_EQ(2, *stepper);
+    }
+
+    TEST(xrepeat_stepper, to_end_row_major_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.to_end(layout_type::row_major);
+        stepper.step_back(1, 2);
+
+        ASSERT_EQ(8, *stepper);
+    }
+
+    TEST(xrepeat_stepper, to_end_column_major_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.to_end(layout_type::column_major);
+        stepper.step_back(0, 2);
+
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat_stepper, step_leading_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step_leading();
+        stepper.step_leading();
+        stepper.step_leading();
+
+        ASSERT_EQ(4, *stepper);
+    }
+
+    TEST(xrepeat_stepper, step_leading_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step_leading();
+        stepper.step_leading();
+        stepper.step_leading();
+
+        ASSERT_EQ(1, *stepper);
+    }
+
+    TEST(xrepeat_stepper, huge_step_with_repeat_1)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 1, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step(1, 8);
+
+        ASSERT_EQ(9, *stepper);
+    }
+
+    TEST(xrepeat_stepper, huge_step_with_repeat_2)
+    {
+        xarray<size_t> array = {
+            {1, 2, 3},
+            {4, 5, 6},
+            {7, 8, 9},
+        };
+        const auto repeated_array = xt::repeat(array, 2, 0);
+        auto stepper = repeated_array.stepper_begin();
+
+        stepper.step(1, 17);
+
+        ASSERT_EQ(9, *stepper);
+    }
+}
diff --git a/test/test_xscalar.cpp b/test/test_xscalar.cpp
index 0df173961..ba994ed12 100644
--- a/test/test_xscalar.cpp
+++ b/test/test_xscalar.cpp
@@ -1,14 +1,16 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
-#include "xtensor/xscalar.hpp"
-#include "xtensor/xarray.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xscalar.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -57,7 +59,7 @@ namespace xt
     TEST(xscalar, at)
     {
         xscalar<int> x(2);
-        EXPECT_ANY_THROW(x.at(0));
+        XT_EXPECT_ANY_THROW(x.at(0));
     }
 
     TEST(xscalar, dimension)
@@ -85,7 +87,6 @@ namespace xt
         EXPECT_EQ(iter, iter_end);
     }
 
-
     TEST(xscalar, stepper)
     {
         xarray<double> ref = zeros<double>({4, 6});
diff --git a/test/test_xscalar_semantic.cpp b/test/test_xscalar_semantic.cpp
index 8e30c6646..9b7223b70 100644
--- a/test/test_xscalar_semantic.cpp
+++ b/test/test_xscalar_semantic.cpp
@@ -1,13 +1,15 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xnoalias.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/core/xnoalias.hpp"
+
+#include "test_common_macros.hpp"
 #include "test_xsemantic.hpp"
 
 namespace xt
@@ -27,270 +29,274 @@ namespace xt
         using storage_type = C;
     };
 
-    using testing_types = ::testing::Types<xarray_dynamic, xtensor_dynamic>;
-    TYPED_TEST_CASE(scalar_semantic, testing_types);
-
-    TYPED_TEST(scalar_semantic, a_plus_equal_b)
-    {
-        scalar_operation_tester<std::plus<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major += scalar");
-            TypeParam a = tester.ra;
-            a += tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major += scalar");
-            TypeParam a = tester.ca;
-            a += tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major += scalar");
-            TypeParam a = tester.cta;
-            a += tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major += scalar");
-            TypeParam a = tester.ua;
-            a += tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
-        }
-    }
+#define SCALAR_SEMANTIC_TEST_TYPES xarray_dynamic, xtensor_dynamic
 
-    TYPED_TEST(scalar_semantic, a_minus_equal_b)
+    TEST_SUITE("scalar_semantic")
     {
-        scalar_operation_tester<std::minus<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major -= scalar");
-            TypeParam a = tester.ra;
-            a -= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major -= scalar");
-            TypeParam a = tester.ca;
-            a -= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major -= scalar");
-            TypeParam a = tester.cta;
-            a -= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major -= scalar");
-            TypeParam a = tester.ua;
-            a -= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
+        TEST_CASE_TEMPLATE("a_plus_equal_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::plus<>, TypeParam> tester;
+
+            SUBCASE("row_major += scalar")
+            {
+                TypeParam a = tester.ra;
+                a += tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major += scalar")
+            {
+                TypeParam a = tester.ca;
+                a += tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major += scalar")
+            {
+                TypeParam a = tester.cta;
+                a += tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major += scalar")
+            {
+                TypeParam a = tester.ua;
+                a += tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_minus_equal_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::minus<>, TypeParam> tester;
+
+            SUBCASE("row_major -= scalar")
+            {
+                TypeParam a = tester.ra;
+                a -= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major -= scalar")
+            {
+                TypeParam a = tester.ca;
+                a -= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major -= scalar")
+            {
+                TypeParam a = tester.cta;
+                a -= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major -= scalar")
+            {
+                TypeParam a = tester.ua;
+                a -= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_times_equal_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::multiplies<>, TypeParam> tester;
+
+            SUBCASE("row_major *= scalar")
+            {
+                TypeParam a = tester.ra;
+                a *= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major *= scalar")
+            {
+                TypeParam a = tester.ca;
+                a *= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major *= scalar")
+            {
+                TypeParam a = tester.cta;
+                a *= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major *= scalar")
+            {
+                TypeParam a = tester.ua;
+                a *= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
+        }
+
+        TEST_CASE_TEMPLATE("a_divide_by_equal_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::divides<>, TypeParam> tester;
+
+            SUBCASE("row_major /= scalar")
+            {
+                TypeParam a = tester.ra;
+                a /= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major /= scalar")
+            {
+                TypeParam a = tester.ca;
+                a /= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major /= scalar")
+            {
+                TypeParam a = tester.cta;
+                a /= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major /= scalar")
+            {
+                TypeParam a = tester.ua;
+                a /= tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
+        }
+
+        TEST_CASE_TEMPLATE("assign_a_plus_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::plus<>, TypeParam> tester;
+
+            SUBCASE("row_major + scalar")
+            {
+                TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
+                noalias(a) = tester.ra + tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major + scalar")
+            {
+                TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
+                noalias(a) = tester.ca + tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major + scalar")
+            {
+                TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
+                noalias(a) = tester.cta + tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major + scalar")
+            {
+                TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
+                noalias(a) = tester.ua + tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
+        }
+
+        TEST_CASE_TEMPLATE("assign_a_minus_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::minus<>, TypeParam> tester;
+
+            SUBCASE("row_major - scalar")
+            {
+                TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
+                noalias(a) = tester.ra - tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major - scalar")
+            {
+                TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
+                noalias(a) = tester.ca - tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major - scalar")
+            {
+                TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
+                noalias(a) = tester.cta - tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major - scalar")
+            {
+                TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
+                noalias(a) = tester.ua - tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
+        }
+
+        TEST_CASE_TEMPLATE("assign_a_times_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::multiplies<>, TypeParam> tester;
+
+            SUBCASE("row_major * scalar")
+            {
+                TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
+                noalias(a) = tester.ra * tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major * scalar")
+            {
+                TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
+                noalias(a) = tester.ca * tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major * scalar")
+            {
+                TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
+                noalias(a) = tester.cta * tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major * scalar")
+            {
+                TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
+                noalias(a) = tester.ua * tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
+        }
+
+        TEST_CASE_TEMPLATE("assign_a_divide_by_b", TypeParam, SCALAR_SEMANTIC_TEST_TYPES)
+        {
+            scalar_operation_tester<std::divides<>, TypeParam> tester;
+
+            SUBCASE("row_major / scalar")
+            {
+                TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
+                noalias(a) = tester.ra / tester.b;
+                EXPECT_TRUE(full_equal(tester.res_r, a));
+            }
+
+            SUBCASE("column_major / scalar")
+            {
+                TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
+                noalias(a) = tester.ca / tester.b;
+                EXPECT_TRUE(full_equal(tester.res_c, a));
+            }
+
+            SUBCASE("central_major / scalar")
+            {
+                TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
+                noalias(a) = tester.cta / tester.b;
+                EXPECT_TRUE(full_equal(tester.res_ct, a));
+            }
+
+            SUBCASE("unit_major / scalar")
+            {
+                TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
+                noalias(a) = tester.ua / tester.b;
+                EXPECT_TRUE(full_equal(tester.res_u, a));
+            }
         }
     }
 
-    TYPED_TEST(scalar_semantic, a_times_equal_b)
-    {
-        scalar_operation_tester<std::multiplies<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major *= scalar");
-            TypeParam a = tester.ra;
-            a *= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major *= scalar");
-            TypeParam a = tester.ca;
-            a *= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major *= scalar");
-            TypeParam a = tester.cta;
-            a *= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major *= scalar");
-            TypeParam a = tester.ua;
-            a *= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
-        }
-    }
-
-    TYPED_TEST(scalar_semantic, a_divide_by_equal_b)
-    {
-        scalar_operation_tester<std::divides<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major /= scalar");
-            TypeParam a = tester.ra;
-            a /= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major /= scalar");
-            TypeParam a = tester.ca;
-            a /= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major /= scalar");
-            TypeParam a = tester.cta;
-            a /= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major /= scalar");
-            TypeParam a = tester.ua;
-            a /= tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
-        }
-    }
-
-    TYPED_TEST(scalar_semantic, assign_a_plus_b)
-    {
-        scalar_operation_tester<std::plus<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major + scalar");
-            TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
-            noalias(a) = tester.ra + tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major + scalar");
-            TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
-            noalias(a) = tester.ca + tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major + scalar");
-            TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
-            noalias(a) = tester.cta + tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major + scalar");
-            TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
-            noalias(a) = tester.ua + tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
-        }
-    }
-
-    TYPED_TEST(scalar_semantic, assign_a_minus_b)
-    {
-        scalar_operation_tester<std::minus<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major - scalar");
-            TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
-            noalias(a) = tester.ra - tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major - scalar");
-            TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
-            noalias(a) = tester.ca - tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major - scalar");
-            TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
-            noalias(a) = tester.cta - tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major - scalar");
-            TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
-            noalias(a) = tester.ua - tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
-        }
-    }
-
-    TYPED_TEST(scalar_semantic, assign_a_times_b)
-    {
-        scalar_operation_tester<std::multiplies<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major * scalar");
-            TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
-            noalias(a) = tester.ra * tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major * scalar");
-            TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
-            noalias(a) = tester.ca * tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major * scalar");
-            TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
-            noalias(a) = tester.cta * tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major * scalar");
-            TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
-            noalias(a) = tester.ua * tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
-        }
-    }
-
-    TYPED_TEST(scalar_semantic, assign_a_divide_by_b)
-    {
-        scalar_operation_tester<std::divides<>, TypeParam> tester;
-
-        {
-            SCOPED_TRACE("row_major / scalar");
-            TypeParam a(tester.ra.shape(), tester.ra.strides(), 0);
-            noalias(a) = tester.ra / tester.b;
-            EXPECT_TRUE(full_equal(tester.res_r, a));
-        }
-
-        {
-            SCOPED_TRACE("column_major / scalar");
-            TypeParam a(tester.ca.shape(), tester.ca.strides(), 0);
-            noalias(a) = tester.ca / tester.b;
-            EXPECT_TRUE(full_equal(tester.res_c, a));
-        }
-
-        {
-            SCOPED_TRACE("central_major / scalar");
-            TypeParam a(tester.cta.shape(), tester.cta.strides(), 0);
-            noalias(a) = tester.cta / tester.b;
-            EXPECT_TRUE(full_equal(tester.res_ct, a));
-        }
-
-        {
-            SCOPED_TRACE("unit_major / scalar");
-            TypeParam a(tester.ua.shape(), tester.ua.strides(), 0);
-            noalias(a) = tester.ua / tester.b;
-            EXPECT_TRUE(full_equal(tester.res_u, a));
-        }
-    }
+#undef SCALAR_SEMANTIC_TEST_TYPES
 }
diff --git a/test/test_xsemantic.hpp b/test/test_xsemantic.hpp
index e595e34f9..0897ad0f6 100644
--- a/test/test_xsemantic.hpp
+++ b/test/test_xsemantic.hpp
@@ -1,17 +1,20 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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 TEST_XSEMANTIC_HPP
 #define TEST_XSEMANTIC_HPP
 
 #include <functional>
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+
 #include "test_common.hpp"
 
 namespace xt
diff --git a/test/test_xset_operation.cpp b/test/test_xset_operation.cpp
new file mode 100644
index 000000000..07cbde18d
--- /dev/null
+++ b/test/test_xset_operation.cpp
@@ -0,0 +1,50 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <cstddef>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/misc/xset_operation.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    TEST(xset_operation, isin)
+    {
+        xt::xtensor<int, 2> a = {{1, 2, 1}, {0, 3, 1}};
+        xt::xtensor<int, 1> b = {1, 2};
+        xt::xtensor<bool, 2> res = {{true, true, true}, {false, false, true}};
+        EXPECT_EQ(xt::isin(a, b), res);
+        EXPECT_EQ(xt::isin(a, b.begin(), b.end()), res);
+        EXPECT_EQ(xt::isin(a, {1, 2}), res);
+    }
+
+    TEST(xset_operation, in1d)
+    {
+        xt::xtensor<int, 1> a = {1, 2, 1, 0, 3, 5, 1};
+        xt::xtensor<int, 1> b = {1, 2};
+        xt::xtensor<bool, 1> res = {true, true, true, false, false, false, true};
+        EXPECT_EQ(xt::in1d(a, b), res);
+        EXPECT_EQ(xt::in1d(a, b.begin(), b.end()), res);
+        EXPECT_EQ(xt::in1d(a, {1, 2}), res);
+    }
+
+    TEST(xset_operation, searchsorted)
+    {
+        xt::xtensor<size_t, 1> a = {1, 2, 7, 8, 20};
+        xt::xtensor<size_t, 1> v = {9, 2, 2, 3, 22, 0};
+        xt::xtensor<size_t, 1> res_right = {4, 1, 1, 2, 5, 0};
+        xt::xtensor<size_t, 1> res_left = {4, 2, 2, 2, 5, 0};
+        EXPECT_EQ(xt::searchsorted(a, v), res_right);
+        EXPECT_EQ(xt::searchsorted(a, v, true), res_right);
+        EXPECT_EQ(xt::searchsorted(a, v, false), res_left);
+    }
+}
diff --git a/test/test_xshape.cpp b/test/test_xshape.cpp
index 5ec282254..a00db785e 100644
--- a/test/test_xshape.cpp
+++ b/test/test_xshape.cpp
@@ -1,175 +1,69 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xbroadcast.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xstrides.hpp"
-#include "xtensor/xfixed.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xshape.hpp"
+#include "xtensor/core/xstrides.hpp"
+#include "xtensor/views/xbroadcast.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
-    using vector_type = svector<std::size_t, 4>;
-
-    TEST(svector, behavior)
-    {
-        vector_type s = {1,2,3,4};
-        vector_type s2 = s;
-        std::vector<std::size_t> v(s.begin(), s.end());
-        std::vector<std::size_t> v2 = {1,2,3,4};
-
-        EXPECT_TRUE(std::equal(s.begin(), s.end(), v.begin()));
-        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
-
-        s.erase(s.begin(), s.begin() + 2);
-        v.erase(v.begin(), v.begin() + 2);
-        EXPECT_TRUE(std::equal(s.begin(), s.end(), v.begin()));
-
-        s2.erase(s2.begin() + 1, s2.end());
-        v2.erase(v2.begin() + 1, v2.end());
-        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
-
-        EXPECT_TRUE(s2.on_stack());
-        s2.push_back(10);
-        s2.push_back(20);
-        s2.push_back(30);
-        s2.push_back(40);
-        v2.push_back(10);
-        v2.push_back(20);
-        v2.push_back(30);
-        v2.push_back(40);
-        EXPECT_FALSE(s2.on_stack());
-        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
-    }
-
-    TEST(svector, insert)
-    {
-        vector_type s = {1,2,3,4};
-        vector_type s2 = s;
-        std::vector<std::size_t> v(s.begin(), s.end());
-        std::vector<std::size_t> v2 = {1,2,3,4};
-
-        s.insert(s.begin(), std::size_t(55));
-        s.insert(s.begin() + 2, std::size_t(123));
-        v.insert(v.begin(), std::size_t(55));
-        v.insert(v.begin() + 2, std::size_t(123));
-        std::size_t nr = 12321;
-        s.insert(s.end(), nr);
-        v.insert(v.end(), nr);
-
-        EXPECT_TRUE(std::equal(s.begin(), s.end(), v.begin()));
-    }
-
-    TEST(svector, constructor)
+    TEST(xshape, initializer_dimension)
     {
-        vector_type a;
-        EXPECT_EQ(size_t(0), a.size());
-
-        vector_type b(10);
-        EXPECT_EQ(size_t(10), b.size());
-
-        vector_type c(10, 2);
-        EXPECT_EQ(size_t(10), c.size());
-        EXPECT_EQ(size_t(2), c[2]);
-
-        std::vector<std::size_t> src(10, std::size_t(1));
-        vector_type d(src.cbegin(), src.cend());
-        EXPECT_EQ(size_t(10), d.size());
-        EXPECT_EQ(size_t(1), d[2]);
-
-        vector_type e(src);
-        EXPECT_EQ(size_t(10), d.size());
-        EXPECT_EQ(size_t(1), d[2]);
-        
-        vector_type f = { 1, 2, 3, 4 };
-        EXPECT_EQ(size_t(4), f.size());
-        EXPECT_EQ(size_t(3), f[2]);
-
-        svector<std::size_t, 8> ov = { 1, 2, 3, 4, 5, 6, 7, 8 };
-        vector_type g(ov);
-        EXPECT_EQ(size_t(8), g.size());
-        EXPECT_EQ(size_t(3), g[2]);
-    }
-
-    TEST(svector, assign)
-    {
-        vector_type a = { 1, 2, 3, 4 };
-        
-        vector_type src1(10, 2);
-        a = src1;
-        EXPECT_EQ(size_t(10), a.size());
-        EXPECT_EQ(size_t(2), a[2]);
-
-        std::vector<size_t> src2(5, 1);
-        a = src2;
-        EXPECT_EQ(size_t(5), a.size());
-        EXPECT_EQ(size_t(1), a[2]);
-
-        a = { 1, 2, 3, 4 };
-        EXPECT_EQ(size_t(4), a.size());
-        EXPECT_EQ(size_t(3), a[2]);
-
-        svector<std::size_t, 4> src3(10, 1);
-        a = src3;
-        EXPECT_EQ(size_t(10), a.size());
-        EXPECT_EQ(size_t(1), a[2]);
+        size_t d0 = initializer_dimension<double>::value;
+        size_t d1 = initializer_dimension<std::initializer_list<double>>::value;
+        size_t d2 = initializer_dimension<std::initializer_list<std::initializer_list<double>>>::value;
+        EXPECT_EQ(size_t(0), d0);
+        EXPECT_EQ(size_t(1), d1);
+        EXPECT_EQ(size_t(2), d2);
     }
 
-    TEST(svector, resize)
+    TEST(xshape, shape)
     {
-        vector_type a;
-        for (size_t i = 1; i < 11; ++i)
-        {
-            size_t size1 = i * 10;
-            a.resize(size1);
-            EXPECT_EQ(size1, a.size());
-            size_t size2 = size1 - 5;
-            a.resize(size2);
-            EXPECT_EQ(size2, a.size());
-        }
+        auto s0 = shape<std::vector<size_t>>(3);
+        auto s1 = shape<std::vector<size_t>>(std::initializer_list<size_t>{1, 2});
+        auto s2 = shape<std::vector<size_t>>(
+            std::initializer_list<std::initializer_list<size_t>>{{1, 2, 4}, {1, 3, 5}}
+        );
+
+        std::vector<size_t> e0 = {};
+        std::vector<size_t> e1 = {2};
+        std::vector<size_t> e2 = {2, 3};
+
+        EXPECT_EQ(e0, s0);
+        EXPECT_EQ(e1, s1);
+        EXPECT_EQ(e2, s2);
     }
 
-    TEST(svector, access)
+    TEST(xshape, promote_shape)
     {
-        vector_type a(10);
-        a[0] = size_t(1);
-        EXPECT_EQ(size_t(1), a[0]);
-        a[3] = size_t(3);
-        EXPECT_EQ(size_t(3), a[3]);
-        a[5] = size_t(2);
-        EXPECT_EQ(size_t(2), a[5]);
+        bool expect_v = std::is_same<
+            dynamic_shape<size_t>,
+            promote_shape_t<dynamic_shape<size_t>, std::array<size_t, 3>, std::array<size_t, 2>>>::value;
 
-        a.front() = size_t(0);
-        EXPECT_EQ(size_t(0), a[0]);
+        bool expect_a = std::is_same<
+            std::array<size_t, 3>,
+            promote_shape_t<std::array<size_t, 2>, std::array<size_t, 3>, std::array<size_t, 2>>>::value;
 
-        a.back() = size_t(1);
-        EXPECT_EQ(size_t(1), a[9]);
-    }
-
-    TEST(svector, iterator)
-    {
-        vector_type a(10);
-        std::iota(a.begin(), a.end(), std::size_t(0));
-        for (size_t i = 0; i < a.size(); ++i)
-        {
-            EXPECT_EQ(i, a[i]);
-        }
+        ASSERT_TRUE(expect_v);
+        ASSERT_TRUE(expect_a);
     }
 
-    TEST(xshape, fixed)
+    TEST(xshape, has_shape)
     {
-        fixed_shape<3, 4, 5> af;
-        using cast_type = typename fixed_shape<3, 4, 5>::cast_type;
-        cast_type a = af;
-        EXPECT_EQ(a[0], size_t(3));
-        EXPECT_EQ(a[2], size_t(5));
-        EXPECT_EQ(a.back(), size_t(5));
-        EXPECT_EQ(a.front(), size_t(3));
-        EXPECT_EQ(a.size(), size_t(3));
+        std::array<size_t, 2> shape = {2, 3};
+        xt::xtensor<size_t, 2> A = xt::zeros<size_t>(shape);
+        ASSERT_TRUE(xt::has_shape(A, shape));
+        ASSERT_TRUE(xt::has_shape(A, {2, 3}));
     }
-}
\ No newline at end of file
+}
diff --git a/test/test_xsimd.cpp b/test/test_xsimd.cpp
new file mode 100644
index 000000000..69d2ee995
--- /dev/null
+++ b/test/test_xsimd.cpp
@@ -0,0 +1,78 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+#if defined(_MSC_VER) && !defined(__clang__)
+#define VS_SKIP_XFIXED 1
+#endif
+
+// xfixed leads to ICE in debug mode, this provides
+// an easy way to prevent compilation
+#ifndef VS_SKIP_XFIXED
+
+
+#if (_MSC_VER < 1910 && _WIN64) || (_MSC_VER >= 1910) || !defined(_MSC_VER)
+
+#include <complex>
+#include <limits>
+
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/core/xtensor_config.hpp"
+
+#include "test_common_macros.hpp"
+
+// On VS2015, when compiling in x86 mode, alignas(T) leads to C2718
+// when used for a function parameter, even indirectly. This means that
+// we cannot pass parameters whose class is declared with alignas specifier
+// or any type wrapping or inheriting from such a type.
+// The xtensor_fixed class internally uses aligned_array which is declared as
+// alignas(something_different_from_0), hence the workaround.
+#if _MSC_VER < 1910 && !_WIN64
+#define VS_X86_WORKAROUND 1
+#endif
+
+
+template <typename T>
+class alignas(XTENSOR_FIXED_ALIGN) Foo
+{
+public:
+
+    using allocator_type = std::conditional_t<
+        XTENSOR_FIXED_ALIGN != 0,
+        xt_simd::aligned_allocator<T, XTENSOR_FIXED_ALIGN>,
+        std::allocator<T>>;
+
+    Foo(T fac)
+        : m_fac(fac)
+    {
+        m_bar.fill(fac);
+    }
+
+    auto get() const
+    {
+        return m_bar;
+    }
+
+private:
+
+    xt::xtensor_fixed<T, xt::xshape<10, 10>> m_bar;
+    T m_fac;
+};
+
+namespace xt
+{
+
+    TEST(xsimd, alignas)
+    {
+        int fac = 10;
+        Foo<int> foo(10);
+        EXPECT_TRUE(xt::sum(foo.get())() == fac * 10 * 10);
+    }
+}
+
+#endif
+#endif  // VS_SKIP_XFIXED
diff --git a/test/test_xsimd8.cpp b/test/test_xsimd8.cpp
new file mode 100644
index 000000000..01b3e7834
--- /dev/null
+++ b/test/test_xsimd8.cpp
@@ -0,0 +1,30 @@
+/***************************************************************************
+ * 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. *
+ ****************************************************************************/
+
+#include <complex>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/misc/xcomplex.hpp"
+
+#include "test_common_macros.hpp"
+
+namespace xt
+{
+    using namespace std::complex_literals;
+
+    TEST(xcomplex, arg)
+    {
+        xarray<std::complex<double>> cmplarg_0 = {
+            {0.40101756 + 0.71233018i, 0.62731701 + 0.42786349i, 0.32415089 + 0.2977805i},
+            {0.24475928 + 0.49208478i, 0.69475518 + 0.74029639i, 0.59390240 + 0.35772892i},
+            {0.63179202 + 0.41720995i, 0.44025718 + 0.65472131i, 0.08372648 + 0.37380143i}
+        };
+        xarray<std::complex<double>> res = xt::conj(cmplarg_0);
+    }
+}
diff --git a/test/test_xsort.cpp b/test/test_xsort.cpp
index 605efd1b6..bbe928d4d 100644
--- a/test/test_xsort.cpp
+++ b/test/test_xsort.cpp
@@ -1,34 +1,34 @@
-/****************************************************************************
- * Copyright (c) 2016, Johan Mabille, Sylvain Corlay and Wolf Vollprecht    *
+/***************************************************************************
+ * 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. *
  ****************************************************************************/
 
-#include "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xinfo.hpp"
-#include "xtensor/xview.hpp"
-#include "xtensor/xrandom.hpp"
-#include "xtensor/xslice.hpp"
-#include "xtensor/xsort.hpp"
+#include "xtensor/containers/xadapt.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xmath.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/io/xinfo.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xsort.hpp"
+#include "xtensor/views/xslice.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
-
     TEST(xsort, argsort)
     {
         xarray<double> a1 = {2, 3, 1};
         xarray<double, xt::layout_type::column_major> a2_c = {{2, 3, 1}, {4, 6, 5}};
         xarray<double, xt::layout_type::row_major> a2_r = {{2, 3, 1}, {4, 6, 5}};
-        xarray<float> a3 = {{{1,3,2},
-                             {4,2,1}},
-                            {{5,1,3},
-                             {4,2,6}}};
+        xarray<float> a3 = {{{1, 3, 2}, {4, 2, 1}}, {{5, 1, 3}, {4, 2, 6}}};
 
         xarray<std::size_t> ex = {2, 0, 1};
         EXPECT_EQ(ex, argsort(a1, 0));
@@ -44,9 +44,9 @@ namespace xt
         EXPECT_EQ(ex2_1, argsort(a2_c, 1));
         EXPECT_EQ(ex2_1, argsort(a2_r, 1));
 
-        xarray<std::size_t> ex3_0 = {{{0,1,0},{0,0,0}},{{1,0,1},{1,1,1}}};
-        xarray<std::size_t> ex3_1 = {{{0,1,1},{1,0,0}},{{1,0,0},{0,1,1}}};
-        xarray<std::size_t> ex3_2 = {{{0,2,1},{2,1,0}},{{1,2,0},{1,0,2}}};
+        xarray<std::size_t> ex3_0 = {{{0, 1, 0}, {0, 0, 0}}, {{1, 0, 1}, {1, 1, 1}}};
+        xarray<std::size_t> ex3_1 = {{{0, 1, 1}, {1, 0, 0}}, {{1, 0, 0}, {0, 1, 1}}};
+        xarray<std::size_t> ex3_2 = {{{0, 2, 1}, {2, 1, 0}}, {{1, 2, 0}, {1, 0, 2}}};
 
         EXPECT_EQ(ex3_2, argsort(a3));
         EXPECT_EQ(ex3_0, argsort(a3, 0));
@@ -58,7 +58,7 @@ namespace xt
         EXPECT_EQ(ex4, argsort(t1, 0));
         EXPECT_EQ(ex4, argsort(t1));
 
-        if (XTENSOR_DEFAULT_LAYOUT == layout_type::row_major)
+        if (XTENSOR_DEFAULT_TRAVERSAL == layout_type::row_major)
         {
             xtensor_fixed<double, xt::xshape<2, 3>> tf1 = a2_r;
             EXPECT_EQ(ex2_1, argsort(tf1));
@@ -70,6 +70,112 @@ namespace xt
         }
     }
 
+    TEST(xsort, argsort_zero_stride)
+    {
+        {
+            xt::xtensor<double, 2> A = {{1.4, 1.3, 1.2, 1.1}};
+            xt::xtensor<size_t, 2> bsort = {{0, 0, 0, 0}};
+            xt::xtensor<size_t, 2> fsort = {{3, 2, 1, 0}};
+            EXPECT_EQ(bsort, xt::argsort(A, 0));
+            EXPECT_EQ(fsort, xt::argsort(A, 1));
+            EXPECT_EQ(fsort, xt::argsort(A));
+        }
+        {
+            xt::xtensor<double, 3> A = {{{1.4, 1.3, 1.2, 1.1}}};
+            xt::xtensor<size_t, 3> bsort = {{{0, 0, 0, 0}}};
+            xt::xtensor<size_t, 3> fsort = {{{3, 2, 1, 0}}};
+            EXPECT_EQ(bsort, xt::argsort(A, 0));
+            EXPECT_EQ(bsort, xt::argsort(A, 1));
+            EXPECT_EQ(fsort, xt::argsort(A, 2));
+            EXPECT_EQ(fsort, xt::argsort(A));
+        }
+    }
+
+    TEST(xsort, argsort_zero_stride_column_major)
+    {
+        {
+            xt::xtensor<double, 2, xt::layout_type::column_major> A = {{1.4, 1.3, 1.2, 1.1}};
+            xt::xtensor<size_t, 2, xt::layout_type::column_major> bsort = {{0, 0, 0, 0}};
+            xt::xtensor<size_t, 2, xt::layout_type::column_major> fsort = {{3, 2, 1, 0}};
+            EXPECT_EQ(bsort, xt::argsort(A, 0));
+            EXPECT_EQ(fsort, xt::argsort(A, 1));
+            EXPECT_EQ(fsort, xt::argsort(A));
+        }
+        {
+            xt::xtensor<double, 3, xt::layout_type::column_major> A = {{{1.4, 1.3, 1.2, 1.1}}};
+            xt::xtensor<size_t, 3, xt::layout_type::column_major> bsort = {{{0, 0, 0, 0}}};
+            xt::xtensor<size_t, 3, xt::layout_type::column_major> fsort = {{{3, 2, 1, 0}}};
+            EXPECT_EQ(bsort, xt::argsort(A, 0));
+            EXPECT_EQ(bsort, xt::argsort(A, 1));
+            EXPECT_EQ(fsort, xt::argsort(A, 2));
+            EXPECT_EQ(fsort, xt::argsort(A));
+        }
+    }
+
+    TEST(xsort, flatten_argsort)
+    {
+        {
+            xarray<int, layout_type::row_major> a = {{1, 2, 3}, {4, 5, 6}};
+            xarray<std::size_t, layout_type::row_major> res = argsort(a, placeholders::xtuph());
+            xarray<std::size_t, layout_type::row_major> expected = {0, 1, 2, 3, 4, 5};
+            EXPECT_EQ(res, expected);
+        }
+        {
+            xarray<int, layout_type::column_major> a = {{1, 2, 3}, {4, 5, 6}};
+            xarray<std::size_t, layout_type::column_major> res = argsort(a, placeholders::xtuph());
+            xarray<std::size_t, layout_type::column_major> expected = {0, 1, 2, 3, 4, 5};
+            EXPECT_EQ(res, expected);
+        }
+    }
+
+    TEST(xsort, argsort_stable)
+    {
+        xt::xarray<int> a = {
+            2247,  2044, 2037, 1825, 1699, 1600, 1501, 1432, 1440, 1388, 1299, 1259,  1211, 1177, 1124, 1121,
+            1399,  1179, 1102, 1055, 1017, 1001, 979,  953,  925,  927,  1899, 4782,  2601, 3050, 1998, 3478,
+            5762,  8745, 7777, 4086, 2968, 2456, 2138, 3199, 7187, 7165, 3942, 11588, 4643, 3618, 3184, 6052,
+            3723,  3356, 2645, 2330, 2103, 1928, 1890, 3624, 3647, 5821, 2949, 4161,  3855, 5200, 3162, 3896,
+            19818, 5228, 3711, 4874, 4868, 4267, 2978, 2748, 2500, 2276, 2107, 1969,  1815, 1714, 1649, 1561,
+            1491,  1428, 1347, 1288, 1245, 1207, 1163, 1189, 1558, 1313, 1186, 1147,  1143, 1099, 1036, 1008,
+            982,   953,  924,  899,  880,  858,  836,  818,  791,  762,  742,  720,   701,  685,  674,  658,
+            643,   625,  609,  602,  594,  594,  625,  616,  707,  759,  929,  755,   684,  737,  804,  680,
+            639,   620,  706,  2474, 1406, 2686, 2037, 1410, 1130, 992,  901,  847,   798,  766,  750,  2793,
+            1574,  1087, 960,  883,  823,  782,  755,  730,  705,  677,  744,  932,   770,  794,  804,  728,
+            721,   765,  826,  795,  784,  875,  711,  795,  2295, 1265, 1115, 936,   817,  742,  713,  680,
+            647,   647,  671,  651,  692,  605,  576,  612,  564,  536,  526,  516,   506,  494,  473,  459,
+            451,   450,  441,  428,  430,  453,  467,  444,  413,  390,  376,  373,   368,  360,  359,  351,
+            348,   345,  343,  340,  337,  341,  529,  476,  448,  397,  367,  354,   342,  332,  320,  324,
+            327,   332,  340,  359,  331,  382,  371,  356,  333,  318,  316,  318,   312,  308,  300,  298,
+            399,   448,  669,  534,  402,  384,  361,  347,  337,  342,  349,  339,   333,  325,  324,  326,
+            324,   322,  320,  318,  322,  327,  327,  333,  329,  333,  353,  436,   516,  412,  402,  398,
+            551,   449,  416,  484,  801,  537,  457,  483,  534,  477,  483,  582,   575,  557,  504,  477,
+            515,   643,  627,  627,  546,  515,  497,  577,  1439, 1198, 1591, 1815,  1448, 1117, 960,  847,
+            809,   788,  749,  896,  870,  801,  752
+        };
+
+        xt::xarray<std::size_t> ex = {
+            239, 238, 237, 236, 234, 233, 235, 259, 222, 258, 257, 260, 223, 254, 256, 253, 255, 224, 261,
+            262, 264, 228, 221, 225, 232, 252, 263, 265, 212, 248, 251, 211, 226, 213, 220, 249, 210, 209,
+            247, 208, 250, 207, 266, 219, 231, 206, 227, 205, 246, 218, 204, 230, 203, 202, 229, 245, 201,
+            217, 271, 240, 244, 270, 269, 200, 274, 195, 196, 267, 194, 199, 216, 241, 273, 193, 192, 197,
+            278, 191, 198, 190, 215, 281, 287, 279, 282, 275, 189, 294, 286, 188, 288, 293, 187, 268, 186,
+            214, 243, 280, 185, 277, 292, 272, 285, 184, 284, 182, 295, 283, 116, 117, 115, 181, 114, 183,
+            119, 129, 113, 118, 290, 291, 128, 112, 289, 176, 177, 179, 111, 242, 178, 110, 153, 127, 175,
+            124, 109, 180, 108, 152, 130, 120, 166, 174, 107, 160, 159, 151, 125, 106, 173, 154, 306, 142,
+            310, 123, 150, 121, 105, 161, 141, 156, 149, 164, 305, 104, 157, 163, 167, 140, 276, 309, 126,
+            158, 304, 172, 103, 148, 162, 102, 139, 303, 101, 308, 165, 100, 147, 307, 99,  138, 98,  24,
+            25,  122, 155, 171, 23,  97,  146, 302, 22,  96,  137, 21,  95,  20,  94,  19,  145, 93,  18,
+            170, 301, 15,  14,  136, 92,  91,  86,  13,  17,  90,  87,  297, 85,  12,  84,  11,  169, 83,
+            10,  89,  82,  9,   16,  132, 135, 81,  7,   296, 8,   300, 80,  6,   88,  79,  144, 298, 5,
+            78,  4,   77,  76,  299, 3,   54,  26,  53,  75,  30,  2,   134, 1,   52,  74,  38,  0,   73,
+            168, 51,  37,  131, 72,  28,  50,  133, 71,  143, 58,  36,  70,  29,  62,  46,  39,  49,  31,
+            45,  55,  56,  66,  48,  60,  63,  42,  35,  59,  69,  44,  27,  68,  67,  61,  65,  32,  57,
+            47,  41,  40,  34,  33,  43,  64
+        };
+
+        EXPECT_EQ(ex, xt::argsort(a, {0}, xt::sorting_method::stable));
+    }
+
     TEST(xsort, sort_easy)
     {
         xarray<double> a = {{5, 3, 1}, {4, 4, 4}};
@@ -88,6 +194,13 @@ namespace xt
 
         xarray<double> ex_3 = {{1, 3, 5}, {4, 4, 4}};
         EXPECT_EQ(ex_3, sort(a, 1));
+
+#ifndef XTENSOR_DISABLE_EXCEPTIONS
+        xt::xarray<double> xarr = xt::eval(xt::arange(0, 16));
+        xarr.reshape({4, 4});
+        auto view = xt::reshape_view(xt::transpose(xarr, {1, 0}), {2, 8});
+        EXPECT_NO_THROW(xt::sort(view, 0));
+#endif
     }
 
     TEST(xsort, fixed)
@@ -104,12 +217,11 @@ namespace xt
     TEST(xsort, argmin)
     {
         xarray<double> a = {{5, 3, 1}, {4, 4, 4}};
-        xarray<double> b = {1,3,4,-100};
+        xarray<double> b = {1, 3, 4, -100};
         xarray<double, layout_type(int(XTENSOR_DEFAULT_LAYOUT) & 0x03)> ar = {{5, 3, 1}, {4, 4, 4}};
 
-        xarray<std::size_t> ex;
+        xarray<std::size_t> ex = 2ul;
 
-        ex = (XTENSOR_DEFAULT_LAYOUT == layout_type::row_major) ? 2ul : 4ul;
         EXPECT_EQ(ex, argmin(a));
 
         EXPECT_EQ(size_t(3), argmin(b)());
@@ -121,11 +233,14 @@ namespace xt
         xarray<std::size_t> ex_3 = {2, 0};
         EXPECT_EQ(ex_3, argmin(a, 1));
 
-        xtensor<double, 2> xa = {{5,3,1}, {4,4,4}};
+        xtensor<double, 2> xa = {{5, 3, 1}, {4, 4, 4}};
         EXPECT_EQ(ex, argmin(xa));
         EXPECT_EQ(ex_2, argmin(xa, 0));
         EXPECT_EQ(ex_3, argmin(xa, 1));
 
+        xtensor<double, 1> ya = {1, 0, 3, 2, 2};
+        EXPECT_EQ(1, argmin(ya)());
+        EXPECT_EQ(1, argmin(ya, 0)());
     }
 
     TEST(xsort, argmax)
@@ -140,9 +255,29 @@ namespace xt
         xarray<std::size_t> ex_3 = {0, 0};
         EXPECT_EQ(ex_3, argmax(a, 1));
 
-        xt::xtensor<int, 2> b = {{ 1,2 }};
+        xtensor<int, 2> b = {{1, 2}};
         auto res = xt::eval(xt::argmax(b, 1));
-        EXPECT_EQ(res(), 0);
+        EXPECT_EQ(res(), 1u);
+
+        xtensor<int, 3> c = {{{1, 2, 3, 4}}, {{4, 3, 2, 1}}};
+        xtensor<std::size_t, 2> ex_4 = {{3}, {0}};
+        EXPECT_EQ(ex_4, argmax(c, 2));
+
+        xtensor<std::size_t, 2> ex_5 = {{1, 1, 0, 0}};
+        EXPECT_EQ(ex_5, argmax(c, 0));
+
+        xtensor<std::size_t, 2> ex_6 = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+        EXPECT_EQ(ex_6, argmax(c, 1));
+
+        xtensor<double, 1> ya = {1, 0, 3, 2, 2};
+        EXPECT_EQ(2, argmax(ya)());
+        EXPECT_EQ(2, argmax(ya, 0)());
+
+        // xtensor#2568
+        xarray<double> d = {0, 1, 0};
+        xtensor<size_t, 0> d_ex_1 = {1};
+        EXPECT_EQ(d_ex_1, argmax(d));
+        EXPECT_EQ(1, argmax(d)(0));
     }
 
     TEST(xsort, sort_large_prob)
@@ -175,28 +310,28 @@ namespace xt
         {
             xarray<double> a = xt::random::rand<double>({5, 4, 6, 7});
 
-            auto a_s0 = argmin(a, 0);
+            auto a_s0 = argmin<XTENSOR_DEFAULT_LAYOUT>(a, 0);
             auto va_s0 = view(a, xt::all(), 3, 2, 3);
             auto m0_idx = a_s0(3, 2, 3);
             auto it0 = std::min_element(va_s0.begin(), va_s0.end());
             auto c0_idx = std::distance(va_s0.begin(), it0);
             EXPECT_EQ(static_cast<size_t>(c0_idx), m0_idx);
 
-            auto a_s1 = argmin(a, 1);
+            auto a_s1 = argmin<XTENSOR_DEFAULT_LAYOUT>(a, 1);
             auto va_s1 = view(a, 3, xt::all(), 2, 3);
             auto m1_idx = a_s1(3, 2, 3);
             auto it1 = std::min_element(va_s1.begin(), va_s1.end());
             auto c1_idx = std::distance(va_s1.begin(), it1);
             EXPECT_EQ(static_cast<size_t>(c1_idx), m1_idx);
 
-            auto a_s2 = argmin(a, 2);
+            auto a_s2 = argmin<XTENSOR_DEFAULT_LAYOUT>(a, 2);
             auto va_s2 = view(a, 3, 2, xt::all(), 3);
             auto m2_idx = a_s2(3, 2, 3);
             auto it2 = std::min_element(va_s2.begin(), va_s2.end());
             auto c2_idx = std::distance(va_s2.begin(), it2);
             EXPECT_EQ(static_cast<size_t>(c2_idx), m2_idx);
 
-            auto a_s3 = argmin(a, 3);
+            auto a_s3 = argmin<XTENSOR_DEFAULT_LAYOUT>(a, 3);
             auto va_s3 = view(a, 3, 2, 3, xt::all());
             auto m3_idx = a_s3(3, 2, 3);
             auto it3 = std::min_element(va_s3.begin(), va_s3.end());
@@ -207,33 +342,226 @@ namespace xt
 
     TEST(xsort, unique)
     {
-        xarray<double> a = {1,2,3, 5,3,2,1,2,2,2,2,2,2, 45};
+        xarray<double> a = {1, 2, 3, 5, 3, 2, 1, 2, 2, 2, 2, 2, 2, 45};
         xarray<double> ax = {1, 2, 3, 5, 45};
         EXPECT_EQ(unique(a), ax);
 
-        xarray<double> b = {{1,2,3}, {4,5,6}, {7,8,9}};
-        xarray<double> bx = {1,2,3,4,5,6,7,8,9};
+        xarray<double> b = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+        xarray<double> bx = {1, 2, 3, 4, 5, 6, 7, 8, 9};
         EXPECT_EQ(unique(b), bx);
 
-        xarray<double> bb = {{1,2,3}, {7,8,9}, {4,5,6}, {7,8,9}};
-        xarray<double> bbx = {1,2,3,4,5,6,7,8,9};
+        xarray<double> bb = {{1, 2, 3}, {7, 8, 9}, {4, 5, 6}, {7, 8, 9}};
+        xarray<double> bbx = {1, 2, 3, 4, 5, 6, 7, 8, 9};
         EXPECT_EQ(unique(bb), bbx);
+
+        auto c = view(b, range(0, 3), range(0, 3));
+        auto d = unique(c);
+        EXPECT_EQ(d, bx);
+
+        auto e = xt::unique(xt::where(xt::greater(b, 2), 1, 0));
+        xarray<double> ex = {0, 1};
+        EXPECT_EQ(e, ex);
     }
 
     TEST(xsort, setdiff1d)
     {
         {
-            xarray<size_t> ar1 = {1,2,3,4,4,4,5};
-            xarray<size_t> ar2 = {4,5};
-            xarray<size_t> out = {1,2,3};
+            xarray<size_t> ar1 = {1, 2, 3, 4, 4, 4, 5};
+            xarray<size_t> ar2 = {4, 5};
+            xarray<size_t> out = {1, 2, 3};
             EXPECT_EQ(setdiff1d(ar1, ar2), out);
         }
 
         {
-            xarray<size_t> ar1 = {{5,6,7},{4,4,4},{1,2,3}};
-            xarray<size_t> ar2 = {4,1};
-            xarray<size_t> out = {2,3,5,6,7};
+            xarray<size_t> ar1 = {{5, 6, 7}, {4, 4, 4}, {1, 2, 3}};
+            xarray<size_t> ar2 = {4, 1};
+            xarray<size_t> out = {2, 3, 5, 6, 7};
             EXPECT_EQ(setdiff1d(ar1, ar2), out);
         }
     }
+
+    template <class T>
+    bool check_partition(T& arr, std::size_t pos)
+    {
+        bool res = true;
+        for (std::size_t i = 0; i < pos; ++i)
+        {
+            res = res && arr(i) <= arr(pos);
+        }
+        for (std::size_t i = pos; i < arr.size(); ++i)
+        {
+            res = res && arr(i) >= arr(pos);
+        }
+        return res;
+    }
+
+    TEST(xsort, partition)
+    {
+        SUBCASE("simple")
+        {
+            xt::xarray<int> a = {3, 4, 2, 1};
+            auto part = xt::partition(a, 2);
+            EXPECT_TRUE(check_partition(part, 2));
+        }
+
+        SUBCASE("complex")
+        {
+            xt::xarray<double> a = {927.,  932.,  935.,  943.,  944.,  944.,  945.,  948.,  952.,
+                                    962.,  968.,  968.,  969.,  969.,  974.,  981.,  993.,  994.,
+                                    994.,  1003., 1007., 1008., 1008., 1012., 1013., 1014., 1014.,
+                                    1017., 1019., 1020., 1023., 1026., 1026., 1028., 1030., 1032.,
+                                    1039., 1047., 1071., 1080., 1085., 1088., 1111., 1112., 1117.,
+                                    1119., 1128., 1130., 1209., 1309., 1426.};
+            xt::xtensor_fixed<std::size_t, xt::xshape<4>> kth = {17, 32, 18, 33};
+
+            SUBCASE("1D")
+            {
+                auto part = xt::partition(a, kth);
+                for (std::size_t k : kth)
+                {
+                    CAPTURE(k);
+                    EXPECT_TRUE(check_partition(part, k));
+                }
+            }
+
+            SUBCASE("2D")
+            {
+                a.reshape({1, a.size()});
+                auto part = xt::partition(a, kth, 1);
+                for (std::size_t k : kth)
+                {
+                    CAPTURE(k);
+                    EXPECT_TRUE(check_partition(part, k));
+                }
+            }
+        }
+
+        SUBCASE("exception")
+        {
+#ifndef XTENSOR_DISABLE_EXCEPTIONS
+            xt::xarray<double> a = xt::eval(xt::arange(0, 16));
+            a.reshape({4, 4});
+            auto view = xt::transpose(a, {1, 0});
+            EXPECT_NO_THROW(xt::partition(view, 1, 0));
+#endif
+        }
+    }
+
+    template <class T, class U>
+    bool check_argpartition(T& arr, U& idxs, std::size_t pos)
+    {
+        bool res = true;
+        for (std::size_t i = 0; i < pos; ++i)
+        {
+            res = res && arr(idxs[i]) <= arr(idxs[pos]);
+        }
+        for (std::size_t i = pos; i < arr.size(); ++i)
+        {
+            res = res && arr(idxs[i]) >= arr(idxs[pos]);
+        }
+        return res;
+    }
+
+    TEST(xsort, argpartition)
+    {
+        SUBCASE("simple")
+        {
+            xt::xarray<int> a = {3, 4, 2, 1};
+            auto r1 = xt::argpartition(a, 2);
+            EXPECT_TRUE(check_argpartition(a, r1, 2));
+
+            SUBCASE("adapt")
+            {
+                std::size_t s = a.size();
+                int* arr = a.data();
+                dynamic_shape<std::size_t> sh = {s};
+                auto b = xt::adapt(arr, s, xt::no_ownership(), sh);
+                auto r2 = xt::argpartition(b, 2);
+                EXPECT_TRUE(check_argpartition(b, r2, 2));
+            }
+        }
+
+        SUBCASE("complex")
+        {
+            const xt::xarray<double> data = {1014., 1017., 1019., 1020., 1023., 1026., 1026., 1028., 1030.,
+                                             1032., 1039., 1047., 1071., 927.,  932.,  935.,  943.,  944.,
+                                             944.,  945.,  948.,  952.,  962.,  968.,  968.,  969.,  969.,
+                                             974.,  981.,  993.,  994.,  994.,  1003., 1007., 1008., 1008.,
+                                             1012., 1013., 1014., 1080., 1085., 1088., 1111., 1112., 1117.,
+                                             1119., 1128., 1130., 1209., 1309., 1426.};
+            const xt::xtensor_fixed<std::size_t, xt::xshape<4>> kth = {17, 32, 18, 33};
+
+            SUBCASE("1D")
+            {
+                const auto& a = data;
+                const auto argpart = xt::argpartition(a, kth);
+                for (std::size_t k : kth)
+                {
+                    CAPTURE(k);
+                    EXPECT_TRUE(check_argpartition(a, argpart, k));
+                }
+            }
+
+            SUBCASE("2D")
+            {
+                auto a = data;
+                a.reshape({1, a.size()});
+                const auto argpart = xt::argpartition(a, kth, 1);
+                for (std::size_t k : kth)
+                {
+                    CAPTURE(k);
+                    EXPECT_TRUE(check_argpartition(a, argpart, k));
+                }
+            }
+        }
+    }
+
+    TEST(xsort, quantile)
+    {
+        const xt::xtensor_fixed<double, xt::xshape<4, 2, 2>> data = {
+            {{3., 4.}, {2., 1.}},
+            {{-1., 1.}, {3., 2.}},
+            {{-9., -0.}, {-9., -3.}},
+            {{12., 12.}, {12., 12.}},
+        };
+
+        {
+            auto q = xt::quantile(data, {.3, .0, 1.});
+            const xt::xtensor_fixed<double, xt::xshape<3>> expected = {0.5, -9., 12.};
+            EXPECT_TRUE(xt::equal(q, expected)(0));
+        }
+
+        const xt::xtensor_fixed<double, xt::xshape<3, 4, 2>> expected1 = {
+            {{2.3, 1.9}, {0.2, 1.3}, {-9., -2.1}, {12., 12.}},
+            {{2., 1.}, {-1., 1.}, {-9., -3.}, {12., 12.}},
+            {{3., 4.}, {3., 2.}, {-9., 0.}, {12., 12.}},
+        };
+        {
+            auto q1 = xt::quantile(data, {.3, .0, 1.}, 1);
+            EXPECT_TRUE(xt::equal(q1, expected1)(0));
+        }
+        {
+            auto q1 = xt::quantile(xt::xtensor<float, 3>(data), {.3, .0, 1.}, 1);
+            EXPECT_TRUE(xt::equal(q1, expected1)(0));
+        }
+        {
+            auto q1 = xt::quantile(xt::xarray<float>(data), {.3, .0, 1.}, 1);
+            EXPECT_TRUE(xt::equal(q1, expected1)(0));
+        }
+    }
+
+    TEST(xsort, median)
+    {
+        xt::xtensor<float, 2> a = {{3, 4, 2, 1}, {1, 1, 3, 2}, {9, 9, 9, 9}, {12, 12, 12, 12}, {5, 5, 5, 5}};
+        auto mall = median(a);
+        auto ma0 = median(a, 0);
+        auto ma1 = median(a, 1);
+
+        EXPECT_EQ(mall, 5.f);
+
+        xt::xtensor<float, 1> ma0_exp = {5, 5, 5, 5};
+        xt::xtensor<float, 1> ma1_exp = {2.5, 1.5, 9., 12., 5.};
+        EXPECT_EQ(ma0, ma0_exp);
+        EXPECT_EQ(ma1, ma1_exp);
+    }
 }
diff --git a/test/test_xstorage.cpp b/test/test_xstorage.cpp
index ec5096dd3..cb66a8c69 100644
--- a/test/test_xstorage.cpp
+++ b/test/test_xstorage.cpp
@@ -1,20 +1,27 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xtensor_config.hpp"
-#include "xtensor/xstorage.hpp"
+ * 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. *
+ ****************************************************************************/
+
 #include <numeric>
 
+#include "xtensor/containers/xstorage.hpp"
+#include "xtensor/core/xtensor_config.hpp"
+
+#include "test_common_macros.hpp"
+
 namespace xt
 {
     using vector_type = uvector<double, XTENSOR_DEFAULT_ALLOCATOR(double)>;
 
+    /***********
+     * uvector *
+     ***********/
+
     TEST(uvector, constructor)
     {
         vector_type a;
@@ -62,6 +69,9 @@ namespace xt
 
         a.back() = 1.0;
         EXPECT_EQ(1.0, a[9]);
+
+        EXPECT_EQ(a.at(5), 2.7);
+        XT_EXPECT_ANY_THROW(a.at(12));
     }
 
     TEST(uvector, iterator)
@@ -73,4 +83,266 @@ namespace xt
             EXPECT_EQ(double(i), a[i]);
         }
     }
+
+    /***********
+     * svector *
+     ***********/
+
+    using svector_type = svector<std::size_t, 4>;
+
+    TEST(svector, behavior)
+    {
+        svector_type s = {1, 2, 3, 4};
+        svector_type s2 = s;
+        std::vector<std::size_t> v(s.begin(), s.end());
+        std::vector<std::size_t> v2 = {1, 2, 3, 4};
+
+        EXPECT_TRUE(std::equal(s.begin(), s.end(), v.begin()));
+        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
+
+        s.erase(s.begin(), s.begin() + 2);
+        v.erase(v.begin(), v.begin() + 2);
+        EXPECT_TRUE(std::equal(s.begin(), s.end(), v.begin()));
+
+        s2.erase(s2.begin() + 1, s2.end());
+        v2.erase(v2.begin() + 1, v2.end());
+        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
+
+        std::size_t i1 = 50;
+        std::size_t i2 = 50;
+        EXPECT_TRUE(s2.on_stack());
+        s2.push_back(10);
+        s2.push_back(20);
+        s2.push_back(30);
+        s2.push_back(40);
+        s2.push_back(i1);
+        s2.push_back(std::move(i1));
+        v2.push_back(10);
+        v2.push_back(20);
+        v2.push_back(30);
+        v2.push_back(40);
+        v2.push_back(i2);
+        v2.push_back(std::move(i2));
+        EXPECT_FALSE(s2.on_stack());
+        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
+    }
+
+    TEST(svector, insert)
+    {
+        svector_type s = {1, 2, 3, 4};
+        svector_type s2 = s;
+        std::vector<std::size_t> v(s.begin(), s.end());
+        std::vector<std::size_t> v2 = {1, 2, 3, 4};
+
+        s.insert(s.begin(), std::size_t(55));
+        s.insert(s.begin() + 2, std::size_t(123));
+        v.insert(v.begin(), std::size_t(55));
+        v.insert(v.begin() + 2, std::size_t(123));
+        std::size_t nr = 12321;
+        s.insert(s.end(), nr);
+        v.insert(v.end(), nr);
+
+        EXPECT_TRUE(std::equal(s.begin(), s.end(), v.begin()));
+    }
+
+    TEST(svector, insert_range)
+    {
+        svector_type s0 = {1, 2, 3, 4};
+        svector_type s1 = s0;
+        svector_type s2 = s0;
+        std::vector<std::size_t> v0(s0.begin(), s0.end());
+        std::vector<std::size_t> v1(v0);
+        std::vector<std::size_t> v2(v0);
+        std::vector<std::size_t> ins = {1, 4};
+
+        s0.insert(s0.begin(), ins.cbegin(), ins.cend());
+        v0.insert(v0.begin(), ins.cbegin(), ins.cend());
+        s1.insert(s1.begin() + 2, ins.cbegin(), ins.cend());
+        v1.insert(v1.begin() + 2, ins.cbegin(), ins.cend());
+        s2.insert(s2.begin() + 4, ins.cbegin(), ins.cend());
+        v2.insert(v2.begin() + 4, ins.cbegin(), ins.cend());
+
+        EXPECT_TRUE(std::equal(s0.begin(), s0.end(), v0.begin()));
+        EXPECT_TRUE(std::equal(s1.begin(), s1.end(), v1.begin()));
+        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
+    }
+
+    TEST(svector, insert_initializer_list)
+    {
+        svector_type s0 = {1, 2, 3, 4};
+        svector_type s1 = s0;
+        svector_type s2 = s0;
+        std::vector<std::size_t> v0(s0.begin(), s0.end());
+        std::vector<std::size_t> v1(v0);
+        std::vector<std::size_t> v2(v0);
+
+        s0.insert(s0.begin(), {1u, 4u});
+        v0.insert(v0.begin(), {1u, 4u});
+        s1.insert(s1.begin() + 2, {1u, 4u});
+        v1.insert(v1.begin() + 2, {1u, 4u});
+        s2.insert(s2.begin() + 4, {1u, 4u});
+        v2.insert(v2.begin() + 4, {1u, 4u});
+
+        EXPECT_TRUE(std::equal(s0.begin(), s0.end(), v0.begin()));
+        EXPECT_TRUE(std::equal(s1.begin(), s1.end(), v1.begin()));
+        EXPECT_TRUE(std::equal(s2.begin(), s2.end(), v2.begin()));
+    }
+
+    TEST(svector, constructor)
+    {
+        svector_type a;
+        EXPECT_EQ(size_t(0), a.size());
+
+        svector_type b(10);
+        EXPECT_EQ(size_t(10), b.size());
+
+        svector_type c(10, 2);
+        EXPECT_EQ(size_t(10), c.size());
+        EXPECT_EQ(size_t(2), c[2]);
+
+        std::vector<std::size_t> src(10, std::size_t(1));
+        svector_type d(src.cbegin(), src.cend());
+        EXPECT_EQ(size_t(10), d.size());
+        EXPECT_EQ(size_t(1), d[2]);
+
+        svector_type e(src);
+        EXPECT_EQ(size_t(10), d.size());
+        EXPECT_EQ(size_t(1), d[2]);
+
+        svector_type f = {1, 2, 3, 4};
+        EXPECT_EQ(size_t(4), f.size());
+        EXPECT_EQ(size_t(3), f[2]);
+
+        svector<std::size_t, 8> ov = {1, 2, 3, 4, 5, 6, 7, 8};
+        svector_type g(ov);
+        EXPECT_EQ(size_t(8), g.size());
+        EXPECT_EQ(size_t(3), g[2]);
+    }
+
+    TEST(svector, assign)
+    {
+        svector_type a = {1, 2, 3, 4};
+
+        svector_type src1(10, 2);
+        a = src1;
+        EXPECT_EQ(size_t(10), a.size());
+        EXPECT_EQ(size_t(2), a[2]);
+
+        std::vector<size_t> src2(5, 1);
+        a = src2;
+        EXPECT_EQ(size_t(5), a.size());
+        EXPECT_EQ(size_t(1), a[2]);
+
+        a = {1, 2, 3, 4};
+        EXPECT_EQ(size_t(4), a.size());
+        EXPECT_EQ(size_t(3), a[2]);
+
+        svector<std::size_t, 4> src3(10, 1);
+        a = src3;
+        EXPECT_EQ(size_t(10), a.size());
+        EXPECT_EQ(size_t(1), a[2]);
+    }
+
+    TEST(svector, resize)
+    {
+        svector_type a;
+        for (size_t i = 1; i < 11; ++i)
+        {
+            size_t size1 = i * 10;
+            a.resize(size1);
+            EXPECT_EQ(size1, a.size());
+            size_t size2 = size1 - 5;
+            a.resize(size2);
+            EXPECT_EQ(size2, a.size());
+        }
+
+        svector_type b = {1, 3, 4};
+        b.resize(6);
+        EXPECT_EQ(b[0], 1u);
+        EXPECT_EQ(b[1], 3u);
+        EXPECT_EQ(b[2], 4u);
+    }
+
+    TEST(svector, swap)
+    {
+        using std::swap;
+
+        {
+            svector_type a = {1, 3, 4, 6, 7};
+            svector_type b = {};
+            svector_type abu = a;
+            svector_type bbu = b;
+
+            swap(a, b);
+
+            EXPECT_EQ(a, bbu);
+            EXPECT_EQ(b, abu);
+        }
+
+        {
+            svector_type a = {1, 3, 4};
+            svector_type b = {2, 1, 5, 3, 9, 12};
+            svector_type abu = a;
+            svector_type bbu = b;
+
+            swap(a, b);
+
+            EXPECT_EQ(a, bbu);
+            EXPECT_EQ(b, abu);
+        }
+
+        {
+            svector_type a = {10, 13, 14};
+            svector_type b = {12, 15, 17};
+            svector_type abu = a;
+            svector_type bbu = b;
+
+            swap(a, b);
+
+            EXPECT_EQ(a, bbu);
+            EXPECT_EQ(b, abu);
+        }
+    }
+
+    TEST(svector, access)
+    {
+        svector_type a(10);
+        a[0] = size_t(1);
+        EXPECT_EQ(size_t(1), a[0]);
+        a[3] = size_t(3);
+        EXPECT_EQ(size_t(3), a[3]);
+        a[5] = size_t(2);
+        EXPECT_EQ(size_t(2), a[5]);
+
+        a.front() = size_t(0);
+        EXPECT_EQ(size_t(0), a[0]);
+
+        a.back() = size_t(1);
+        EXPECT_EQ(size_t(1), a[9]);
+
+        EXPECT_EQ(a.at(5), size_t(2));
+        XT_EXPECT_ANY_THROW(a.at(12));
+    }
+
+    TEST(svector, iterator)
+    {
+        svector_type a(10);
+        std::iota(a.begin(), a.end(), std::size_t(0));
+        for (size_t i = 0; i < a.size(); ++i)
+        {
+            EXPECT_EQ(i, a[i]);
+        }
+    }
+
+    TEST(fixed_shape, fixed_shape)
+    {
+        fixed_shape<3, 4, 5> af;
+        using cast_type = typename fixed_shape<3, 4, 5>::cast_type;
+        cast_type a = af;
+        EXPECT_EQ(a[0], size_t(3));
+        EXPECT_EQ(a[2], size_t(5));
+        EXPECT_EQ(a.back(), size_t(5));
+        EXPECT_EQ(a.front(), size_t(3));
+        EXPECT_EQ(a.size(), size_t(3));
+    }
 }
diff --git a/test/test_xstrided_view.cpp b/test/test_xstrided_view.cpp
index f4aad04e9..5b8f8c01d 100644
--- a/test/test_xstrided_view.cpp
+++ b/test/test_xstrided_view.cpp
@@ -1,20 +1,23 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xio.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xstrided_view.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xview.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/io/xio.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/views/xstrided_view.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -34,12 +37,12 @@ namespace xt
 
     TEST(xstrided_view, simple)
     {
-        view_shape_type shape = { 3, 4 };
+        view_shape_type shape = {3, 4};
         xarray<double> a(shape);
-        std::vector<double> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         std::copy(data.cbegin(), data.cend(), a.begin());
 
-        auto view1 = strided_view(a, xstrided_slice_vector({ 1, range(1, 4) }));
+        auto view1 = strided_view(a, xstrided_slice_vector({1, range(1, 4)}));
         EXPECT_EQ(a(1, 1), view1(0));
         EXPECT_EQ(a(1, 2), view1(1));
         EXPECT_EQ(size_t(1), view1.dimension());
@@ -47,95 +50,93 @@ namespace xt
         EXPECT_EQ(view1(1, 0), view1(0));
         EXPECT_EQ(view1.unchecked(0), view1(0));
 
-        auto view0 = strided_view(a, xstrided_slice_vector({ 0, range(0, 3) }));
+        auto view0 = strided_view(a, xstrided_slice_vector({0, range(0, 3)}));
         EXPECT_EQ(a(0, 0), view0(0));
         EXPECT_EQ(a(0, 1), view0(1));
         EXPECT_EQ(size_t(1), view0.dimension());
         EXPECT_EQ(size_t(3), view0.shape()[0]);
 
-        auto view2 = strided_view(a, xstrided_slice_vector({ range(0, 2), 2 }));
+        auto view2 = strided_view(a, xstrided_slice_vector({range(0, 2), 2}));
         EXPECT_EQ(a(0, 2), view2(0));
         EXPECT_EQ(a(1, 2), view2(1));
         EXPECT_EQ(size_t(1), view2.dimension());
         EXPECT_EQ(size_t(2), view2.shape()[0]);
 
-        auto view4 = strided_view(a, { 1 });
+        auto view4 = strided_view(a, {1});
         EXPECT_EQ(size_t(1), view4.dimension());
         EXPECT_EQ(size_t(4), view4.shape()[0]);
 
-        auto view5 = strided_view(view4, { 1 });
+        auto view5 = strided_view(view4, {1});
         EXPECT_EQ(size_t(0), view5.dimension());
         EXPECT_EQ(size_t(0), view5.shape().size());
 
-        auto view6 = strided_view(a, xstrided_slice_vector({ 1, all() }));
+        auto view6 = strided_view(a, xstrided_slice_vector({1, all()}));
         EXPECT_EQ(a(1, 0), view6(0));
         EXPECT_EQ(a(1, 1), view6(1));
         EXPECT_EQ(a(1, 2), view6(2));
         EXPECT_EQ(a(1, 3), view6(3));
 
-        auto view7 = strided_view(a, xstrided_slice_vector({ all(), 2 }));
+        auto view7 = strided_view(a, xstrided_slice_vector({all(), 2}));
         EXPECT_EQ(a(0, 2), view7(0));
         EXPECT_EQ(a(1, 2), view7(1));
         EXPECT_EQ(a(2, 2), view7(2));
 
-        EXPECT_THROW(strided_view(a, { all(), all(), 1 }), std::runtime_error);
-        EXPECT_THROW(strided_view(a, { all(), all(), all() }), std::runtime_error);
-        EXPECT_NO_THROW(strided_view(a, { all(), newaxis(), all() }));
-        EXPECT_NO_THROW(strided_view(a, { 3, newaxis(), 1 }));
-        EXPECT_NO_THROW(strided_view(a, { 3, 1, newaxis() }));
+        XT_EXPECT_THROW(strided_view(a, {all(), all(), 1}), std::runtime_error);
+        XT_EXPECT_THROW(strided_view(a, {all(), all(), all()}), std::runtime_error);
+        XT_EXPECT_NO_THROW(strided_view(a, {all(), newaxis(), all()}));
+        XT_EXPECT_NO_THROW(strided_view(a, {3, newaxis(), 1}));
+        XT_EXPECT_NO_THROW(strided_view(a, {3, 1, newaxis()}));
     }
 
     TEST(xstrided_view, assign)
     {
-        xt::xarray<double> arr = { 5., 6. };
-        xt::strided_view(arr, { 0 }) = xt::strided_view(arr, { 1 });
+        xt::xarray<double> arr = {5., 6.};
+        xt::strided_view(arr, {0}) = xt::strided_view(arr, {1});
+
+        auto v1 = xt::strided_view(arr, {0});
+        const bool res1 = xt::can_assign<decltype(v1), const xt::xarray<double>&>::value;
+        EXPECT_TRUE(res1);
+
+        const xt::xarray<double> arr2 = arr;
+        auto v2 = xt::strided_view(arr2, {0});
+        const bool res2 = xt::can_assign<decltype(v2), const xt::xarray<double>&>::value;
+        EXPECT_FALSE(res2);
     }
 
     TEST(xstrided_view, three_dimensional)
     {
-        view_shape_type shape = { 3, 4, 2 };
-        std::vector<double> data = {
-            1, 2,
-            3, 4,
-            5, 6,
-            7, 8,
+        view_shape_type shape = {3, 4, 2};
+        std::vector<double> data = {1,  2,  3,  4,  5,  6,   7,   8,
 
-            9, 10,
-            11, 12,
-            21, 22,
-            23, 24,
+                                    9,  10, 11, 12, 21, 22,  23,  24,
 
-            25, 26,
-            27, 28,
-            29, 210,
-            211, 212
-        };
+                                    25, 26, 27, 28, 29, 210, 211, 212};
 
         xarray<double> a(shape);
         std::copy(data.cbegin(), data.cend(), a.begin());
 
-        auto view1 = strided_view(a, { 1 });
+        auto view1 = strided_view(a, {1});
         EXPECT_EQ(size_t(2), view1.dimension());
-        view_shape_type expected_shape = { 4, 2 };
+        view_shape_type expected_shape = {4, 2};
         EXPECT_EQ(expected_shape, view1.shape());
         EXPECT_EQ(a(1, 0, 0), view1(0, 0));
         EXPECT_EQ(a(1, 0, 1), view1(0, 1));
         EXPECT_EQ(a(1, 1, 0), view1(1, 0));
         EXPECT_EQ(a(1, 1, 1), view1(1, 1));
 
-        std::array<std::size_t, 2> idx = { 1, 1 };
+        std::array<std::size_t, 2> idx = {1, 1};
         EXPECT_EQ(a(1, 1, 1), view1.element(idx.cbegin(), idx.cend()));
     }
 
     TEST(xstrided_view, iterator)
     {
-        view_shape_type shape = { 2, 3, 4 };
+        view_shape_type shape = {2, 3, 4};
         xarray<double> a(shape);
-        std::vector<double> data{ 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
-            13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 };
+        std::vector<double> data{1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
+                                 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
-        auto view1 = strided_view(a, xstrided_slice_vector({ range(0, 2), 1, range(1, 4) }));
+        auto view1 = strided_view(a, xstrided_slice_vector({range(0, 2), 1, range(1, 4)}));
         auto iter = view1.template begin<layout_type::row_major>();
         auto iter_end = view1.template end<layout_type::row_major>();
 
@@ -154,7 +155,7 @@ namespace xt
         EXPECT_EQ(iter, iter_end);
         EXPECT_FALSE(iter < iter_end);
 
-        auto view2 = strided_view(view1, xstrided_slice_vector({ range(0, 2), range(1, 3) }));
+        auto view2 = strided_view(view1, xstrided_slice_vector({range(0, 2), range(1, 3)}));
         auto iter2 = view2.template begin<layout_type::row_major>();
         auto iter_end2 = view2.template end<layout_type::row_major>();
 
@@ -172,26 +173,27 @@ namespace xt
 
     TEST(xstrided_view, fill)
     {
-        view_shape_type shape = { 2, 3, 4 };
+        view_shape_type shape = {2, 3, 4};
         xarray<double> a(shape), res(shape);
-        std::vector<double> data{ 1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
-            13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 };
+        std::vector<double> data{1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
+                                 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
-        std::vector<double> data_res = { 1, 2, 3, 4, 5, 4, 4, 4, 9, 10, 11, 12,
-            13, 14, 15, 16, 17, 4, 4, 4, 21, 22, 23, 24 };
+        std::vector<double> data_res = {1,  2,  3,  4,  5,  4, 4, 4, 9,  10, 11, 12,
+                                        13, 14, 15, 16, 17, 4, 4, 4, 21, 22, 23, 24};
         std::copy(data_res.cbegin(), data_res.cend(), res.template begin<layout_type::row_major>());
-        auto view1 = strided_view(a, xstrided_slice_vector({ range(0, 2), 1, range(1, 4) }));
+        auto view1 = strided_view(a, xstrided_slice_vector({range(0, 2), 1, range(1, 4)}));
         view1.fill(4);
         EXPECT_EQ(a, res);
     }
 
     TEST(xstrided_view, xstrided_view_on_xfunction)
     {
-        xarray<int> a = { { 1, 2, 3, 4 },{ 5, 6, 7, 8 },{ 9, 10, 11, 12 } };
-        xarray<int> b = { 1, 2, 3, 4 };
+        xarray<int> a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+        xarray<int> b = {1, 2, 3, 4};
 
         auto sum = a + b;
-        auto func = strided_view(sum, xstrided_slice_vector({ 1, range(1, 4) }));
+        auto func = strided_view(sum, xstrided_slice_vector({1, range(1, 4)}));
+
         auto iter = func.template begin<layout_type::row_major>();
         auto iter_end = func.template end<layout_type::row_major>();
 
@@ -206,17 +208,17 @@ namespace xt
 
     TEST(xstrided_view, view_on_generator)
     {
-        auto vgen = strided_view(eye(4), xstrided_slice_vector({ 1, range(1, 4) }));
+        auto vgen = strided_view(eye(4), xstrided_slice_vector({1, range(1, 4)}));
         auto iter = vgen.cbegin();
     }
 
     TEST(xstrided_view, xstrided_view_on_xtensor)
     {
-        xtensor<int, 2> a({ 3, 4 });
-        std::vector<int> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+        xtensor<int, 2> a({3, 4});
+        std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
-        auto view1 = strided_view(a, xstrided_slice_vector({ 1, range(1, 4) }));
+        auto view1 = strided_view(a, xstrided_slice_vector({1, range(1, 4)}));
         EXPECT_EQ(a(1, 1), view1(0));
         EXPECT_EQ(a(1, 2), view1(1));
         EXPECT_EQ(size_t(1), view1.dimension());
@@ -230,7 +232,7 @@ namespace xt
         ++iter;
         EXPECT_EQ(8, *iter);
 
-        xarray<int> b({ 3 }, 2);
+        xarray<int> b({3}, 2);
         xtensor<int, 1> res = view1 + b;
         EXPECT_EQ(8, res(0));
         EXPECT_EQ(9, res(1));
@@ -239,13 +241,13 @@ namespace xt
 
     TEST(xstrided_view, const_view)
     {
-        const xtensor<double, 3> arr{ { 1, 2, 3 }, 2.5 };
-        xtensor<double, 2> arr2{ { 2, 3 }, 0.0 };
-        xtensor<double, 2> ref{ { 2, 3 }, 2.5 };
-        arr2 = strided_view(arr, { 0 });
+        const xtensor<double, 3> arr{{1, 2, 3}, 2.5};
+        xtensor<double, 2> arr2{{2, 3}, 0.0};
+        xtensor<double, 2> ref{{2, 3}, 2.5};
+        arr2 = strided_view(arr, {0});
         EXPECT_EQ(ref, arr2);
         // check that the following compiles
-        auto v = strided_view(arr, { 0 });
+        auto v = strided_view(arr, {0});
         double acc = v(0);
         EXPECT_EQ(acc, 2.5);
         auto iter = v.begin();
@@ -253,12 +255,12 @@ namespace xt
 
     TEST(xstrided_view, newaxis)
     {
-        view_shape_type shape = { 3, 4 };
+        view_shape_type shape = {3, 4};
         xarray<double> a(shape);
-        std::vector<double> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         std::copy(data.cbegin(), data.cend(), a.begin());
 
-        auto view1 = strided_view(a, xstrided_slice_vector({ all(), newaxis(), all() }));
+        auto view1 = strided_view(a, xstrided_slice_vector({all(), newaxis(), all()}));
         EXPECT_EQ(a(1, 1), view1(1, 0, 1));
         EXPECT_EQ(a(1, 2), view1(1, 0, 2));
         EXPECT_EQ(size_t(3), view1.dimension());
@@ -268,7 +270,7 @@ namespace xt
         EXPECT_EQ(view1(0, 1), view1(0, 0, 1));
         EXPECT_EQ(view1(2, 1, 0, 1), view1(1, 0, 1));
 
-        auto view2 = strided_view(a, xstrided_slice_vector({ all(), all(), newaxis() }));
+        auto view2 = strided_view(a, xstrided_slice_vector({all(), all(), newaxis()}));
         EXPECT_EQ(a(1, 1), view2(1, 1, 0));
         EXPECT_EQ(a(1, 2), view2(1, 2, 0));
         EXPECT_EQ(size_t(3), view2.dimension());
@@ -276,41 +278,41 @@ namespace xt
         EXPECT_EQ(size_t(4), view2.shape()[1]);
         EXPECT_EQ(size_t(1), view2.shape()[2]);
 
-        auto view3 = strided_view(a, xstrided_slice_vector({ 1, newaxis(), all() }));
+        auto view3 = strided_view(a, xstrided_slice_vector({1, newaxis(), all()}));
         EXPECT_EQ(a(1, 1), view3(0, 1));
         EXPECT_EQ(a(1, 2), view3(0, 2));
         EXPECT_EQ(size_t(2), view3.dimension());
 
-        auto view4 = strided_view(a, xstrided_slice_vector({ 1, all(), newaxis() }));
+        auto view4 = strided_view(a, xstrided_slice_vector({1, all(), newaxis()}));
         EXPECT_EQ(a(1, 1), view4(1, 0));
         EXPECT_EQ(a(1, 2), view4(2, 0));
         EXPECT_EQ(size_t(2), view4.dimension());
 
-        auto view5 = strided_view(view1, { 1 });
+        auto view5 = strided_view(view1, {1});
         EXPECT_EQ(a(1, 1), view5(0, 1));
         EXPECT_EQ(a(1, 2), view5(0, 2));
         EXPECT_EQ(size_t(2), view5.dimension());
 
-        auto view6 = strided_view(view2, { 1 });
+        auto view6 = strided_view(view2, {1});
         EXPECT_EQ(a(1, 1), view6(1, 0));
         EXPECT_EQ(a(1, 2), view6(2, 0));
         EXPECT_EQ(size_t(2), view6.dimension());
 
-        std::array<std::size_t, 3> idx1 = { 1, 0, 2 };
+        std::array<std::size_t, 3> idx1 = {1, 0, 2};
         EXPECT_EQ(a(1, 2), view1.element(idx1.begin(), idx1.end()));
 
-        std::array<std::size_t, 3> idx2 = { 1, 2, 0 };
+        std::array<std::size_t, 3> idx2 = {1, 2, 0};
         EXPECT_EQ(a(1, 2), view2.element(idx2.begin(), idx2.end()));
     }
 
     TEST(xstrided_view, newaxis_iterating)
     {
-        view_shape_type shape = { 3, 4 };
+        view_shape_type shape = {3, 4};
         xarray<double> a(shape);
-        std::vector<double> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
-        auto view1 = strided_view(a, xstrided_slice_vector({ all(), all(), newaxis() }));
+        auto view1 = strided_view(a, xstrided_slice_vector({all(), all(), newaxis()}));
         auto iter1 = view1.template begin<layout_type::row_major>();
         auto iter1_end = view1.template end<layout_type::row_major>();
 
@@ -340,7 +342,7 @@ namespace xt
         ++iter1;
         EXPECT_EQ(iter1_end, iter1);
 
-        auto view2 = strided_view(a, xstrided_slice_vector({ all(), newaxis(), all() }));
+        auto view2 = strided_view(a, xstrided_slice_vector({all(), newaxis(), all()}));
         auto iter2 = view2.template begin<layout_type::row_major>();
         auto iter2_end = view2.template end<layout_type::row_major>();
 
@@ -373,9 +375,9 @@ namespace xt
 
     TEST(xstrided_view, newaxis_function)
     {
-        view_shape_type shape = { 3, 4 };
+        view_shape_type shape = {3, 4};
         xarray<double> a(shape);
-        std::vector<double> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
         xarray<double> b(view_shape_type(1, 4));
@@ -383,10 +385,10 @@ namespace xt
         data_end += 4;
         std::copy(data.cbegin(), data_end, b.template begin<layout_type::row_major>());
 
-        auto v = strided_view(b, xstrided_slice_vector({ newaxis(), all() }));
+        auto v = strided_view(b, xstrided_slice_vector({newaxis(), all()}));
         xarray<double> res = a + v;
 
-        std::vector<double> data2{ 2, 4, 6, 8, 6, 8, 10, 12, 10, 12, 14, 16 };
+        std::vector<double> data2{2, 4, 6, 8, 6, 8, 10, 12, 10, 12, 14, 16};
         xarray<double> expected(shape);
         std::copy(data2.cbegin(), data2.cend(), expected.template begin<layout_type::row_major>());
 
@@ -397,56 +399,56 @@ namespace xt
     {
         using namespace xt::placeholders;
         using t = xarray<int>;
-        t a = { 1, 2, 3, 4, 5 };
+        t a = {1, 2, 3, 4, 5};
 
         auto n = xnone();
 
-        auto v1 = strided_view(a, xstrided_slice_vector({ range(3, _) }));
-        t v1e = { 4, 5 };
+        auto v1 = strided_view(a, xstrided_slice_vector({range(3, _)}));
+        t v1e = {4, 5};
         EXPECT_TRUE(v1e == v1);
 
-        auto v2 = strided_view(a, xstrided_slice_vector({ range(_, 2) }));
-        t v2e = { 1, 2 };
+        auto v2 = strided_view(a, xstrided_slice_vector({range(_, 2)}));
+        t v2e = {1, 2};
         EXPECT_TRUE(v2e == v2);
 
-        auto v3 = strided_view(a, xstrided_slice_vector({ range(n, n) }));
-        t v3e = { 1, 2, 3, 4, 5 };
+        auto v3 = strided_view(a, xstrided_slice_vector({range(n, n)}));
+        t v3e = {1, 2, 3, 4, 5};
         EXPECT_TRUE(v3e == v3);
 
-        auto v4 = strided_view(a, xstrided_slice_vector({ range(n, 2, -1) }));
-        t v4e = { 5, 4 };
+        auto v4 = strided_view(a, xstrided_slice_vector({range(n, 2, -1)}));
+        t v4e = {5, 4};
         EXPECT_TRUE(v4e == v4);
 
-        auto v5 = strided_view(a, xstrided_slice_vector({ range(2, n, -1) }));
-        t v5e = { 3, 2, 1 };
+        auto v5 = strided_view(a, xstrided_slice_vector({range(2, n, -1)}));
+        t v5e = {3, 2, 1};
         EXPECT_TRUE(v5e == v5);
 
-        auto v6 = strided_view(a, xstrided_slice_vector({ range(n, n, n) }));
-        t v6e = { 1, 2, 3, 4, 5 };
+        auto v6 = strided_view(a, xstrided_slice_vector({range(n, n, n)}));
+        t v6e = {1, 2, 3, 4, 5};
         EXPECT_TRUE(v6e == v6);
 
-        auto v7 = strided_view(a, xstrided_slice_vector({ range(1, n, 2) }));
-        t v7e = { 2, 4 };
+        auto v7 = strided_view(a, xstrided_slice_vector({range(1, n, 2)}));
+        t v7e = {2, 4};
         EXPECT_TRUE(v7e == v7);
 
-        auto v8 = strided_view(a, xstrided_slice_vector({ range(2, n, 2) }));
-        t v8e = { 3, 5 };
+        auto v8 = strided_view(a, xstrided_slice_vector({range(2, n, 2)}));
+        t v8e = {3, 5};
         EXPECT_TRUE(v8e == v8);
     }
 
     TEST(xstrided_view, extended_assign)
     {
         using t = xarray<int>;
-        t a = { 1, 2, 3, 4, 5 };
+        t a = {1, 2, 3, 4, 5};
 
-        auto v = strided_view(a, xstrided_slice_vector({ range(0, 2) }));
+        auto v = strided_view(a, xstrided_slice_vector({range(0, 2)}));
         v = 1000;
         EXPECT_EQ(v(0), 1000);
         EXPECT_EQ(a(0), 1000);
         EXPECT_EQ(a(1), 1000);
 
-        auto v2 = strided_view(a, xstrided_slice_vector({ range(3, 5) }));
-        t b = { -100, -100 };
+        auto v2 = strided_view(a, xstrided_slice_vector({range(3, 5)}));
+        t b = {-100, -100};
         v2 = b;
         EXPECT_EQ(v2(1), -100);
         EXPECT_EQ(a(4), -100);
@@ -455,65 +457,81 @@ namespace xt
     TEST(xstrided_view, ellipsis)
     {
         using t = xarray<int>;
-        auto a = t::from_shape({ 5, 5, 1, 1, 1, 4 });
+        auto a = t::from_shape({5, 5, 1, 1, 1, 4});
         std::iota(a.begin(), a.end(), 0);
 
-        auto v1 = strided_view(a, { 1, 1, xt::ellipsis() });
-        dynamic_shape<std::size_t> v1_s{ 1, 1, 1, 4 };
+        auto v1 = strided_view(a, {1, 1, xt::ellipsis()});
+        dynamic_shape<std::size_t> v1_s{1, 1, 1, 4};
         EXPECT_EQ(v1.shape(), v1_s);
 
-        EXPECT_EQ(strided_view(a, { 2, 2, xt::ellipsis() }), strided_view(a, { 2, 2, xt::all(), xt::all(), xt::all(), xt::all() }));
-        EXPECT_EQ(strided_view(a, { 2, xt::ellipsis(), 0, 2 }), strided_view(a, { 2, xt::all(), xt::all(), xt::all(), 0, 2 }));
+        EXPECT_EQ(
+            strided_view(a, {2, 2, xt::ellipsis()}),
+            strided_view(a, {2, 2, xt::all(), xt::all(), xt::all(), xt::all()})
+        );
+        EXPECT_EQ(
+            strided_view(a, {2, xt::ellipsis(), 0, 2}),
+            strided_view(a, {2, xt::all(), xt::all(), xt::all(), 0, 2})
+        );
 
-        EXPECT_THROW(strided_view(a, { xt::ellipsis(), 0, xt::ellipsis() }), std::runtime_error);
+        XT_EXPECT_THROW(strided_view(a, {xt::ellipsis(), 0, xt::ellipsis()}), std::runtime_error);
 
-        t b = xt::ones<int>({ 5, 5, 5 });
-        auto v2 = strided_view(b, { xt::ellipsis(), 1, 1, 1 });
+        t b = xt::ones<int>({5, 5, 5});
+        auto v2 = strided_view(b, {xt::ellipsis(), 1, 1, 1});
         EXPECT_EQ(v2(), 1);
         EXPECT_EQ(v2.shape().size(), size_t(0));
 
-        auto v3 = strided_view(b, { xt::ellipsis(), 1, xt::all(), 1 });
-        dynamic_shape<std::size_t> v3_s{ 5 };
+        auto v3 = strided_view(b, {xt::ellipsis(), 1, xt::all(), 1});
+        dynamic_shape<std::size_t> v3_s{5};
         EXPECT_EQ(v3.shape(), v3_s);
 
 
-        EXPECT_THROW(strided_view(b, { xt::ellipsis(), 1, 1, 1, 1 }), std::runtime_error);
+        XT_EXPECT_THROW(strided_view(b, {xt::ellipsis(), 1, 1, 1, 1}), std::runtime_error);
     }
 
     TEST(xstrided_view, incompatible_shape)
     {
-        xarray<int> a = xarray<int>::from_shape({ 4, 3, 2 });
-        xarray<int> b = xarray<int>::from_shape({ 2, 3, 4 });
+        xarray<int> a = xarray<int>::from_shape({4, 3, 2});
+        xarray<int> b = xarray<int>::from_shape({2, 3, 4});
         xstrided_slice_vector sv;
         sv.push_back(all());
         auto v = strided_view(a, sv);
 
         EXPECT_FALSE(broadcastable(v.shape(), b.shape()));
         EXPECT_FALSE(broadcastable(b.shape(), v.shape()));
-        EXPECT_THROW(assert_compatible_shape(b, v), broadcast_error);
-        EXPECT_THROW(assert_compatible_shape(v, b), broadcast_error);
-        EXPECT_THROW(v = b, broadcast_error);
-        EXPECT_THROW(noalias(v) = b, broadcast_error);
+        XT_EXPECT_THROW(assert_compatible_shape(b, v), broadcast_error);
+        XT_EXPECT_THROW(assert_compatible_shape(v, b), broadcast_error);
+        XT_EXPECT_THROW(v = b, broadcast_error);
+        XT_EXPECT_THROW(noalias(v) = b, broadcast_error);
     }
 
-    TEST(xstrided_view, view_on_view)
+    TEST(xstrided_view, strided_view_on_view)
     {
-        xarray<int> a = xt::ones<int>({ 3, 4, 5 });
-        auto v1 = strided_view(a, { 1, all(), all() });
-        auto vv1 = strided_view(v1, { 1, all() });
+        xarray<int> a = xt::ones<int>({3, 4, 5});
+        auto v1 = view(a, 1, all(), all());
+        auto vv1 = strided_view(v1, {1, all()});
         vv1 = vv1 * 5;
         EXPECT_EQ(a(0, 0, 0), 1);
         EXPECT_EQ(a(1, 1, 0), 5);
         EXPECT_EQ(a(1, 1, 4), 5);
         EXPECT_EQ(a(1, 2, 4), 1);
         EXPECT_EQ(v1(1, 4), 5);
+    }
 
-        bool st = std::is_same<decltype(v1), decltype(vv1)>::value;
-        EXPECT_TRUE(st);
+    TEST(xstrided_view, strided_view_on_strided_view)
+    {
+        xarray<int> a = xt::ones<int>({3, 4, 5});
+        auto v1 = strided_view(a, {1, all(), all()});
+        auto vv1 = strided_view(v1, {1, all()});
+        vv1 = vv1 * 5;
+        EXPECT_EQ(a(0, 0, 0), 1);
+        EXPECT_EQ(a(1, 1, 0), 5);
+        EXPECT_EQ(a(1, 1, 4), 5);
+        EXPECT_EQ(a(1, 2, 4), 1);
+        EXPECT_EQ(v1(1, 4), 5);
 
-        a = xt::ones<int>({ 3, 4, 5 });
-        auto v2 = strided_view(a, { all(), 1, all() });
-        auto vv2 = strided_view(v2, { all(), 2 });
+        a = xt::ones<int>({3, 4, 5});
+        auto v2 = strided_view(a, {all(), 1, all()});
+        auto vv2 = strided_view(v2, {all(), 2});
         vv2 = vv2 * 5;
         EXPECT_EQ(a(0, 0, 0), 1);
         EXPECT_EQ(a(1, 1, 2), 5);
@@ -526,74 +544,76 @@ namespace xt
     TEST(xstrided_view, range_integer_casting)
     {
         // just check compilation
-        auto arr = xarray<int>::from_shape({ 3, 4, 5 });
-        auto a = strided_view(arr, { range(0, std::ptrdiff_t(2)), 323 });
-        auto b = strided_view(arr, { range(std::size_t(0), 2), 323 });
+        auto arr = xarray<int>::from_shape({3, 4, 5});
+        auto a = strided_view(arr, {range(0, std::ptrdiff_t(2)), 323});
+        auto b = strided_view(arr, {range(std::size_t(0), 2), 323});
     }
 
     TEST(xstrided_view, strides)
     {
         // Strides: 72/24/6/1
-        xarray<int, layout_type::row_major> a = xarray<int, layout_type::row_major>::from_shape({ 5, 3, 4, 6 });
+        xarray<int, layout_type::row_major> a = xarray<int, layout_type::row_major>::from_shape({5, 3, 4, 6});
 
-        auto s1 = strided_view(a, { 1, 1, xt::all(), xt::all() }).strides();
-        std::vector<std::size_t> s1e = { 6, 1 };
+        auto s1 = strided_view(a, {1, 1, xt::all(), xt::all()}).strides();
+        std::vector<std::size_t> s1e = {6, 1};
         EXPECT_EQ(s1, s1e);
 
-        auto s2 = strided_view(a, { 1, xt::all(), xt::all(), 1 }).strides();
-        std::vector<std::size_t> s2e = { 24, 6 };
+        auto s2 = strided_view(a, {1, xt::all(), xt::all(), 1}).strides();
+        std::vector<std::size_t> s2e = {24, 6};
         EXPECT_EQ(s2, s2e);
 
-        auto s3 = strided_view(a, { 1, xt::all(), 1, xt::newaxis(), xt::newaxis(), xt::all() }).strides();
-        std::vector<std::size_t> s3e = { 24, 0, 0, 1 };
+        auto s3 = strided_view(a, {1, xt::all(), 1, xt::newaxis(), xt::newaxis(), xt::all()}).strides();
+        std::vector<std::size_t> s3e = {24, 0, 0, 1};
         EXPECT_EQ(s3, s3e);
 
-        auto s4 = strided_view(a, { xt::range(0, 1, 2), 1, 0, xt::all(), xt::newaxis() }).strides();
-        std::vector<std::size_t> s4e = { 0, 1, 0 };
+        auto s4 = strided_view(a, {xt::range(0, 1, 2), 1, 0, xt::all(), xt::newaxis()}).strides();
+        std::vector<std::size_t> s4e = {0, 1, 0};
         EXPECT_EQ(s4, s4e);
 
-        auto s4x = strided_view(a, { xt::range(0, 5, 2), 1, 0, xt::all(), xt::newaxis() }).strides();
-        std::vector<std::size_t> s4xe = { 72 * 2, 1, 0 };
+        auto s4x = strided_view(a, {xt::range(0, 5, 2), 1, 0, xt::all(), xt::newaxis()}).strides();
+        std::vector<std::size_t> s4xe = {72 * 2, 1, 0};
         EXPECT_EQ(s4x, s4xe);
 
-        auto s5 = strided_view(a, { xt::all(), 1 }).strides();
-        std::vector<std::size_t> s5e = { 72, 6, 1 };
+        auto s5 = strided_view(a, {xt::all(), 1}).strides();
+        std::vector<std::size_t> s5e = {72, 6, 1};
         EXPECT_EQ(s5, s5e);
 
-        auto s6 = strided_view(a, { xt::all(), 1, 1, xt::newaxis(), xt::all() }).strides();
-        std::vector<std::size_t> s6e = { 72, 0, 1 };
+        auto s6 = strided_view(a, {xt::all(), 1, 1, xt::newaxis(), xt::all()}).strides();
+        std::vector<std::size_t> s6e = {72, 0, 1};
         EXPECT_EQ(s6, s6e);
 
-        auto s7 = strided_view(a, { xt::all(), 1, xt::newaxis(), xt::all() }).strides();
-        std::vector<std::size_t> s7e = { 72, 0, 6, 1 };
+        auto s7 = strided_view(a, {xt::all(), 1, xt::newaxis(), xt::all()}).strides();
+        std::vector<std::size_t> s7e = {72, 0, 6, 1};
         EXPECT_EQ(s7, s7e);
     }
 
     TEST(xstrided_view, layout)
     {
-        xarray<int, layout_type::row_major> a = xarray<int, layout_type::row_major>::from_shape({ 5, 3, 4, 6 });
+        xarray<int, layout_type::row_major> a = xarray<int, layout_type::row_major>::from_shape({5, 3, 4, 6});
 
-        auto s1 = strided_view(a, { xt::all(), 1, xt::newaxis(), xt::all() }).layout();
+        auto s1 = strided_view(a, {xt::all(), 1, xt::newaxis(), xt::all()}).layout();
         EXPECT_EQ(s1, layout_type::dynamic);
 
-        auto s1x = strided_view(a, { 1, xt::all(), xt::newaxis(), xt::all() }).layout();
+        auto s1x = strided_view(a, {1, xt::all(), xt::newaxis(), xt::all()}).layout();
         EXPECT_EQ(s1x, layout_type::row_major);
 
-        auto s2 = strided_view(a, { 1, 2, range(0, 3), xt::all() }).layout();
+        auto s2 = strided_view(a, {1, 2, range(0, 3), xt::all()}).layout();
         EXPECT_EQ(s2, layout_type::row_major);
 
-        auto s3 = strided_view(a, { 1 }).layout();
+        auto s3 = strided_view(a, {1}).layout();
         EXPECT_EQ(s3, layout_type::row_major);
 
-        xarray<int, layout_type::column_major> b = xarray<int, layout_type::column_major>::from_shape({ 5, 3, 4, 6 });
+        xarray<int, layout_type::column_major> b = xarray<int, layout_type::column_major>::from_shape(
+            {5, 3, 4, 6}
+        );
 
-        auto s4 = strided_view(b, { 1 }).layout();
+        auto s4 = strided_view(b, {1}).layout();
         EXPECT_EQ(s4, layout_type::dynamic);
 
-        auto s5 = strided_view(b, { xt::all(), 1, 1, 1 }).layout();
+        auto s5 = strided_view(b, {xt::all(), 1, 1, 1}).layout();
         EXPECT_EQ(s5, layout_type::column_major);
 
-        auto s6 = strided_view(b, { xt::all(), 1, 1, xt::range(0, 6) }).layout();
+        auto s6 = strided_view(b, {xt::all(), 1, 1, xt::range(0, 6)}).layout();
         EXPECT_EQ(s6, layout_type::dynamic);
     }
 
@@ -616,7 +636,7 @@ namespace xt
         view_shape_type shape = {2, 3, 4};
         xarray<double, layout_type::row_major> a(shape);
         std::vector<double> data = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
-            13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
+                                    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
         auto view1 = strided_view(a, {range(0, 2), 1, range(1, 4)});
@@ -655,47 +675,66 @@ namespace xt
     TEST(xstrided_view, reshape_view)
     {
         xarray<double> a = xt::arange<double>(9);
-        auto av = xt::reshape_view(a, {3, 3});
-        auto xv = xt::reshape_view(a, xshape<3, 3>());
+        auto av = xt::reshape_view<XTENSOR_DEFAULT_LAYOUT>(a, {3, 3});
+        auto xv = xt::reshape_view<XTENSOR_DEFAULT_LAYOUT>(a, xshape<3, 3>());
 
-
-        xtensor<double, 2> e = xt::reshape_view(xt::arange(9), {3, 3});
-        xtensor<double, 2> es = xt::reshape_view(a, {3, 3});
+        xtensor<double, 2> e = xt::reshape_view<XTENSOR_DEFAULT_LAYOUT>(xt::arange(9), {3, 3});
+        xtensor<double, 2> es = xt::reshape_view<XTENSOR_DEFAULT_LAYOUT>(a, {3, 3});
 
         a.reshape({3, 3});
         for (std::size_t i = 0; i < 100; ++i)
         {
-            xtensor<double, 2> par = xt::reshape_view(xt::arange(9), {3, 3});
+            xtensor<double, 2> par = xt::reshape_view<XTENSOR_DEFAULT_LAYOUT>(xt::arange(9), {3, 3});
             EXPECT_EQ(a, par);
         }
-
         using assign_traits = xassign_traits<xarray<double>, decltype(av)>;
 
 #if XTENSOR_USE_XSIMD
-        EXPECT_TRUE(assign_traits::convertible_types());
-        EXPECT_TRUE(assign_traits::simd_size());
-        EXPECT_TRUE(assign_traits::forbid_simd());
-        EXPECT_FALSE(assign_traits::simd_assign());
+        EXPECT_TRUE(assign_traits::simd_linear_assign());
 #endif
 
         EXPECT_EQ(av, e);
         EXPECT_EQ(av, a);
 
-        bool truthy;
-        truthy = std::is_same<typename decltype(xv)::temporary_type, xtensor_fixed<double, xshape<3, 3>>>();
-        EXPECT_TRUE(truthy);
+        static_assert(
+            std::is_same<
+                typename decltype(xv)::temporary_type,
+                xtensor_fixed<double, xshape<3, 3>, XTENSOR_DEFAULT_LAYOUT>>::value,
+            "Container types do not match"
+        );
+        static_assert(
+            std::is_same<typename decltype(av)::temporary_type, xtensor<double, 2, XTENSOR_DEFAULT_LAYOUT>>::value,
+            "Container types do not match"
+        );
+        static_assert(
+            std::is_same<typename decltype(av)::shape_type, typename decltype(e)::shape_type>::value,
+            "Shape types do not match"
+        );
+
+        xarray<int> xa = {{1, 2, 3}, {4, 5, 6}};
+        std::vector<std::size_t> new_shape = {3, 2};
+        auto xrv = reshape_view(xa, new_shape);
+
+        xarray<int> xres = {{1, 2}, {3, 4}, {5, 6}};
+        EXPECT_EQ(xrv, xres);
+
+        auto nv = xt::reshape_view<XTENSOR_DEFAULT_LAYOUT>(a, {-1, 3});
+        std::vector<size_t> expected_shape({3, 3});
+        EXPECT_TRUE(std::equal(nv.shape().begin(), nv.shape().end(), expected_shape.begin()));
+    }
 
-    #if !defined(X_OLD_CLANG)
-        truthy = std::is_same<typename decltype(av)::temporary_type, xtensor<double, 2>>();
-        EXPECT_TRUE(truthy);
-        truthy = std::is_same<typename decltype(av)::shape_type, typename decltype(e)::shape_type>::value;
-        EXPECT_TRUE(truthy);
-    #endif
+    TEST(xstrided_view, reshape_view_assign)
+    {
+        xarray<int, layout_type::column_major> xa = {{1, 2, 3}, {4, 5, 6}};
+        xarray<int, layout_type::column_major> exp = {{1, 2}, {3, 4}, {5, 6}};
+        auto v = reshape_view(xa, {3, 2});
+        xarray<int, layout_type::column_major> res = v;
+        EXPECT_EQ(res, exp);
     }
 
     TEST(xstrided_view, on_xview)
     {
-        xarray<double> a = {0,1,2,3,4,5,6,7,8};
+        xarray<double> a = {0, 1, 2, 3, 4, 5, 6, 7, 8};
         auto v = view(a, keep(3, 5, 6));
         auto v2 = strided_view(v, {2});
         EXPECT_EQ(v2(0), 6);
@@ -703,4 +742,195 @@ namespace xt
         EXPECT_EQ(v3(0), 3);
         EXPECT_EQ(v3(1), 5);
     }
+
+    TEST(xstrided_view, on_xbroadcast)
+    {
+        xarray<double, layout_type::column_major> a = {{0.0, 1.0, 2.0}, {10.0, 11.0, 12.0}};
+
+        auto b = broadcast(a, {2, 3});
+        auto v = strided_view(b, {0});
+        EXPECT_EQ(v(0), 0.0);
+        EXPECT_EQ(v(1), 1.0);
+        EXPECT_EQ(v(2), 2.0);
+    }
+
+    TEST(xstrided_view, on_broadcasted_scalar)
+    {
+        xarray<double> expected = {1, 1, 1, 1, 1, 1, 1, 1};
+        xarray<double> a = xt::squeeze(xt::ones<double>({8, 1}));
+        EXPECT_EQ(a, expected);
+    }
+
+    TEST(xstrided_view, on_transpose)
+    {
+        xt::xarray<double> arr{{0.0, 1.0, 2.0}, {10.0, 11.0, 12.0}};
+
+        auto t = xt::transpose(arr + arr);
+        auto v = xt::strided_view(t, {0});
+        EXPECT_EQ(v(0), 0.0);
+        EXPECT_EQ(v(1), 20.0);
+    }
+
+    TEST(xstrided_view, reshape_strided)
+    {
+        xtensor<int, 2> a = {{1, 2, 3, 4, 5, 6, 7, 8}, {11, 12, 13, 14, 15, 16, 17, 18}};
+
+        auto v1 = view(a, all(), range(0, 4));
+        auto rv1 = reshape_view(v1, {2, 2, 2});
+        xtensor<int, 3> expected = {{{1, 2}, {3, 4}}, {{11, 12}, {13, 14}}};
+        EXPECT_EQ(expected, rv1);
+
+        auto rv2 = reshape_view(a, {2, 2, 4});
+        auto v2 = strided_view(rv2, {0, 0, all()});
+        xtensor<int, 1> expected2 = {1, 2, 3, 4};
+        EXPECT_EQ(expected2, v2);
+    }
+
+    TEST(xstrided_view, zerod_view_iterator)
+    {
+        xt::xarray<int> a{{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}};
+        xt::xstrided_slice_vector sl = {1, 0, 1};
+
+        auto vi = xt::strided_view(a, sl);
+        auto it0 = vi.cbegin<layout_type::row_major>();
+        auto it1 = it0 + 0;
+        EXPECT_EQ(*it0, *it1);
+
+        auto it2 = vi.cbegin<layout_type::column_major>();
+        auto it3 = it2 + 0;
+        EXPECT_EQ(*it2, *it3);
+    }
+
+    TEST(xstrided_view, view_on_const)
+    {
+        const xtensor<int, 1> a = {1, 2, 3, 4};
+        auto v = strided_view(a, {all()});
+        auto d = v.data();
+        EXPECT_TRUE((std::is_same<decltype(d), const int*>::value));
+        EXPECT_EQ(d[0], 1);
+    }
+
+    namespace test
+    {
+        template <class E1, class E2>
+        void check_reshaped_1d(const E1& e1, const E2& e2)
+        {
+            EXPECT_EQ(e1(0, 0), e2(0, 0));
+            EXPECT_EQ(e1(0, 1), e2(0, 1));
+            EXPECT_EQ(e1(1, 0), e2(1, 0));
+            EXPECT_EQ(e1(1, 1), e2(1, 1));
+            EXPECT_EQ(e1(2, 0), e2(2, 0));
+            EXPECT_EQ(e1(2, 1), e2(2, 1));
+
+            auto iter1 = e1.template cbegin<layout_type::row_major>();
+            auto iter2 = e2.template cbegin<layout_type::row_major>();
+            EXPECT_EQ(*iter1, e1(0, 0));
+            EXPECT_EQ(*iter1++, *iter2++);
+            EXPECT_EQ(*iter1, e1(0, 1));
+            EXPECT_EQ(*iter1++, *iter2++);
+            EXPECT_EQ(*iter1, e1(1, 0));
+            EXPECT_EQ(*iter1++, *iter2++);
+            EXPECT_EQ(*iter1, e1(1, 1));
+            EXPECT_EQ(*iter1++, *iter2++);
+            EXPECT_EQ(*iter1, e1(2, 0));
+            EXPECT_EQ(*iter1++, *iter2++);
+            EXPECT_EQ(*iter1, e1(2, 1));
+            EXPECT_EQ(*iter1++, *iter2++);
+            EXPECT_EQ(iter1, e1.template cend<layout_type::row_major>());
+            EXPECT_EQ(iter2, e2.template cend<layout_type::row_major>());
+        }
+
+        template <class E1, class E2>
+        void check_reshaped_2d_rm(const E1& e1, const E2& e2)
+        {
+            check_reshaped_1d(e1, e2);
+            EXPECT_EQ(e1(0, 0), 1);
+            EXPECT_EQ(e1(0, 1), 2);
+            EXPECT_EQ(e1(1, 0), 3);
+            EXPECT_EQ(e1(1, 1), 4);
+            EXPECT_EQ(e1(2, 0), 5);
+            EXPECT_EQ(e1(2, 1), 6);
+        }
+
+        template <class E1, class E2>
+        void check_reshaped_2d_cm(const E1& e1, const E2& e2)
+        {
+            check_reshaped_1d(e1, e2);
+            EXPECT_EQ(e1(0, 0), 1);
+            EXPECT_EQ(e1(0, 1), 5);
+            EXPECT_EQ(e1(1, 0), 4);
+            EXPECT_EQ(e1(1, 1), 3);
+            EXPECT_EQ(e1(2, 0), 2);
+            EXPECT_EQ(e1(2, 1), 6);
+        }
+    }
+
+    TEST(xstrided_view, reshape_view_1d)
+    {
+        xarray<int> a = {1, 2, 3, 4, 5, 6};
+
+        auto var = reshape_view<layout_type::row_major>(a, {3, 2});
+        xarray<int> rvar = var;
+        test::check_reshaped_1d(rvar, var);
+        EXPECT_EQ(rvar(0, 0), 1);
+        EXPECT_EQ(rvar(0, 1), 2);
+        EXPECT_EQ(rvar(1, 0), 3);
+        EXPECT_EQ(rvar(1, 1), 4);
+        EXPECT_EQ(rvar(2, 0), 5);
+        EXPECT_EQ(rvar(2, 1), 6);
+
+        auto vac = reshape_view<layout_type::column_major>(a, {3, 2});
+        xarray<int> rvac = vac;
+        test::check_reshaped_1d(rvac, vac);
+        EXPECT_EQ(rvac(0, 0), 1);
+        EXPECT_EQ(rvac(0, 1), 4);
+        EXPECT_EQ(rvac(1, 0), 2);
+        EXPECT_EQ(rvac(1, 1), 5);
+        EXPECT_EQ(rvac(2, 0), 3);
+        EXPECT_EQ(rvac(2, 1), 6);
+    }
+
+    TEST(xstrided_view, reshape_view_2d)
+    {
+        xarray<int, layout_type::row_major> ra = {{1, 2, 3}, {4, 5, 6}};
+
+        auto vrar = reshape_view<layout_type::row_major>(ra, {3, 2});
+        xarray<int> rvrar = vrar;
+        test::check_reshaped_2d_rm(rvrar, vrar);
+
+        auto vrac = reshape_view<layout_type::column_major>(ra, {3, 2});
+        xarray<int> rvrac = vrac;
+        test::check_reshaped_2d_cm(rvrac, vrac);
+
+        xarray<int, layout_type::column_major> ca = {{1, 2, 3}, {4, 5, 6}};
+
+        auto vcar = reshape_view<layout_type::row_major>(ca, {3, 2});
+        xarray<int> rvcar = vcar;
+        test::check_reshaped_2d_rm(rvcar, vcar);
+
+        auto vcac = reshape_view<layout_type::column_major>(ca, {3, 2});
+        xarray<int> rvcac = vcac;
+        test::check_reshaped_2d_cm(rvcac, vcac);
+    }
+
+    TEST(xstrided_view, flatten)
+    {
+        xt::xarray<int> x = {{1, 2, 3}, {4, 5, 6}};
+        auto x_view = xt::strided_view(x, {xt::range(0, 1), xt::range(0, 1)});
+        auto x_flat = xt::flatten<xt::layout_type::column_major>(x_view);
+        x_flat = 10;
+        xt::xarray<int> exp = {{10, 2, 3}, {4, 5, 6}};
+        EXPECT_EQ(x, exp);
+
+        auto x_view2 = xt::strided_view(x, {xt::range(0, 1), xt::range(0, 2)});
+        auto x_flat2 = xt::flatten<xt::layout_type::column_major>(x_view2);
+        x_flat2 = 15;
+        xt::xarray<int> exp2 = {{15, 15, 3}, {4, 5, 6}};
+        EXPECT_EQ(x, exp2);
+
+        xt::xarray<int> b = {20, 25};
+        x_flat2 = b;
+        xt::xarray<int> exp3 = {{20, 25, 3}, {4, 5, 6}};
+        EXPECT_EQ(x, exp3);
+    }
 }
diff --git a/test/test_xstrides.cpp b/test/test_xstrides.cpp
index 78b2dd6f2..1ac41823c 100644
--- a/test/test_xstrides.cpp
+++ b/test/test_xstrides.cpp
@@ -1,44 +1,169 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xarray.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
+    TEST(xstrides, broadcast_shape)
+    {
+        using shape_type = std::vector<std::size_t>;
+        shape_type s1 = {2, 4, 3};
+        shape_type s2 = {2, 1, 3};
+        shape_type s3 = {2, 0, 3};
+        shape_type s4 = uninitialized_shape<shape_type>(3);
+
+        shape_type s5 = s2;
+        bool t1 = broadcast_shape(s1, s5);
+        EXPECT_EQ(s5, s1);
+        EXPECT_FALSE(t1);
+
+        shape_type s6 = s2;
+        bool t2 = broadcast_shape(s3, s6);
+        EXPECT_EQ(s6, s3);
+        EXPECT_FALSE(t2);
+
+        shape_type s7 = s3;
+        XT_EXPECT_ANY_THROW(broadcast_shape(s1, s7));
+
+        shape_type s8 = s4;
+        bool t3 = broadcast_shape(s1, s8);
+        EXPECT_EQ(s8, s1);
+        EXPECT_TRUE(t3);
+
+        shape_type s9 = s4;
+        bool t4 = broadcast_shape(s2, s9);
+        EXPECT_EQ(s9, s2);
+        EXPECT_TRUE(t4);
+
+        shape_type s10 = s4;
+        bool t5 = broadcast_shape(s3, s10);
+        EXPECT_EQ(s10, s3);
+        EXPECT_TRUE(t5);
+    }
+
+    TEST(xstrides, free_function_2d_row_major)
+    {
+        xt::xarray<int, xt::layout_type::row_major> a = xt::ones<int>({1, 3});
+        using stype = std::vector<std::ptrdiff_t>;
+        std::ptrdiff_t sof = sizeof(int);
+
+        EXPECT_EQ(xt::strides(a), stype({3, 1}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::normal), stype({3, 1}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::internal), stype({0, 1}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::bytes), stype({3 * sof, sof}));
+
+        EXPECT_TRUE(xt::strides(a, 0) == 3);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::normal) == 3);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::internal) == 0);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::bytes) == 3 * sof);
+
+        EXPECT_TRUE(xt::strides(a, 1) == 1);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::normal) == 1);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::internal) == 1);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::bytes) == sof);
+    }
+
+    TEST(xstrides, free_function_4d_row_major)
+    {
+        xt::xarray<int, xt::layout_type::row_major> a = xt::ones<int>({5, 4, 1, 4});
+        using stype = std::vector<std::ptrdiff_t>;
+        std::ptrdiff_t sof = sizeof(int);
+
+        EXPECT_EQ(xt::strides(a), stype({16, 4, 4, 1}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::normal), stype({16, 4, 4, 1}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::internal), stype({16, 4, 0, 1}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::bytes), stype({16 * sof, 4 * sof, 4 * sof, 1 * sof}));
+
+        EXPECT_TRUE(xt::strides(a, 0) == 16);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::normal) == 16);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::internal) == 16);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::bytes) == 16 * sof);
+
+        EXPECT_TRUE(xt::strides(a, 1) == 4);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::normal) == 4);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::internal) == 4);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::bytes) == 4 * sof);
+
+        EXPECT_TRUE(xt::strides(a, 2) == 4);
+        EXPECT_TRUE(xt::strides(a, 2, xt::stride_type::normal) == 4);
+        EXPECT_TRUE(xt::strides(a, 2, xt::stride_type::internal) == 0);
+        EXPECT_TRUE(xt::strides(a, 2, xt::stride_type::bytes) == 4 * sof);
+
+        EXPECT_TRUE(xt::strides(a, 3) == 1);
+        EXPECT_TRUE(xt::strides(a, 3, xt::stride_type::normal) == 1);
+        EXPECT_TRUE(xt::strides(a, 3, xt::stride_type::internal) == 1);
+        EXPECT_TRUE(xt::strides(a, 3, xt::stride_type::bytes) == sof);
+    }
+
+    TEST(xstrides, free_function_4d_column_major)
+    {
+        xt::xarray<int, xt::layout_type::column_major> a = xt::ones<int>({5, 4, 1, 4});
+        using stype = std::vector<std::ptrdiff_t>;
+        std::ptrdiff_t sof = sizeof(int);
+
+        EXPECT_EQ(xt::strides(a), stype({1, 5, 20, 20}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::normal), stype({1, 5, 20, 20}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::internal), stype({1, 5, 0, 20}));
+        EXPECT_EQ(xt::strides(a, xt::stride_type::bytes), stype({sof, 5 * sof, 20 * sof, 20 * sof}));
+
+        EXPECT_TRUE(xt::strides(a, 0) == 1);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::normal) == 1);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::internal) == 1);
+        EXPECT_TRUE(xt::strides(a, 0, xt::stride_type::bytes) == sof);
+
+        EXPECT_TRUE(xt::strides(a, 1) == 5);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::normal) == 5);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::internal) == 5);
+        EXPECT_TRUE(xt::strides(a, 1, xt::stride_type::bytes) == 5 * sof);
+
+        EXPECT_TRUE(xt::strides(a, 2) == 20);
+        EXPECT_TRUE(xt::strides(a, 2, xt::stride_type::normal) == 20);
+        EXPECT_TRUE(xt::strides(a, 2, xt::stride_type::internal) == 0);
+        EXPECT_TRUE(xt::strides(a, 2, xt::stride_type::bytes) == 20 * sof);
+
+        EXPECT_TRUE(xt::strides(a, 3) == 20);
+        EXPECT_TRUE(xt::strides(a, 3, xt::stride_type::normal) == 20);
+        EXPECT_TRUE(xt::strides(a, 3, xt::stride_type::internal) == 20);
+        EXPECT_TRUE(xt::strides(a, 3, xt::stride_type::bytes) == 20 * sof);
+    }
+
     TEST(xstrides, unravel_from_strides)
     {
+        SUBCASE("row_major strides")
         {
-            SCOPED_TRACE("row_major strides");
             row_major_result<> rm;
             using index_type = xt::dynamic_shape<std::ptrdiff_t>;
-            index_type index = { 2, 1, 1 };
+            index_type index = {2, 1, 1};
             auto offset = element_offset<std::ptrdiff_t>(rm.strides(), index.cbegin(), index.cend());
             index_type unrav_index = unravel_from_strides(offset, rm.strides(), layout_type::row_major);
             EXPECT_TRUE(std::equal(unrav_index.cbegin(), unrav_index.cend(), index.cbegin()));
         }
 
+        SUBCASE("column_major strides")
         {
-            SCOPED_TRACE("column_major strides");
             column_major_result<> cm;
             using index_type = xt::dynamic_shape<std::ptrdiff_t>;
-            index_type index = { 2, 1, 1 };
+            index_type index = {2, 1, 1};
             auto offset = element_offset<std::ptrdiff_t>(cm.strides(), index.cbegin(), index.cend());
             index_type unrav_index = unravel_from_strides(offset, cm.strides(), layout_type::column_major);
             EXPECT_TRUE(std::equal(unrav_index.cbegin(), unrav_index.cend(), index.cbegin()));
         }
 
+        SUBCASE("unit_major strides")
         {
-            SCOPED_TRACE("unit_major strides");
             unit_shape_result<> um;
             using index_type = xt::dynamic_shape<std::ptrdiff_t>;
-            index_type index = { 2, 0, 1 };
+            index_type index = {2, 0, 1};
             auto offset = element_offset<std::ptrdiff_t>(um.strides(), index.cbegin(), index.cend());
             index_type unrav_index = unravel_from_strides(offset, um.strides(), layout_type::row_major);
             EXPECT_TRUE(std::equal(unrav_index.cbegin(), unrav_index.cend(), index.cbegin()));
@@ -47,34 +172,74 @@ namespace xt
 
     TEST(xstrides, unravel_index)
     {
+        SUBCASE("row_major strides")
         {
-            SCOPED_TRACE("row_major strides");
             row_major_result<> rm;
             using index_type = xt::dynamic_shape<std::ptrdiff_t>;
-            index_type index = { 2, 1, 1 };
+            index_type index = {2, 1, 1};
             auto offset = element_offset<std::size_t>(rm.strides(), index.cbegin(), index.cend());
             index_type unrav_index = unravel_index(offset, rm.shape(), layout_type::row_major);
             EXPECT_TRUE(std::equal(unrav_index.cbegin(), unrav_index.cend(), index.cbegin()));
         }
 
+        SUBCASE("column_major strides")
         {
-            SCOPED_TRACE("column_major strides");
             column_major_result<> cm;
             using index_type = xt::dynamic_shape<std::ptrdiff_t>;
-            index_type index = { 2, 1, 1 };
+            index_type index = {2, 1, 1};
             auto offset = element_offset<std::size_t>(cm.strides(), index.cbegin(), index.cend());
             index_type unrav_index = unravel_index(offset, cm.shape(), layout_type::column_major);
             EXPECT_TRUE(std::equal(unrav_index.cbegin(), unrav_index.cend(), index.cbegin()));
         }
 
+        SUBCASE("unit_major strides")
         {
-            SCOPED_TRACE("unit_major strides");
             unit_shape_result<> um;
             using index_type = xt::dynamic_shape<std::ptrdiff_t>;
-            index_type index = { 2, 0, 1 };
+            index_type index = {2, 0, 1};
             auto offset = element_offset<std::size_t>(um.strides(), index.cbegin(), index.cend());
             index_type unrav_index = unravel_index(offset, um.shape(), layout_type::row_major);
             EXPECT_TRUE(std::equal(unrav_index.cbegin(), unrav_index.cend(), index.cbegin()));
         }
     }
-}
\ No newline at end of file
+
+    TEST(xstrides, do_match_strides)
+    {
+        using vector_type = std::vector<std::size_t>;
+        vector_type shape_0 = {2, 1, 4};
+
+        vector_type strides_0 = {4, 0, 1};
+        EXPECT_TRUE(xt::do_strides_match(shape_0, strides_0, xt::layout_type::row_major, true));
+
+        vector_type strides_1 = {4, 4, 1};
+        EXPECT_TRUE(xt::do_strides_match(shape_0, strides_1, xt::layout_type::row_major, false));
+
+        vector_type strides_2 = {1, 0, 2};
+        EXPECT_TRUE(xt::do_strides_match(shape_0, strides_2, xt::layout_type::column_major, true));
+
+        vector_type strides_3 = {1, 2, 2};
+        EXPECT_TRUE(xt::do_strides_match(shape_0, strides_3, xt::layout_type::column_major, false));
+
+        vector_type shape_1 = {2, 1, 2, 4};
+        vector_type strides_4 = {8, 8, 4, 1};
+        EXPECT_TRUE(xt::do_strides_match(shape_1, strides_4, xt::layout_type::row_major, false));
+
+        vector_type strides_5 = {8, 1, 8, 1};
+        EXPECT_FALSE(xt::do_strides_match(shape_1, strides_5, xt::layout_type::row_major, false));
+
+        vector_type shape_2 = {2, 2, 1, 4};
+        vector_type strides_6 = {1, 2, 4, 4};
+        EXPECT_TRUE(xt::do_strides_match(shape_2, strides_6, xt::layout_type::column_major, false));
+
+        vector_type strides_7 = {1, 2, 1, 4};
+        EXPECT_FALSE(xt::do_strides_match(shape_2, strides_7, xt::layout_type::column_major, false));
+    }
+
+    TEST(xstrides, ravel_index)
+    {
+        xt::uvector<std::size_t> index = {1, 1, 1};
+        xt::uvector<std::size_t> shape = {10, 20, 30};
+        auto idx = xt::ravel_index(index, shape, xt::layout_type::row_major);
+        EXPECT_EQ(idx, 631);
+    }
+}
diff --git a/test/test_xtensor.cpp b/test/test_xtensor.cpp
index 4b8481346..f7f81c75d 100644
--- a/test/test_xtensor.cpp
+++ b/test/test_xtensor.cpp
@@ -1,17 +1,20 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
-#include "test_common.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include <type_traits>
 
-#include "xtensor/xio.hpp"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/io/xio.hpp"
+
+#include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -28,13 +31,7 @@ namespace xt
 
     TEST(xtensor, initializer_constructor)
     {
-        xtensor_dynamic t
-          {{{0, 1, 2},
-            {3, 4, 5},
-            {6, 7, 8}},
-           {{9, 10, 11},
-            {12, 13, 14},
-            {15, 16, 17}}};
+        xtensor_dynamic t{{{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}, {{9, 10, 11}, {12, 13, 14}, {15, 16, 17}}};
         EXPECT_EQ(t.dimension(), size_t(3));
         EXPECT_EQ(t(0, 0, 1), 1);
         EXPECT_EQ(t.shape()[0], size_t(2));
@@ -42,22 +39,22 @@ namespace xt
 
     TEST(xtensor, shaped_constructor)
     {
+        SUBCASE("row_major constructor")
         {
-            SCOPED_TRACE("row_major constructor");
             row_major_result<storage_type> rm;
             xtensor_dynamic ra(rm.m_shape, layout_type::row_major);
             compare_shape(ra, rm);
         }
 
+        SUBCASE("column_major constructor")
         {
-            SCOPED_TRACE("column_major constructor");
             column_major_result<storage_type> cm;
             xtensor_dynamic ca(cm.m_shape, layout_type::column_major);
             compare_shape(ca, cm);
         }
 
+        SUBCASE("from shape")
         {
-            SCOPED_TRACE("from shape");
             std::array<std::size_t, 3> shp = {5, 4, 2};
             std::vector<std::size_t> shp_as_vec = {5, 4, 2};
             auto ca = xtensor<int, 3>::from_shape({3, 2, 1});
@@ -77,8 +74,8 @@ namespace xt
 
     TEST(xtensor, valued_constructor)
     {
+        SUBCASE("row_major valued constructor")
         {
-            SCOPED_TRACE("row_major valued constructor");
             row_major_result<storage_type> rm;
             int value = 2;
             xtensor_dynamic ra(rm.m_shape, value, layout_type::row_major);
@@ -87,8 +84,8 @@ namespace xt
             EXPECT_EQ(ra.storage(), vec);
         }
 
+        SUBCASE("column_major valued constructor")
         {
-            SCOPED_TRACE("column_major valued constructor");
             column_major_result<storage_type> cm;
             int value = 2;
             xtensor_dynamic ca(cm.m_shape, value, layout_type::column_major);
@@ -121,15 +118,15 @@ namespace xt
         int value = 2;
         xtensor_dynamic a(res.m_shape, res.m_strides, value);
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             xtensor_dynamic b(a);
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("assignment operator")
         {
-            SCOPED_TRACE("assignment operator");
             row_major_result<storage_type> r;
             xtensor_dynamic c(r.m_shape, 0);
             EXPECT_NE(a.storage(), c.storage());
@@ -145,16 +142,16 @@ namespace xt
         int value = 2;
         xtensor_dynamic a(res.m_shape, res.m_strides, value);
 
+        SUBCASE("move constructor")
         {
-            SCOPED_TRACE("move constructor");
             xtensor_dynamic tmp(a);
             xtensor_dynamic b(std::move(tmp));
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("move assignment")
         {
-            SCOPED_TRACE("move assignment");
             row_major_result<storage_type> r;
             xtensor_dynamic c(r.m_shape, 0);
             EXPECT_NE(a.storage(), c.storage());
@@ -165,16 +162,75 @@ namespace xt
         }
     }
 
+    TEST(xtensor, missing)
+    {
+        xt::xtensor<int, 2> a{{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
+
+        EXPECT_EQ(a(0), 0);
+        EXPECT_EQ(a(1), 1);
+        EXPECT_EQ(a(2), 2);
+        EXPECT_EQ(a(0, 0), 0);
+        EXPECT_EQ(a(1, 0), 3);
+        EXPECT_EQ(a(2, 0), 6);
+        EXPECT_EQ(a(xt::missing), 0);
+        EXPECT_EQ(a(0, xt::missing), 0);
+        EXPECT_EQ(a(1, xt::missing), 3);
+        EXPECT_EQ(a(2, xt::missing), 6);
+        EXPECT_EQ(a(0, 0), 0);
+        EXPECT_EQ(a(0, 1), 1);
+        EXPECT_EQ(a(0, 2), 2);
+        EXPECT_EQ(a(1, 0), 3);
+        EXPECT_EQ(a(1, 1), 4);
+        EXPECT_EQ(a(1, 2), 5);
+        EXPECT_EQ(a(2, 0), 6);
+        EXPECT_EQ(a(2, 1), 7);
+        EXPECT_EQ(a(2, 2), 8);
+        EXPECT_EQ(a(9, 9, 9, 0, 0), 0);
+        EXPECT_EQ(a(9, 9, 9, 0, 1), 1);
+        EXPECT_EQ(a(9, 9, 9, 0, 2), 2);
+        EXPECT_EQ(a(9, 9, 9, 1, 0), 3);
+        EXPECT_EQ(a(9, 9, 9, 1, 1), 4);
+        EXPECT_EQ(a(9, 9, 9, 1, 2), 5);
+        EXPECT_EQ(a(9, 9, 9, 2, 0), 6);
+        EXPECT_EQ(a(9, 9, 9, 2, 1), 7);
+        EXPECT_EQ(a(9, 9, 9, 2, 2), 8);
+
+        EXPECT_EQ(a.periodic(-1, xt::missing), a(2, xt::missing));
+        EXPECT_EQ(a.periodic(-2, xt::missing), a(1, xt::missing));
+        EXPECT_EQ(a.periodic(-3, xt::missing), a(0, xt::missing));
+
+        EXPECT_EQ(a.at(0, xt::missing), a.at(0, 0));
+        EXPECT_EQ(a.at(1, xt::missing), a.at(1, 0));
+        EXPECT_EQ(a.at(2, xt::missing), a.at(2, 0));
+
+        EXPECT_TRUE(a.in_bounds(0, xt::missing));
+        EXPECT_TRUE(a.in_bounds(1, xt::missing));
+        EXPECT_TRUE(a.in_bounds(2, xt::missing));
+        EXPECT_FALSE(a.in_bounds(3, xt::missing));
+    }
+
     TEST(xtensor, resize)
     {
         xtensor_dynamic a;
         test_resize<xtensor_dynamic, storage_type>(a);
+
+#ifdef XTENSOR_ENABLE_ASSERT
+        xtensor_dynamic b;
+        std::vector<size_t> s = {2u, 2u};
+        xtensor_dynamic::strides_type strides = {2u, 1u};
+        EXPECT_THROW(b.resize(s), std::runtime_error);
+        EXPECT_THROW(b.resize(s, layout_type::dynamic), std::runtime_error);
+        EXPECT_THROW(b.resize(s, strides), std::runtime_error);
+#endif
     }
 
     TEST(xtensor, reshape)
     {
         xtensor_dynamic a;
         test_reshape<xtensor_dynamic, storage_type>(a);
+
+        xtensor<int, 1> b;
+        test_throwing_reshape(b);
     }
 
     TEST(xtensor, transpose)
@@ -183,11 +239,13 @@ namespace xt
         test_transpose<xtensor_dynamic, storage_type>(a);
     }
 
+#if !(defined(XTENSOR_ENABLE_ASSERT) && defined(XTENSOR_DISABLE_EXCEPTIONS))
     TEST(xtensor, access)
     {
         xtensor_dynamic a;
         test_access<xtensor_dynamic, storage_type>(a);
     }
+#endif
 
     TEST(xtensor, unchecked)
     {
@@ -201,11 +259,13 @@ namespace xt
         test_at<xtensor_dynamic, storage_type>(a);
     }
 
+#if !(defined(XTENSOR_ENABLE_ASSERT) && defined(XTENSOR_DISABLE_EXCEPTIONS))
     TEST(xtensor, element)
     {
         xtensor_dynamic a;
         test_element<xtensor_dynamic, storage_type>(a);
     }
+#endif
 
     TEST(xtensor, indexed_access)
     {
@@ -259,18 +319,24 @@ namespace xt
         EXPECT_EQ(2, res(0));
         EXPECT_EQ(2, res(1));
 
-        xtensor<int, 1> b = { 1, 2 };
+        xtensor<int, 1> b = {1, 2};
         xt::xarray<double> ca = a * b;
     }
 
     TEST(xtensor, move_from_xarray)
     {
-        xarray<double> a = {{{1,2,3}, {4,5,6}}, {{10, 10, 10}, {1,5,10}}};
+        xarray<double> a = {{{1, 2, 3}, {4, 5, 6}}, {{10, 10, 10}, {1, 5, 10}}};
         xarray<double> a1 = a;
         xtensor<double, 3> b(std::move(a1));
         EXPECT_EQ(a, b);
-        EXPECT_TRUE(std::equal(a.strides().begin(), a.strides().end(), b.strides().begin()) && a.strides().size() == b.strides().size());
-        EXPECT_TRUE(std::equal(a.backstrides().begin(), a.backstrides().end(), b.backstrides().begin()) && a.backstrides().size() == b.backstrides().size());
+        EXPECT_TRUE(
+            std::equal(a.strides().begin(), a.strides().end(), b.strides().begin())
+            && a.strides().size() == b.strides().size()
+        );
+        EXPECT_TRUE(
+            std::equal(a.backstrides().begin(), a.backstrides().end(), b.backstrides().begin())
+            && a.backstrides().size() == b.backstrides().size()
+        );
         EXPECT_EQ(a.layout(), b.layout());
 
         xarray<double> a2 = a;
@@ -278,9 +344,151 @@ namespace xt
         c = std::move(a2);
 
         EXPECT_EQ(a, c);
-        EXPECT_TRUE(std::equal(a.strides().begin(), a.strides().end(), c.strides().begin()) && a.strides().size() == c.strides().size());
-        EXPECT_TRUE(std::equal(a.backstrides().begin(), a.backstrides().end(), c.backstrides().begin()) && a.backstrides().size() == c.backstrides().size());
+        EXPECT_TRUE(
+            std::equal(a.strides().begin(), a.strides().end(), c.strides().begin())
+            && a.strides().size() == c.strides().size()
+        );
+        EXPECT_TRUE(
+            std::equal(a.backstrides().begin(), a.backstrides().end(), c.backstrides().begin())
+            && a.backstrides().size() == c.backstrides().size()
+        );
         EXPECT_EQ(a.layout(), c.layout());
     }
 
+    TEST(xtensor, from_indices)
+    {
+        xt::xtensor<int, 2> a = {{1, 0, 0}, {1, 1, 0}, {1, 1, 1}};
+        xt::xtensor<size_t, 2> jdx = {{0, 0}, {1, 0}, {1, 1}, {2, 0}, {2, 1}, {2, 2}};
+        xt::xtensor<size_t, 2> idx = xt::from_indices(xt::argwhere(xt::equal(a, 1)));
+        EXPECT_TRUE(idx == jdx);
+    }
+
+    TEST(xtensor, flatten_indices)
+    {
+        xt::xtensor<int, 1> a = {1, 0, 0, 1, 1, 0, 1, 1, 1};
+        xt::xtensor<size_t, 1> jdx = {0, 3, 4, 6, 7, 8};
+        xt::xtensor<size_t, 1> idx = xt::flatten_indices(xt::argwhere(xt::equal(a, 1)));
+        EXPECT_TRUE(idx == jdx);
+    }
+
+    TEST(xtensor, ravel_indices)
+    {
+        xt::xtensor<int, 2> a = {{1, 0, 0}, {1, 1, 0}, {1, 1, 1}};
+        xt::xtensor<size_t, 1> jdx = {0, 3, 4, 6, 7, 8};
+        xt::xtensor<size_t, 1> idx = xt::ravel_indices(xt::argwhere(xt::equal(a, 1)), a.shape());
+        EXPECT_TRUE(idx == jdx);
+    }
+
+    TEST(xtensor, ravel_indices_column_major)
+    {
+        xt::xtensor<int, 2, xt::layout_type::column_major> a = {{1, 0, 0}, {1, 1, 0}, {1, 1, 1}};
+        xt::xtensor<size_t, 1> jdx = {0, 1, 4, 2, 5, 8};
+        xt::xtensor<size_t, 1> idx = xt::ravel_indices(
+            xt::argwhere(xt::equal(a, 1)),
+            a.shape(),
+            xt::layout_type::column_major
+        );
+        EXPECT_TRUE(idx == jdx);
+    }
+
+    TEST(xarray, operator_brace)
+    {
+#ifdef XTENSOR_ENABLE_ASSERT
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+        EXPECT_THROW(a(2, 0), std::runtime_error);
+        EXPECT_THROW(a(0, 3), std::runtime_error);
+
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}};
+        EXPECT_THROW(a(0, 3), std::runtime_error);
+        EXPECT_THROW(a(1, 3), std::runtime_error);
+#endif
+    }
+
+    TEST(xtensor, periodic)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}, {30, 40, 50}};
+        a.periodic(-1, 3) = 30;
+        a.periodic(-1, 4) = 40;
+        a.periodic(-1, 5) = 50;
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xtensor, flat)
+    {
+        {
+            xt::xtensor<size_t, 2, xt::layout_type::row_major> a = {{0, 1, 2}, {3, 4, 5}};
+            xt::xtensor<size_t, 2, xt::layout_type::row_major> b = {{0, 1, 2}, {30, 40, 50}};
+            a.flat(3) = 30;
+            a.flat(4) = 40;
+            a.flat(5) = 50;
+            EXPECT_EQ(a, b);
+#ifdef XTENSOR_ENABLE_ASSERT
+            EXPECT_THROW(a.flat(6), std::runtime_error);
+#endif
+        }
+        {
+            xt::xtensor<size_t, 2, xt::layout_type::column_major> a = {{0, 1, 2}, {3, 4, 5}};
+            xt::xtensor<size_t, 2, xt::layout_type::column_major> b = {{0, 1, 2}, {30, 40, 50}};
+            a.flat(1) = 30;
+            a.flat(3) = 40;
+            a.flat(5) = 50;
+            EXPECT_EQ(a, b);
+#ifdef XTENSOR_ENABLE_ASSERT
+            EXPECT_THROW(a.flat(6), std::runtime_error);
+#endif
+        }
+    }
+
+    TEST(xtensor, in_bounds)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+        EXPECT_TRUE(a.in_bounds(0, 0) == true);
+        EXPECT_TRUE(a.in_bounds(2, 0) == false);
+    }
+
+    TEST(xtensor, iterator_types)
+    {
+        using tensor_type = xtensor<int, 2>;
+        test_iterator_types<tensor_type, int*, const int*>();
+    }
+
+    TEST(xtensor, type_traits)
+    {
+        using tensor_type = xt::xtensor<double, 3>;
+        EXPECT_TRUE(std::is_constructible<tensor_type>::value);
+        EXPECT_TRUE(std::is_constructible<tensor_type>::value);
+
+        EXPECT_TRUE(std::is_default_constructible<tensor_type>::value);
+
+        EXPECT_TRUE(std::is_copy_constructible<tensor_type>::value);
+
+        EXPECT_TRUE(std::is_move_constructible<tensor_type>::value);
+        EXPECT_TRUE(std::is_nothrow_move_constructible<tensor_type>::value);
+
+        EXPECT_TRUE(std::is_copy_assignable<tensor_type>::value);
+
+        EXPECT_TRUE(std::is_move_assignable<tensor_type>::value);
+        EXPECT_TRUE(std::is_nothrow_move_assignable<tensor_type>::value);
+
+        EXPECT_TRUE(std::is_destructible<tensor_type>::value);
+        EXPECT_TRUE(std::is_nothrow_destructible<tensor_type>::value);
+    }
+
+    TEST(xtensor, bool_container)
+    {
+        xt::xtensor<int, 1> a{1, 0, 1, 0}, b{1, 1, 0, 0};
+
+        xt::xtensor<bool, 1> c = a & b;
+        EXPECT_TRUE(c(0));
+        EXPECT_FALSE(c(1));
+        EXPECT_FALSE(c(2));
+        EXPECT_FALSE(c(3));
+
+        xt::xtensor<bool, 1> d = a | b;
+        EXPECT_TRUE(d(0));
+        EXPECT_TRUE(d(1));
+        EXPECT_TRUE(d(2));
+        EXPECT_FALSE(d(3));
+    }
 }
diff --git a/test/test_xtensor_adaptor.cpp b/test/test_xtensor_adaptor.cpp
index 8d1af41db..5bbc5c0d3 100644
--- a/test/test_xtensor_adaptor.cpp
+++ b/test/test_xtensor_adaptor.cpp
@@ -1,14 +1,16 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xtensor.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xtensor.hpp"
+
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -18,16 +20,16 @@ namespace xt
 
     TEST(xtensor_adaptor, shaped_constructor)
     {
+        SUBCASE("row_major constructor")
         {
-            SCOPED_TRACE("row_major constructor");
             row_major_result<storage_type> rm;
             vec_type v;
             adaptor_type a(v, rm.shape(), layout_type::row_major);
             compare_shape(a, rm);
         }
 
+        SUBCASE("column_major constructor")
         {
-            SCOPED_TRACE("column_major constructor");
             column_major_result<storage_type> cm;
             vec_type v;
             adaptor_type a(v, cm.shape(), layout_type::column_major);
@@ -50,15 +52,15 @@ namespace xt
         vec_type v(res.size(), value);
         adaptor_type a(v, res.shape(), res.strides());
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             adaptor_type b(a);
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("assignment operator")
         {
-            SCOPED_TRACE("assignment operator");
             row_major_result<storage_type> r;
             vec_type v2(r.size(), 0);
             adaptor_type c(v2, r.shape());
@@ -76,16 +78,16 @@ namespace xt
         vec_type v(res.size(), value);
         adaptor_type a(v, res.shape(), res.strides());
 
+        SUBCASE("move constructor")
         {
-            SCOPED_TRACE("move constructor");
             adaptor_type tmp(a);
             adaptor_type b(std::move(tmp));
             compare_shape(a, b);
             EXPECT_EQ(a.storage(), b.storage());
         }
 
+        SUBCASE("move assignment")
         {
-            SCOPED_TRACE("move assignment");
             row_major_result<storage_type> r;
             vec_type v2(r.size(), 0);
             adaptor_type c(v2, r.shape());
@@ -111,12 +113,14 @@ namespace xt
         test_reshape<adaptor_type, storage_type>(a);
     }
 
+#if !(defined(XTENSOR_ENABLE_ASSERT) && defined(XTENSOR_DISABLE_EXCEPTIONS))
     TEST(xtensor_adaptor, access)
     {
         vec_type v;
         adaptor_type a(v);
         test_access<adaptor_type, storage_type>(a);
     }
+#endif
 
     TEST(xtensor_adaptor, unchecked)
     {
@@ -185,4 +189,16 @@ namespace xt
         ad = ad * 2;
         EXPECT_EQ(ad(1, 1), 10.);
     }
+
+    TEST(xtensor_adaptor, iterator_types)
+    {
+        using vec_type = std::vector<int>;
+        using tensor_type = xtensor_adaptor<vec_type, 2>;
+        using const_tensor_type = xtensor_adaptor<const vec_type, 2>;
+        using iterator = vec_type::iterator;
+        using const_iterator = vec_type::const_iterator;
+
+        test_iterator_types<tensor_type, iterator, const_iterator>();
+        test_iterator_types<const_tensor_type, const_iterator, const_iterator>();
+    }
 }
diff --git a/test/test_xtensor_semantic.cpp b/test/test_xtensor_semantic.cpp
index 5cb680983..66caddfed 100644
--- a/test/test_xtensor_semantic.cpp
+++ b/test/test_xtensor_semantic.cpp
@@ -1,15 +1,17 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xtensor.hpp"
 
-#include "gtest/gtest.h"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
 #include "test_common.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -53,17 +55,11 @@ namespace xt
         using int32_tensor = xtensor<int32_t, 2>;
         using double_tensor = xtensor<double, 2>;
 
-        int8_tensor i8t = {{int8_t(0), int8_t(1) },
-                           { int8_t(2) , int8_t(3) },
-                           { int8_t(4) , int8_t(5) }};
+        int8_tensor i8t = {{int8_t(0), int8_t(1)}, {int8_t(2), int8_t(3)}, {int8_t(4), int8_t(5)}};
 
-        int32_tensor i32t = {{ int32_t(0), int32_t(1) },
-                             { int8_t(2) , int8_t(3) },
-                             { int8_t(4) , int8_t(5) }};
+        int32_tensor i32t = {{int32_t(0), int32_t(1)}, {int8_t(2), int8_t(3)}, {int8_t(4), int8_t(5)}};
 
-        double_tensor dt = {{0., 1.},
-                            {2., 3.},
-                            {4., 5.}};
+        double_tensor dt = {{0., 1.}, {2., 3.}, {4., 5.}};
 
         int32_tensor i32res = i8t;
         EXPECT_EQ(i32res, i32t);
@@ -74,7 +70,7 @@ namespace xt
 
     TEST(xtensor_semantic, broadcasting_single_element)
     {
-        xtensor<int, 2> t = xt::zeros<int>({ 1, 1 });
+        xtensor<int, 2> t = xt::zeros<int>({1, 1});
         EXPECT_EQ(t.backstrides().size(), 2u);
         EXPECT_EQ(t.backstrides()[0], 0u);
         EXPECT_EQ(t.backstrides()[1], 0u);
diff --git a/test/test_xutils.cpp b/test/test_xutils.cpp
index 42991c295..6107c4bce 100644
--- a/test/test_xutils.cpp
+++ b/test/test_xutils.cpp
@@ -1,24 +1,26 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
+ * 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. *
+ ****************************************************************************/
+
+#include <complex>
 #include <initializer_list>
-#include <type_traits>
 #include <tuple>
-#include <complex>
+#include <type_traits>
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xshape.hpp"
+#include "xtensor/utils/xutils.hpp"
+#include "xtensor/views/xstrided_view.hpp"
+#include "xtensor/views/xview.hpp"
 
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xarray.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xstrided_view.hpp"
-#include "xtensor/xshape.hpp"
-#include "xtensor/xutils.hpp"
-#include "xtensor/xview.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -63,70 +65,55 @@ namespace xt
         auto t = std::make_tuple(a, b, c, d);
         for_each(fn, t);
         ASSERT_TRUE(a == fn.a && b == fn.b && c == fn.c && d == fn.d);
+        EXPECT_FALSE(noexcept(for_each(fn, t)));
     }
 
     TEST(utils, accumulate)
     {
-        auto func = [](int i, int j) { return i + j; };
+        auto func = [](int i, int j)
+        {
+            return i + j;
+        };
         const std::tuple<int, int, int> t(3, 4, 1);
         EXPECT_EQ(8, accumulate(func, 0, t));
+        EXPECT_FALSE(noexcept(accumulate(func, 0, t)));
+
+        auto func_ne = [](int i, int j) noexcept
+        {
+            return i + j;
+        };
+        EXPECT_EQ(8, accumulate(func_ne, 0, t));
+        EXPECT_TRUE(noexcept(accumulate(func_ne, 0, t)));
+
+        const std::tuple<> t_empty{};
+        EXPECT_EQ(8, accumulate(func_ne, 8, t_empty));
     }
 
     template <class... T>
     auto foo(const std::tuple<T...>& t)
     {
-        auto func = [](int i) { return i; };
+        auto func = [](int i)
+        {
+            return i;
+        };
         return apply<int>(1, func, t);
     }
 
-    TEST(utils, apply)
+    int fun(int i) noexcept
     {
-        ASSERT_TRUE(foo(std::make_tuple(1, 2, 3)) == 2);
+        return 2 * i;
     }
 
-    TEST(utils, initializer_dimension)
-    {
-        size_t d0 = initializer_dimension<double>::value;
-        size_t d1 = initializer_dimension<std::initializer_list<double>>::value;
-        size_t d2 = initializer_dimension<std::initializer_list<std::initializer_list<double>>>::value;
-        EXPECT_EQ(size_t(0), d0);
-        EXPECT_EQ(size_t(1), d1);
-        EXPECT_EQ(size_t(2), d2);
-    }
-
-    TEST(utils, promote_shape)
-    {
-        bool expect_v = std::is_same<
-            dynamic_shape<size_t>,
-            promote_shape_t<dynamic_shape<size_t>, std::array<size_t, 3>, std::array<size_t, 2>>
-        >::value;
-
-        bool expect_a = std::is_same<
-            std::array<size_t, 3>,
-            promote_shape_t<std::array<size_t, 2>, std::array<size_t, 3>, std::array<size_t, 2>>
-        >::value;
-
-        ASSERT_TRUE(expect_v);
-        ASSERT_TRUE(expect_a);
-    }
-
-    TEST(utils, shape)
+    TEST(utils, apply)
     {
-        auto s0 = shape<std::vector<size_t>>(3);
-        auto s1 = shape<std::vector<size_t>>(std::initializer_list<size_t>{1, 2});
-        auto s2 = shape<std::vector<size_t>>(std::initializer_list<std::initializer_list<size_t>>{{1, 2, 4}, {1, 3, 5}});
-
-        std::vector<size_t> e0 = {};
-        std::vector<size_t> e1 = {2};
-        std::vector<size_t> e2 = {2, 3};
-
-        ASSERT_TRUE(check_shape(3, s0.begin(), s0.end()));
-        ASSERT_TRUE(check_shape(std::initializer_list<size_t>{1, 2}, s1.begin(), s1.end()));
-        ASSERT_TRUE(check_shape(std::initializer_list<std::initializer_list<size_t>>{{1, 2, 4}, {1, 3, 5}}, s2.begin(), s2.end()));
-
-        EXPECT_EQ(e0, s0);
-        EXPECT_EQ(e1, s1);
-        EXPECT_EQ(e2, s2);
+        ASSERT_TRUE(foo(std::make_tuple(1, 2, 3)) == 2);
+        static_assert(!noexcept(foo(std::make_tuple(1, 2, 3))));
+        auto func_ne = [](int i) noexcept
+        {
+            return i;
+        };
+        auto t = std::make_tuple(1, 2, 3);
+        static_assert(noexcept(apply<int>(1, func_ne, t)));
     }
 
     TEST(utils, conditional_cast)
@@ -135,58 +122,12 @@ namespace xt
         EXPECT_TRUE((std::is_same<decltype(conditional_cast<true, double>(1)), double>::value));
     }
 
-    TEST(utils, promote_traits)
-    {
-        EXPECT_TRUE((std::is_same<promote_type_t<uint8_t>, int>::value));
-        EXPECT_TRUE((std::is_same<promote_type_t<int>, int>::value));
-        EXPECT_TRUE((std::is_same<promote_type_t<float>, float>::value));
-        EXPECT_TRUE((std::is_same<promote_type_t<double>, double>::value));
-        EXPECT_TRUE((std::is_same<promote_type_t<bool>, bool>::value));
-
-        EXPECT_TRUE((std::is_same<big_promote_type_t<uint8_t>, unsigned long long>::value));
-        EXPECT_TRUE((std::is_same<big_promote_type_t<short>, long long>::value));
-        EXPECT_TRUE((std::is_same<big_promote_type_t<int>, long long>::value));
-        EXPECT_TRUE((std::is_same<big_promote_type_t<float>, double>::value));
-        EXPECT_TRUE((std::is_same<big_promote_type_t<double>, double>::value));
-
-        EXPECT_TRUE((std::is_same<real_promote_type_t<uint8_t>, double>::value));
-        EXPECT_TRUE((std::is_same<real_promote_type_t<int>, double>::value));
-        EXPECT_TRUE((std::is_same<real_promote_type_t<float>, float>::value));
-        EXPECT_TRUE((std::is_same<real_promote_type_t<double>, double>::value));
-
-        EXPECT_TRUE((std::is_same<bool_promote_type_t<bool>, uint8_t>::value));
-        EXPECT_TRUE((std::is_same<bool_promote_type_t<int>, int>::value));
-    }
-
-    TEST(utils, norm_traits)
-    {
-        EXPECT_TRUE((std::is_same<norm_type_t<uint8_t>, int>::value));
-        EXPECT_TRUE((std::is_same<norm_type_t<int>, int>::value));
-        EXPECT_TRUE((std::is_same<norm_type_t<double>, double>::value));
-        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<uint8_t>>, double>::value));
-        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<int>>, double>::value));
-        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<double>>, double>::value));
-        EXPECT_TRUE((std::is_same<norm_type_t<std::vector<long double>>, long double>::value));
-
-        EXPECT_TRUE((std::is_same<squared_norm_type_t<uint8_t>, int>::value));
-        EXPECT_TRUE((std::is_same<squared_norm_type_t<int>, int>::value));
-        EXPECT_TRUE((std::is_same<squared_norm_type_t<double>, double>::value));
-        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<uint8_t>>, uint64_t>::value));
-        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<int>>, uint64_t>::value));
-        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<double>>, double>::value));
-        EXPECT_TRUE((std::is_same<squared_norm_type_t<std::vector<long double>>, long double>::value));
-    }
-
     TEST(utils, has_data_interface)
     {
-        bool b = has_data_interface<xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<const xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<const xtensor<double, 2>>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<const xtensor_fixed<double, xshape<3, 4>>>::value;
-        EXPECT_TRUE(b);
+        static_assert(data_interface_expression<xarray<int>>);
+        static_assert(data_interface_expression<const xarray<int>>);
+        static_assert(data_interface_expression<const xtensor<double, 2>>);
+        static_assert(data_interface_expression<const xtensor_fixed<double, xshape<3, 4>>>);
 
         xarray<int> a = xarray<int>::from_shape({3, 4, 5});
         auto f = a + a - 23;
@@ -194,24 +135,27 @@ namespace xt
         auto vv2 = strided_view(v2, {all(), 2});
         auto v3 = strided_view(f, {all(), 2});
 
-        b = has_data_interface<decltype(v2)>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<decltype(vv2)>::value;
-        EXPECT_TRUE(b);
-        b = has_data_interface<decltype(v3)>::value;
-        EXPECT_FALSE(b);
+        static_assert(data_interface_expression<decltype(v2)>);
+        static_assert(data_interface_expression<decltype(vv2)>);
+        static_assert(!data_interface_expression<decltype(v3)>);
+    }
+
+    TEST(utils, has_storage_type)
+    {
+        static_assert(container_expression<xarray<int>>);
+
+        xarray<int> x, y;
+        static_assert(!container_expression<decltype(x + y)>);
+        static_assert(container_expression<decltype(view(x, all()))>);
+        static_assert(!container_expression<decltype(view(2 * x, all()))>);
     }
 
     TEST(utils, has_strides)
     {
-        bool b = has_strides<xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<const xarray<int>>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<const xtensor<double, 2>>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<const xtensor_fixed<double, xshape<3, 4>>>::value;
-        EXPECT_TRUE(b);
+        static_assert(strided_expression<xarray<int>>);
+        static_assert(strided_expression<const xarray<int>>);
+        static_assert(strided_expression<const xtensor<double, 2>>);
+        static_assert(strided_expression<const xtensor_fixed<double, xshape<3, 4>>>);
 
         xarray<int> a = xarray<int>::from_shape({3, 4, 5});
         auto f = a + a - 23;
@@ -219,15 +163,12 @@ namespace xt
         auto vv2 = strided_view(v2, {all(), 2});
         auto v3 = strided_view(f, {all(), 2});
 
-        b = has_strides<decltype(v2)>::value;
-        EXPECT_TRUE(b);
-        b = has_strides<decltype(vv2)>::value;
-        EXPECT_TRUE(b);
+        static_assert(strided_expression<decltype(v2)>);
+        static_assert(strided_expression<decltype(vv2)>);
 
 #ifndef _MSC_VER
         // TODO fix this test for MSVC 2015!
-        b = has_strides<decltype(v3)>::value;
-        EXPECT_TRUE(b);
+        static_assert(strided_expression<decltype(v3)>);
 #endif
     }
 
@@ -263,18 +204,20 @@ namespace xt
 
     TEST(utils, allocation_tracking)
     {
-        using arr_t = xarray<double, layout_type::row_major,
-                             tracking_allocator<double, std::allocator<double>, alloc_tracking::policy::assert>>;
+        using arr_t = xarray<
+            double,
+            layout_type::row_major,
+            tracking_allocator<double, std::allocator<double>, alloc_tracking::policy::assert>>;
 
-        arr_t a = {{1,2,3}, {5,6,7}};
+        arr_t a = {{1, 2, 3}, {5, 6, 7}};
 
         alloc_tracking::enable();
-        EXPECT_THROW(arr_t b = a + 123, std::runtime_error);
-        EXPECT_NO_THROW(a.resize({2, 3}));
-        EXPECT_NO_THROW(a.resize({3, 2}));
-        EXPECT_THROW(a.resize({3, 15}), std::runtime_error);
+        XT_EXPECT_THROW(arr_t b = a + 123, std::runtime_error);
+        XT_EXPECT_NO_THROW(a.resize({2, 3}));
+        XT_EXPECT_NO_THROW(a.resize({3, 2}));
+        XT_EXPECT_THROW(a.resize({3, 15}), std::runtime_error);
         alloc_tracking::disable();
-        EXPECT_NO_THROW(arr_t c = a);
+        XT_EXPECT_NO_THROW(arr_t c = a);
     }
 
     TEST(utils, static_dimension)
diff --git a/test/test_xvectorize.cpp b/test/test_xvectorize.cpp
index 4c0f0ce1b..69fa400dc 100644
--- a/test/test_xvectorize.cpp
+++ b/test/test_xvectorize.cpp
@@ -1,15 +1,16 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
-#include "gtest/gtest.h"
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/core/xvectorize.hpp"
 
-#include "xtensor/xarray.hpp"
-#include "xtensor/xvectorize.hpp"
+#include "test_common_macros.hpp"
 
 namespace xt
 {
@@ -32,7 +33,10 @@ namespace xt
 
     TEST(xvectorize, lambda)
     {
-        auto lambda = [](double d1, double d2) { return d1 + d2; };
+        auto lambda = [](double d1, double d2)
+        {
+            return d1 + d2;
+        };
         auto vec_lambda = vectorize(lambda);
         shape_type shape = {3, 2};
         xarray<double> a(shape, 1.5);
@@ -62,7 +66,12 @@ namespace xt
 
     TEST(xvectorize, noargument)
     {
-        auto vecfunc = vectorize([] { return double(1.); });
+        auto vecfunc = vectorize(
+            []
+            {
+                return double(1.);
+            }
+        );
         shape_type shape = {3, 2};
         xarray<double> a(shape, 1.5);
         a = vecfunc();
diff --git a/test/test_xview.cpp b/test/test_xview.cpp
index d8646559a..6547b9df1 100644
--- a/test/test_xview.cpp
+++ b/test/test_xview.cpp
@@ -1,25 +1,36 @@
 /***************************************************************************
-* 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. *
-****************************************************************************/
+ * 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. *
+ ****************************************************************************/
 
 #include <algorithm>
 
-#include "gtest/gtest.h"
-
-#include "xtensor/xarray.hpp"
-#include "xtensor/xbuilder.hpp"
-#include "xtensor/xfixed.hpp"
-#include "xtensor/xnoalias.hpp"
-#include "xtensor/xstrided_view.hpp"
-#include "xtensor/xmanipulation.hpp"
-#include "xtensor/xtensor.hpp"
-#include "xtensor/xview.hpp"
-#include "xtensor/xrandom.hpp"
-
+#include "test_common_macros.hpp"
+
+// Workaround to avoid warnings regarding initialization
+// of distribution internal variables
+#if (defined(__GNUC__) && !defined(__clang__))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#include "xtensor/generators/xgenerator.hpp"
+#pragma GCC diagnostic pop
+#else
+#endif
+
+#include "xtensor/containers/xarray.hpp"
+#include "xtensor/containers/xfixed.hpp"
+#include "xtensor/containers/xtensor.hpp"
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/generators/xbuilder.hpp"
+#include "xtensor/generators/xrandom.hpp"
+#include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/views/index_mapper.hpp"
+#include "xtensor/views/xstrided_view.hpp"
+#include "xtensor/views/xview.hpp"
 
 namespace xt
 {
@@ -44,7 +55,8 @@ namespace xt
             view_shape_type shape = {3, 4};
             xarray<double> a(shape);
             auto view1 = view(a, 1, range(1, 4));
-            bool check = std::is_same<xarray<double>, typename xcontainer_inner_types<decltype(view1)>::temporary_type>::value;
+            bool check = std::
+                is_same<xarray<double>, typename xcontainer_inner_types<decltype(view1)>::temporary_type>::value;
             EXPECT_TRUE(check);
         }
 
@@ -52,11 +64,15 @@ namespace xt
             xtensor<double, 2>::shape_type shape = {3, 4};
             xtensor<double, 2> a(shape);
             auto view1 = view(a, 1, range(1, 4));
-            bool check1 = std::is_same<xtensor<double, 1>, typename xcontainer_inner_types<decltype(view1)>::temporary_type>::value;
+            bool check1 = std::is_same<
+                xtensor<double, 1>,
+                typename xcontainer_inner_types<decltype(view1)>::temporary_type>::value;
             EXPECT_TRUE(check1);
 
             auto view2 = view(a, all(), newaxis(), range(1, 4));
-            bool check2 = std::is_same<xtensor<double, 3>, typename xcontainer_inner_types<decltype(view2)>::temporary_type>::value;
+            bool check2 = std::is_same<
+                xtensor<double, 3>,
+                typename xcontainer_inner_types<decltype(view2)>::temporary_type>::value;
             EXPECT_TRUE(check2);
         }
     }
@@ -72,24 +88,24 @@ namespace xt
         EXPECT_EQ(a(1, 1), view1(0));
         EXPECT_EQ(a(1, 2), view1(1));
         EXPECT_EQ(size_t(1), view1.dimension());
-        EXPECT_ANY_THROW(view1.at(10));
-        EXPECT_ANY_THROW(view1.at(0, 0));
+        XT_EXPECT_ANY_THROW(view1.at(10));
+        XT_EXPECT_ANY_THROW(view1.at(0, 0));
 
         auto view0 = view(a, 0, range(0, 3));
         EXPECT_EQ(a(0, 0), view0(0));
         EXPECT_EQ(a(0, 1), view0(1));
         EXPECT_EQ(size_t(1), view0.dimension());
-        EXPECT_EQ(size_t(3), view0.shape()[0]);
+        EXPECT_EQ(size_t(3), view0.shape(0));
 
         auto view2 = view(a, range(0, 2), 2);
         EXPECT_EQ(a(0, 2), view2(0));
         EXPECT_EQ(a(1, 2), view2(1));
         EXPECT_EQ(size_t(1), view2.dimension());
-        EXPECT_EQ(size_t(2), view2.shape()[0]);
+        EXPECT_EQ(size_t(2), view2.shape(0));
 
         auto view4 = view(a, 1);
         EXPECT_EQ(size_t(1), view4.dimension());
-        EXPECT_EQ(size_t(4), view4.shape()[0]);
+        EXPECT_EQ(size_t(4), view4.shape(0));
 
         auto view5 = view(view4, 1);
         EXPECT_EQ(size_t(0), view5.dimension());
@@ -128,15 +144,152 @@ namespace xt
         }
     }
 
+    TEST(xview_mapping, simple)
+    {
+        view_shape_type shape = {3, 4};
+        xarray<double> a(shape);
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
+
+        auto view1 = view(a, 1, range(1, 4));
+
+        index_mapper<decltype(view1)> mapper1;
+
+        EXPECT_EQ(a(1, 1), mapper1.map(a, view1, 0));
+        EXPECT_EQ(a(1, 2), mapper1.map(a, view1, 1));
+        EXPECT_EQ(size_t(1), mapper1.dimension(a));
+        XT_EXPECT_ANY_THROW(mapper1.map_at(a, view1, 10));
+
+        auto view0 = view(a, 0, range(0, 3));
+        index_mapper<decltype(view0)> mapper0;
+
+        EXPECT_EQ(a(0, 0), mapper0.map(a, view0, 0));
+        EXPECT_EQ(a(0, 1), mapper0.map(a, view0, 1));
+        EXPECT_EQ(size_t(1), mapper0.dimension(a));
+
+        auto view2 = view(a, range(0, 2), 2);
+        index_mapper<decltype(view2)> mapper2;
+        EXPECT_EQ(a(0, 2), mapper2.map(a, view2, 0));
+        EXPECT_EQ(a(1, 2), mapper2.map(a, view2, 1));
+        EXPECT_EQ(size_t(1), mapper2.dimension(a));
+
+        auto view4 = view(a, 1);
+        index_mapper<decltype(view4)> mapper4;
+        EXPECT_EQ(size_t(1), mapper4.dimension(a));
+
+        auto view5 = view(view4, 1);
+        index_mapper<decltype(view5)> mapper5;
+        EXPECT_EQ(size_t(0), mapper5.dimension(view4));
+
+        auto view6 = view(a, 1, all());
+        index_mapper<decltype(view6)> mapper6;
+        EXPECT_EQ(a(1, 0), mapper6.map(a, view6, 0));
+        EXPECT_EQ(a(1, 1), mapper6.map(a, view6, 1));
+        EXPECT_EQ(a(1, 2), mapper6.map(a, view6, 2));
+        EXPECT_EQ(a(1, 3), mapper6.map(a, view6, 3));
+
+        auto view7 = view(a, all(), 2);
+        index_mapper<decltype(view7)> mapper7;
+        EXPECT_EQ(a(0, 2), mapper7.map(a, view7, 0));
+        EXPECT_EQ(a(1, 2), mapper7.map(a, view7, 1));
+        EXPECT_EQ(a(2, 2), mapper7.map(a, view7, 2));
+    }
+
+    TEST(xview_mapping, indices)
+    {
+        xarray<double> a = {{1., 2., 3.}, {4., 5., 6.}};
+
+        auto view1 = view(a, all(), all());
+        index_mapper<decltype(view1)> mapper1;
+
+        EXPECT_EQ(a(0, 2), mapper1.map(a, view1, 0, 2));
+        EXPECT_EQ(a(0, 2), mapper1.map(a, view1, 2));
+        EXPECT_EQ(a(1, 2), mapper1.map(a, view1, 1, 1, 2));
+
+        auto view2 = view(a, all());
+        index_mapper<decltype(view2)> mapper2;
+
+        EXPECT_EQ(a(0, 2), mapper2.map(a, view2, 0, 2));
+        EXPECT_EQ(a(0, 2), mapper2.map(a, view2, 2));
+        EXPECT_EQ(a(1, 2), mapper2.map(a, view2, 1, 1, 2));
+    }
+
+    TEST(xview, negative_index)
+    {
+        view_shape_type shape = {3, 4};
+        xarray<double> a(shape);
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
+
+        auto view0 = view(a, -2, range(1, 4));
+        auto view1 = view(a, 1, range(1, 4));
+        EXPECT_EQ(view0, view1);
+    }
+
+    TEST(xview, negative_step)
+    {
+        view_shape_type shape = {3, 4};
+        xarray<double> a(shape);
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
+
+        auto view0 = view(a, 1, range(3, 0, -1));
+        EXPECT_EQ(size_t(1), view0.dimension());
+        EXPECT_EQ(size_t(3), view0.shape(0));
+        EXPECT_EQ(a(1, 3), view0(0));
+        EXPECT_EQ(a(1, 2), view0(1));
+        EXPECT_EQ(a(1, 1), view0(2));
+    }
+
+    TEST(xview, size_zero)
+    {
+        view_shape_type shape = {3, 4};
+        xarray<double> a(shape);
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
+
+        auto view0 = view(a, 1, range(0, 0));
+        EXPECT_EQ(size_t(1), view0.dimension());
+        EXPECT_EQ(size_t(0), view0.shape(0));
+
+        auto view1 = view(a, 1, range(3, 0, 1));
+        EXPECT_EQ(size_t(1), view1.dimension());
+        EXPECT_EQ(size_t(0), view1.shape(0));
+
+        auto view2 = view(a, 1, range(0, 3, -1));
+        EXPECT_EQ(size_t(1), view2.dimension());
+        EXPECT_EQ(size_t(0), view2.shape(0));
+    }
+
+    TEST(xview, stored_range)
+    {
+        view_shape_type shape = {3, 4};
+        xarray<double> a(shape);
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+        std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
+
+        auto r0 = range(1, 3);
+        auto r1 = range(0, 3);
+        auto view0 = view(a, r0, r1);
+
+        view0 += xt::ones<double>({2, 3});
+        EXPECT_EQ(a(1, 0), 6);
+        EXPECT_EQ(a(1, 1), 7);
+        EXPECT_EQ(a(1, 2), 8);
+        EXPECT_EQ(a(2, 0), 10);
+        EXPECT_EQ(a(2, 1), 11);
+        EXPECT_EQ(a(2, 2), 12);
+    }
+
     TEST(xview, copy_semantic)
     {
-        view_shape_type shape = { 3, 4 };
+        view_shape_type shape = {3, 4};
         xarray<double> a(shape);
-        std::vector<double> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             auto view1 = view(a, 1, range(1, 4));
             auto view2(view1);
             EXPECT_EQ(a(1, 1), view2(0));
@@ -152,8 +305,8 @@ namespace xt
             }
         }
 
+        SUBCASE("copy assignment operator")
         {
-            SCOPED_TRACE("copy assignment operator");
             auto view1 = view(a, 1, range(1, 4));
             auto view2 = view(a, 2, range(0, 3));
             view2 = view1;
@@ -165,13 +318,13 @@ namespace xt
 
     TEST(xview, move_semantic)
     {
-        view_shape_type shape = { 3, 4 };
+        view_shape_type shape = {3, 4};
         xarray<double> a(shape);
-        std::vector<double> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
+        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
+        SUBCASE("copy constructor")
         {
-            SCOPED_TRACE("copy constructor");
             auto view1 = view(a, 1, range(1, 4));
             auto view2(std::move(view1));
             EXPECT_EQ(a(1, 1), view2(0));
@@ -187,8 +340,8 @@ namespace xt
             }
         }
 
+        SUBCASE("copy assignment operator")
         {
-            SCOPED_TRACE("copy assignment operator");
             auto view1 = view(a, 1, range(1, 4));
             auto view2 = view(a, 2, range(0, 3));
             view2 = std::move(view1);
@@ -201,22 +354,11 @@ namespace xt
     TEST(xview, three_dimensional)
     {
         view_shape_type shape = {3, 4, 2};
-        std::vector<double> data = {
-            1, 2,
-            3, 4,
-            5, 6,
-            7, 8,
-
-            9, 10,
-            11, 12,
-            21, 22,
-            23, 24,
-
-            25, 26,
-            27, 28,
-            29, 210,
-            211, 212
-        };
+        std::vector<double> data = {1,  2,  3,  4,  5,  6,   7,   8,
+
+                                    9,  10, 11, 12, 21, 22,  23,  24,
+
+                                    25, 26, 27, 28, 29, 210, 211, 212};
         xarray<double> a(shape);
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
@@ -226,13 +368,45 @@ namespace xt
         EXPECT_EQ(a(1, 0, 1), view1(0, 1));
         EXPECT_EQ(a(1, 1, 0), view1(1, 0));
         EXPECT_EQ(a(1, 1, 1), view1(1, 1));
-        EXPECT_ANY_THROW(view1.at(10, 10));
-        EXPECT_ANY_THROW(view1.at(0, 0, 0));
+        XT_EXPECT_ANY_THROW(view1.at(10, 10));
+        XT_EXPECT_ANY_THROW(view1.at(0, 0, 0));
 
         std::array<std::size_t, 2> idx = {1, 1};
         EXPECT_EQ(a(1, 1, 1), view1.element(idx.cbegin(), idx.cend()));
     }
 
+    TEST(xview_mapping, three_dimensional)
+    {
+        view_shape_type shape = {3, 4, 2};
+        std::vector<double> data = {1,  2,  3,  4,  5,  6,   7,   8,
+
+                                    9,  10, 11, 12, 21, 22,  23,  24,
+
+                                    25, 26, 27, 28, 29, 210, 211, 212};
+        xarray<double> a(shape);
+        std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
+
+        auto view1 = view(a, 1, all(), all());
+        index_mapper<decltype(view1)> mapper1;
+
+        EXPECT_EQ(size_t(2), mapper1.dimension(a));
+        EXPECT_EQ(a(1, 0, 0), mapper1.map(a, view1, 0, 0));
+        EXPECT_EQ(a(1, 0, 1), mapper1.map(a, view1, 0, 1));
+        EXPECT_EQ(a(1, 1, 0), mapper1.map(a, view1, 1, 0));
+        EXPECT_EQ(a(1, 1, 1), mapper1.map(a, view1, 1, 1));
+        XT_EXPECT_ANY_THROW(mapper1.map_at(a, view1, 10, 10));
+
+        auto view2 = view(a, 1);
+        index_mapper<decltype(view2)> mapper2;
+
+        EXPECT_EQ(size_t(2), mapper2.dimension(a));
+        EXPECT_EQ(a(1, 0, 0), mapper2.map(a, view2, 0, 0));
+        EXPECT_EQ(a(1, 0, 1), mapper2.map(a, view2, 0, 1));
+        EXPECT_EQ(a(1, 1, 0), mapper2.map(a, view2, 1, 0));
+        EXPECT_EQ(a(1, 1, 1), mapper2.map(a, view2, 1, 1));
+        XT_EXPECT_ANY_THROW(mapper2.map_at(a, view2, 10, 10));
+    }
+
     TEST(xview, integral_count)
     {
         size_t squeeze1 = integral_count<size_t, size_t, size_t, xrange<size_t>>();
@@ -267,13 +441,9 @@ namespace xt
 
     TEST(xview, temporary_view)
     {
-        xt::xarray<double> arr1
-         {{1.0, 2.0, 3.0},
-          {2.0, 5.0, 7.0},
-          {2.0, 5.0, 7.0}};
+        xt::xarray<double> arr1{{1.0, 2.0, 3.0}, {2.0, 5.0, 7.0}, {2.0, 5.0, 7.0}};
 
-        xt::xarray<double> arr2
-         {5.0, 6.0, 7.0};
+        xt::xarray<double> arr2{5.0, 6.0, 7.0};
 
         xt::xarray<double> res = xt::view(arr1, 1) + arr2;
         EXPECT_EQ(7., res(0));
@@ -283,10 +453,7 @@ namespace xt
 
     TEST(xview, access)
     {
-        xt::xarray<double> arr
-        {{ 1.0, 2.0, 3.0 },
-         { 2.0, 5.0, 7.0 },
-         { 2.0, 5.0, 7.0 }};
+        xt::xarray<double> arr{{1.0, 2.0, 3.0}, {2.0, 5.0, 7.0}, {2.0, 5.0, 7.0}};
 
         auto v1 = xt::view(arr, 1, xt::range(1, 3));
         EXPECT_EQ(v1(), arr(0, 1));
@@ -294,22 +461,45 @@ namespace xt
         EXPECT_EQ(v1(1, 1), arr(1, 2));
 
         auto v2 = xt::view(arr, all(), newaxis(), all());
-        //EXPECT_EQ(v2(1), arr(0, 1));
+        // EXPECT_EQ(v2(1), arr(0, 1));
         EXPECT_EQ(v2(1, 0, 2), arr(1, 2));
         EXPECT_EQ(v2(2, 1, 0, 2), arr(1, 2));
 
         auto v3 = xt::view(arr, xt::range(0, 2), xt::range(1, 3));
-        //EXPECT_EQ(v3(1), arr(0, 2));
+        // EXPECT_EQ(v3(1), arr(0, 2));
         EXPECT_EQ(v3(1, 1), arr(1, 2));
         EXPECT_EQ(v3(2, 3, 1, 1), arr(1, 2));
     }
 
+    TEST(xview_mapping, access)
+    {
+        xt::xarray<double> arr{{1.0, 2.0, 3.0}, {2.0, 5.0, 7.0}, {2.0, 5.0, 7.0}};
+
+        auto v1 = xt::view(arr, 1, xt::range(1, 3));
+        index_mapper<decltype(v1)> mapper1;
+
+        EXPECT_EQ(mapper1.map(arr, v1), arr(0, 1));
+        EXPECT_EQ(mapper1.map(arr, v1, 1), arr(1, 2));
+        EXPECT_EQ(mapper1.map(arr, v1, 1, 1), arr(1, 2));
+
+        auto v2 = xt::view(arr, all(), newaxis(), all());
+        index_mapper<decltype(v2)> mapper2;
+
+        // EXPECT_EQ(v2(1), arr(0, 1));
+        EXPECT_EQ(mapper2.map(arr, v2, 1, 0, 2), arr(1, 2));
+        EXPECT_EQ(mapper2.map(arr, v2, 2, 1, 0, 2), arr(1, 2));
+
+        auto v3 = xt::view(arr, xt::range(0, 2), xt::range(1, 3));
+        index_mapper<decltype(v3)> mapper3;
+
+        // EXPECT_EQ(v3(1), arr(0, 2));
+        EXPECT_EQ(mapper3.map(arr, v3, 1, 1), arr(1, 2));
+        EXPECT_EQ(mapper3.map(arr, v3, 2, 3, 1, 1), arr(1, 2));
+    }
+
     TEST(xview, unchecked)
     {
-        xt::xarray<double> arr
-        { { 1.0, 2.0, 3.0 },
-        { 2.0, 5.0, 7.0 },
-        { 2.0, 5.0, 7.0 } };
+        xt::xarray<double> arr{{1.0, 2.0, 3.0}, {2.0, 5.0, 7.0}, {2.0, 5.0, 7.0}};
 
         auto v1 = xt::view(arr, 1, xt::range(1, 3));
         EXPECT_EQ(v1.unchecked(1), arr(1, 2));
@@ -325,7 +515,7 @@ namespace xt
     {
         view_shape_type shape = {2, 3, 4};
         xarray<double, layout_type::row_major> a(shape);
-        std::vector<double> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+        std::vector<double> data = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
                                     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
@@ -364,13 +554,13 @@ namespace xt
 
     TEST(xview, fill)
     {
-        view_shape_type shape = { 2, 3, 4 };
+        view_shape_type shape = {2, 3, 4};
         xarray<double, layout_type::row_major> a(shape), res(shape);
-        std::vector<double> data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-            13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24 };
+        std::vector<double> data = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
+                                    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
-        std::vector<double> data_res = { 1, 2, 3, 4, 5, 4, 4, 4, 9, 10, 11, 12,
-            13, 14, 15, 16, 17, 4, 4, 4, 21, 22, 23, 24 };
+        std::vector<double> data_res = {1,  2,  3,  4,  5,  4, 4, 4, 9,  10, 11, 12,
+                                        13, 14, 15, 16, 17, 4, 4, 4, 21, 22, 23, 24};
         std::copy(data_res.cbegin(), data_res.cend(), res.template begin<layout_type::row_major>());
         auto view1 = view(a, range(0, 2), 1, range(1, 4));
         view1.fill(4);
@@ -382,7 +572,7 @@ namespace xt
         view_shape_type shape = {2, 3, 4};
         xarray<double, layout_type::row_major> a(shape);
         std::vector<double> data = {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12,
-            13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
+                                    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
         std::copy(data.cbegin(), data.cend(), a.template begin<layout_type::row_major>());
 
         auto view1 = view(a, range(0, 2), 1, range(1, 4));
@@ -477,6 +667,7 @@ namespace xt
         EXPECT_EQ(v2, 3);
 
         auto it = a2.begin();
+        EXPECT_EQ(*it, v2);
     }
 
     TEST(xview, trivial_iterating)
@@ -523,7 +714,9 @@ namespace xt
         EXPECT_EQ(count1, size_t(3));
         size_t count2 = newaxis_count<xnewaxis<size_t>, xrange<size_t>, xnewaxis<size_t>>();
         EXPECT_EQ(count2, size_t(2));
-        size_t count3 = newaxis_count_before<xnewaxis<size_t>, xnewaxis<size_t>, xnewaxis<size_t>, xrange<size_t>>(3);
+        size_t count3 = newaxis_count_before<xnewaxis<size_t>, xnewaxis<size_t>, xnewaxis<size_t>, xrange<size_t>>(
+            3
+        );
         EXPECT_EQ(count3, size_t(3));
         size_t count4 = newaxis_count_before<xnewaxis<size_t>, xrange<size_t>, xnewaxis<size_t>>(2);
         EXPECT_EQ(count4, size_t(1));
@@ -578,8 +771,13 @@ namespace xt
         std::array<std::size_t, 3> idx2 = {1, 2, 0};
         EXPECT_EQ(a(1, 2), view2.element(idx2.begin(), idx2.end()));
 
-        std::array<std::size_t, 3> idx3 = {1, 2};
+        std::array<std::size_t, 2> idx3 = {1, 2};
         EXPECT_EQ(a(1, 2), view3.element(idx3.begin(), idx3.end()));
+
+        xt::xarray<float> x5 = xt::ones<float>({1, 4, 16, 16});
+        auto view7 = xt::view(x5, xt::all(), xt::newaxis(), xt::all(), xt::all(), xt::all());
+        std::array<std::size_t, 5> idx4 = {0, 0, 2, 14, 12};
+        EXPECT_EQ(view7.element(idx4.begin(), idx4.end()), 1.f);
     }
 
     TEST(xview, newaxis_iterating)
@@ -764,16 +962,14 @@ namespace xt
 
     TEST(xview, strides_type)
     {
-        xt::xtensor<float, 2> a{
-            { 1, 2 },
-            { 3, 4 },
-            { 5, 6 }
-        };
+        xt::xtensor<float, 2> a{{1, 2}, {3, 4}, {5, 6}};
         auto row = xt::view(a, 1, xt::all());
         if (a.layout() == layout_type::row_major)
         {
             bool cond1 = std::is_same<decltype(row)::strides_type, std::array<std::ptrdiff_t, 1>>::value;
-            bool cond2 = std::is_same<decltype(row.strides()), const xt::sequence_view<std::array<std::ptrdiff_t, 2>, 1, 2>&>::value;
+            bool cond2 = std::is_same<
+                decltype(row.strides()),
+                const xt::sequence_view<std::array<std::ptrdiff_t, 2>, 1, 2>&>::value;
             EXPECT_TRUE(cond1);
             EXPECT_TRUE(cond2);
         }
@@ -809,10 +1005,10 @@ namespace xt
 
         EXPECT_FALSE(broadcastable(v.shape(), b.shape()));
         EXPECT_FALSE(broadcastable(b.shape(), v.shape()));
-        EXPECT_THROW(assert_compatible_shape(b, v), broadcast_error);
-        EXPECT_THROW(assert_compatible_shape(v, b), broadcast_error);
-        EXPECT_THROW(v = b, broadcast_error);
-        EXPECT_THROW(noalias(v) = b, broadcast_error);
+        XT_EXPECT_THROW(assert_compatible_shape(b, v), broadcast_error);
+        XT_EXPECT_THROW(assert_compatible_shape(v, b), broadcast_error);
+        XT_EXPECT_THROW(v = b, broadcast_error);
+        XT_EXPECT_THROW(noalias(v) = b, broadcast_error);
     }
 
     TEST(xview, strides)
@@ -856,7 +1052,7 @@ namespace xt
 
     TEST(xview, to_scalar)
     {
-        std::array<std::size_t, 3> sh{2,2,2};
+        std::array<std::size_t, 3> sh{2, 2, 2};
         xtensor<double, 3> a(sh, 123);
         xtensor_fixed<double, xshape<2, 2, 2>> af = a;
         xarray<double> b = a;
@@ -884,7 +1080,7 @@ namespace xt
         ax = is_xscalar<decltype(afv1)>::value;
         EXPECT_TRUE(ax);
 
-        const xtensor<double, 2> ac = {{1,2}, {3,4}};
+        const xtensor<double, 2> ac = {{1, 2}, {3, 4}};
         double a1 = view(ac, 0, 0);
         const double& a2 = view(ac, 0, 0);
 
@@ -907,7 +1103,8 @@ namespace xt
 
         auto citer_expv1 = exp.template begin<layout_type::column_major>();
         for (auto iter = v.template begin<layout_type::column_major>();
-            iter != v.template end<layout_type::column_major>(); ++iter)
+             iter != v.template end<layout_type::column_major>();
+             ++iter)
         {
             EXPECT_EQ(*iter, *citer_expv1);
             ++citer_expv1;
@@ -920,39 +1117,32 @@ namespace xt
             ++riter_expv1;
         }
 
-        auto rciter_expv1 = exp.template rbegin<layout_type::column_major>();
+        // TODO: this test cannot pass for views containing squeezes of
+        // keep slices with a single element. This is NOT trivial to fix,
+        // but this use case is not that common.
+        /*auto rciter_expv1 = exp.template rbegin<layout_type::column_major>();
         for (auto iter = v.template rbegin<layout_type::column_major>();
              iter != v.template rend<layout_type::column_major>(); ++iter)
         {
             EXPECT_EQ(*iter, *rciter_expv1);
             ++rciter_expv1;
-        }
+        }*/
     }
 
     TEST(xview, random_stepper)
     {
-        xt::xarray<double> x = xt::arange(0, 100);
-        x.reshape({5, 5, 4});
+        xt::xarray<double, layout_type::row_major> data = xt::arange(0, 100);
+        data.reshape({5, 5, 4});
+        xt::xarray<double> x = data;
 
         xt::xarray<double> expected;
-        if (XTENSOR_DEFAULT_LAYOUT == layout_type::row_major)
+        if (XTENSOR_DEFAULT_TRAVERSAL == layout_type::row_major)
         {
-           expected = {
-               0, 1, 2, 3,
-               20, 21, 22, 23,
-               40, 41, 42, 43,
-               60, 61, 62, 63,
-               80, 81, 82, 83
-           };
+            expected = {0, 1, 2, 3, 20, 21, 22, 23, 40, 41, 42, 43, 60, 61, 62, 63, 80, 81, 82, 83};
         }
         else
         {
-           expected = {
-               0, 1, 2, 3, 4,
-               25, 26, 27, 28, 29,
-               50, 51, 52, 53, 54,
-               75, 76, 77, 78, 79
-           };
+            expected = {0, 1, 2, 3, 4, 25, 26, 27, 28, 29, 50, 51, 52, 53, 54, 75, 76, 77, 78, 79};
         }
         auto v = xt::view(x, all(), 0);
 
@@ -969,17 +1159,16 @@ namespace xt
 
     TEST(xview, keep_slice)
     {
-        xtensor<double, 3, layout_type::row_major> a = {{{ 1, 2, 3, 4},
-                                                         { 5, 6, 7, 8}},
-                                                        {{ 9,10,11,12},
-                                                         {13,14,15,16}},
-                                                        {{17,18,19,20},
-                                                         {21,22,23,24}}};
+        xtensor<double, 3, layout_type::row_major> a = {
+            {{1, 2, 3, 4}, {5, 6, 7, 8}},
+            {{9, 10, 11, 12}, {13, 14, 15, 16}},
+            {{17, 18, 19, 20}, {21, 22, 23, 24}}
+        };
 
         auto v1 = xt::view(a, keep(1), keep(0, 1), keep(0, 3));
         xtensor<double, 3> exp_v1 = {{{9, 12}, {13, 16}}};
-        EXPECT_EQ(v1, exp_v1);
 
+        EXPECT_EQ(v1, exp_v1);
         test_view_iter(v1, exp_v1);
 
         auto v2 = xt::view(a, keep(1), xt::all(), xt::range(0, xt::xnone(), 3));
@@ -993,14 +1182,13 @@ namespace xt
         test_view_iter(v3, exp_v3);
 
         auto v4 = xt::view(a, keep(0, 2), keep(0));
-        xtensor<double, 3> exp_v4 = {{{  1.,   2.,   3.,   4.}},
-                                     {{ 17.,  18.,  19.,  20.}}};
+        xtensor<double, 3> exp_v4 = {{{1., 2., 3., 4.}}, {{17., 18., 19., 20.}}};
         EXPECT_EQ(v4, exp_v4);
 
         v4(0, 0) = 123;
-        v4(1, 0) = 123;
+        v4(1, 0, 0) = 123;
         EXPECT_EQ(a(0, 0, 0), 123);
-        EXPECT_EQ(a(1, 0, 0), 123);
+        EXPECT_EQ(a(2, 0, 0), 123);
 
         v3(0, 2, 1) = 1000;
         EXPECT_EQ(a(1, 1, 3), 1000);
@@ -1013,29 +1201,36 @@ namespace xt
 
     TEST(xview, keep_negative)
     {
-        xtensor<double, 3, layout_type::row_major> a = {{{ 1, 2, 3, 4},
-                                                         { 5, 6, 7, 8}},
-                                                        {{ 9,10,11,12},
-                                                         {13,14,15,16}},
-                                                        {{17,18,19,20},
-                                                         {21,22,23,24}}};
+        xtensor<double, 3, layout_type::row_major> a = {
+            {{1, 2, 3, 4}, {5, 6, 7, 8}},
+            {{9, 10, 11, 12}, {13, 14, 15, 16}},
+            {{17, 18, 19, 20}, {21, 22, 23, 24}}
+        };
 
         auto v1 = xt::view(a, keep(-2), keep(-0, -1), keep(0, -1));
         xtensor<double, 3> exp_v1 = {{{9, 12}, {13, 16}}};
         EXPECT_EQ(v1, exp_v1);
     }
 
+    TEST(xview, keep_broadcast)
+    {
+        xtensor<int, 2> a = {{0, 1}, {2, 3}};
+        xtensor<int, 2> b = {{4, 5}, {7, 8}};
+        xtensor<int, 2> res = xt::view(a, xt::keep(0), xt::all()) + b;
+        xtensor<int, 2> exp = {{4, 6}, {7, 9}};
+        EXPECT_EQ(res, exp);
+    }
+
     TEST(xview, drop_slice)
     {
-        xtensor<double, 3, layout_type::row_major> a = {{{ 1, 2, 3, 4},
-                                                         { 5, 6, 7, 8}},
-                                                        {{ 9,10,11,12},
-                                                         {13,14,15,16}},
-                                                        {{17,18,19,20},
-                                                         {21,22,23,24}}};
+        xtensor<double, 3, layout_type::row_major> a = {
+            {{1, 2, 3, 4}, {5, 6, 7, 8}},
+            {{9, 10, 11, 12}, {13, 14, 15, 16}},
+            {{17, 18, 19, 20}, {21, 22, 23, 24}}
+        };
 
         auto v1 = xt::view(a, drop(0, 2), keep(0, 1), drop(1, 2));
-        xtensor<double, 3> exp_v1 = { { { 9, 12 },{ 13, 16 } } };
+        xtensor<double, 3> exp_v1 = {{{9, 12}, {13, 16}}};
         EXPECT_EQ(v1, exp_v1);
         test_view_iter(v1, exp_v1);
 
@@ -1044,46 +1239,64 @@ namespace xt
         EXPECT_EQ(v2, exp_v1);
 
         auto v4 = xt::view(a, drop(1), drop(1));
-        xtensor<double, 3> exp_v4 = {{{ 1.,   2.,   3.,   4.}},
-                                     {{17.,  18.,  19.,  20.}}};
+        xtensor<double, 3> exp_v4 = {{{1., 2., 3., 4.}}, {{17., 18., 19., 20.}}};
         EXPECT_EQ(v4, exp_v4);
 
         v4(0, 0) = 123;
-        v4(1, 0) = 123;
+        v4(1, 0, 0) = 123;
         EXPECT_EQ(a(0, 0, 0), 123);
-        EXPECT_EQ(a(1, 0, 0), 123);
+        EXPECT_EQ(a(2, 0, 0), 123);
 
         bool b = detail::is_strided_view<decltype(a), xkeep_slice<int>, int>::value;
         EXPECT_FALSE(b);
         b = detail::is_strided_view<decltype(a), xrange<int>, xrange<int>, int>::value;
         EXPECT_TRUE(b);
+
+        std::vector<size_t> empty;
+        auto v5 = xt::view(a, drop(empty), drop(empty), drop(empty));
+        v5(1, 1, 1) = 456;
+        EXPECT_EQ(v5, a);
+        EXPECT_EQ(a(1, 1, 1), 456);
     }
 
     TEST(xview, drop_negative)
     {
-        xtensor<double, 3, layout_type::row_major> a = {{{ 1, 2, 3, 4},
-                                                         { 5, 6, 7, 8}},
-                                                        {{ 9,10,11,12},
-                                                         {13,14,15,16}},
-                                                        {{17,18,19,20},
-                                                         {21,22,23,24}}};
+        xtensor<double, 3, layout_type::row_major> a = {
+            {{1, 2, 3, 4}, {5, 6, 7, 8}},
+            {{9, 10, 11, 12}, {13, 14, 15, 16}},
+            {{17, 18, 19, 20}, {21, 22, 23, 24}}
+        };
 
-        //auto v1 = xt::view(a, keep(-2), keep(-0, -1), keep(0, -1));
+        // auto v1 = xt::view(a, keep(-2), keep(-0, -1), keep(0, -1));
         auto v1 = xt::view(a, drop(-3, -1), keep(0, 1), drop(-3, -2));
-        xtensor<double, 3> exp_v1 = { { { 9, 12 },{ 13, 16 } } };
+        xtensor<double, 3> exp_v1 = {{{9, 12}, {13, 16}}};
         EXPECT_EQ(v1, exp_v1);
     }
 
+    TEST(xview, const_keep_drop_slice)
+    {
+        xt::xtensor<double, 1> xs = xt::arange<double>(10);
+        const auto kidx = xt::keep(0, 3, 5);
+        const auto didx = xt::drop(1, 2, 4, 6, 7, 8, 9);
+        auto kv = xt::view(xs, kidx);
+        auto dv = xt::view(xs, didx);
+        xt::xtensor<double, 1> kres = kv;
+        xt::xtensor<double, 1> dres = dv;
+        xt::xtensor<double, 1> expected = {0., 3., 5.};
+        EXPECT_EQ(kres, expected);
+        EXPECT_EQ(dres, expected);
+    }
+
     TEST(xview, mixed_types)
     {
         xt::xarray<std::uint8_t> input;
         xt::xarray<float> output;
-        input.resize({ { 50,16,16,3 } });
-        output.resize({ { 50,16,16,3 } });
+        input.resize({{50, 16, 16, 3}});
+        output.resize({{50, 16, 16, 3}});
 
         input.fill(std::uint8_t(1));
         output.fill(float(2.));
-        for (int i = 0; i<50; ++i)
+        for (int i = 0; i < 50; ++i)
         {
             auto in_view = xt::view(input, i);
             auto out_view = xt::view(output, i);
@@ -1104,7 +1317,7 @@ namespace xt
 
         auto idx2 = xt::where(col > size_t(0));
         std::vector<std::size_t> exp_idx2 = {1, 2};
-        EXPECT_EQ(idx2.size(), 1);
+        EXPECT_EQ(idx2.size(), 1u);
         EXPECT_EQ(idx2[0], exp_idx2);
     }
 
@@ -1150,15 +1363,15 @@ namespace xt
     {
         using vector_type = std::vector<int>;
         using array_type = std::array<int, 7>;
-        auto a = vector_type({0,1,2,3,4,5,6});
-        auto b = array_type({0,1,2,3,4,5,6});
+        auto a = vector_type({0, 1, 2, 3, 4, 5, 6});
+        auto b = array_type({0, 1, 2, 3, 4, 5, 6});
 
         auto va = sequence_view<vector_type, 3>(a);
         auto vb = sequence_view<array_type, 3>(b);
 
         EXPECT_EQ(va[0], a[3]);
         EXPECT_EQ(va[1], a[4]);
-        EXPECT_EQ(*va.end(), *a.end());
+        EXPECT_EQ(va.end(), a.end());
         EXPECT_TRUE(std::equal(a.begin() + 3, a.end(), va.begin()));
         EXPECT_EQ(a.size() - 3, va.size());
 
@@ -1168,6 +1381,14 @@ namespace xt
         EXPECT_TRUE(std::equal(b.begin() + 3, b.end(), vb.begin()));
         EXPECT_EQ(b.size() - 3, vb.size());
 
+        vector_type cvta = va;
+        std::array<int, 4> cvtb = vb;
+        vector_type cvta_expected = {3, 4, 5, 6};
+        std::array<int, 4> cvtb_expected = {3, 4, 5, 6};
+
+        EXPECT_EQ(cvta, cvta_expected);
+        EXPECT_EQ(cvtb, cvtb_expected);
+
         auto vae = sequence_view<vector_type, 3, 5>(a);
         auto vbe = sequence_view<array_type, 3, 5>(b);
 
@@ -1206,8 +1427,6 @@ namespace xt
             ++rb_iter;
         }
         EXPECT_EQ(rb_iter, vbe.rend());
-
-
     }
 
     TEST(xview, data_offset)
@@ -1247,35 +1466,41 @@ namespace xt
 
             using assign_traits = xassign_traits<decltype(vxt), decltype(b)>;
 
-    #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits::convertible_types());
-            EXPECT_TRUE(assign_traits::simd_size());
-            EXPECT_FALSE(assign_traits::forbid_simd());
-            EXPECT_TRUE(assign_traits::simd_assign());
-    #endif
+#if XTENSOR_USE_XSIMD
+            EXPECT_TRUE(assign_traits::simd_linear_assign());
+#endif
 
             using assign_traits2 = xassign_traits<decltype(b), decltype(vxa)>;
 
-    #if XTENSOR_USE_XSIMD
-            EXPECT_TRUE(assign_traits2::convertible_types());
-            EXPECT_TRUE(assign_traits2::simd_size());
-            EXPECT_TRUE(assign_traits2::forbid_simd());
-            EXPECT_FALSE(assign_traits2::simd_assign());
-    #endif
+#if XTENSOR_USE_XSIMD
+            EXPECT_FALSE(assign_traits2::simd_linear_assign());
+#endif
         }
     }
 
-    xt::xtensor<double,2> view_assign_func(const xt::xtensor<double, 2>& a, int idx)
+    xt::xtensor<double, 2> view_assign_func(const xt::xtensor<double, 2>& a, int idx)
     {
         xt::xtensor<double, 2> b;
-        switch(idx)
+        switch (idx)
         {
-            case 1: b = xt::view(a,      xt::all(), xt::range(0, 1)); break;
-            case 2: b.assign(xt::view(a, xt::all(), xt::range(0, 1))); break;
-            case 3: b = xt::view(a,      xt::all(), xt::range(0, 2)); break;
-            case 4: b = 2.*xt::view(a,   xt::all(), xt::range(0, 1)); break;
-            case 5: b = xt::view(2.*a,   xt::all(), xt::range(0, 1)); break;
-            default: b = a; break;
+            case 1:
+                b = xt::view(a, xt::all(), xt::range(0, 1));
+                break;
+            case 2:
+                b.assign(xt::view(a, xt::all(), xt::range(0, 1)));
+                break;
+            case 3:
+                b = xt::view(a, xt::all(), xt::range(0, 2));
+                break;
+            case 4:
+                b = 2. * xt::view(a, xt::all(), xt::range(0, 1));
+                break;
+            case 5:
+                b = xt::view(2. * a, xt::all(), xt::range(0, 1));
+                break;
+            default:
+                b = a;
+                break;
         }
         return b;
     }
@@ -1298,9 +1523,9 @@ namespace xt
     TEST(xview, view_on_strided_view)
     {
         // Compilation test only
-        xt::xarray<float> original = xt::xarray<float>::from_shape({ 3, 2, 5 });
+        xt::xarray<float> original = xt::xarray<float>::from_shape({3, 2, 5});
         original.fill(float(0.));
-        auto str_view = xt::strided_view(original, { 1, xt::ellipsis() }); //i is an int
+        auto str_view = xt::strided_view(original, {1, xt::ellipsis()});  // i is an int
         auto result = xt::view(str_view, xt::all(), xt::all());
         EXPECT_EQ(result(0), 0.f);
     }
@@ -1312,4 +1537,382 @@ namespace xt
         auto v = xt::view(arr, xt::keep(0, -1), xt::all());
         v = 0;
     }
+
+    TEST(xview, assign_scalar_to_contiguous_view_of_view)
+    {
+        xt::xarray<double> arr{{0., 1., 2.}, {3., 4., 5.}, {6., 7., 8.}};
+        auto vv = xt::view(xt::view(arr, 1), 0);
+        vv = 100.0;
+        EXPECT_EQ(arr(1, 0), 100.0);
+    }
+
+    TEST(xview, keep_assign)
+    {
+        xt::xtensor<int, 2> a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
+
+        auto v = xt::view(xt::view(a, xt::all(), xt::keep(0, 1)), xt::all(), 0);
+        xt::xtensor<int, 1> res = v;
+
+        xt::xtensor<int, 1> exp = {1, 5, 9, 13};
+        EXPECT_EQ(res, exp);
+    }
+
+    TEST(xview, view_view_assignment)
+    {
+        xt::xtensor<double, 4> a = xt::random::rand<double>({5, 5, 5, 5});
+
+        std::size_t sa = 0, sb = 2;
+        auto start = xt::view(a, 1);  // 3D
+        auto res = xt::view(start, xt::all(), xt::all(), xt::keep(sa, sb));
+
+        auto expres = xt::exp(res);
+
+        xt::xarray<double> assgment = expres;
+        auto expv = xt::exp(xt::view(a, 1, xt::all(), xt::all(), xt::range(0, 3, 2)));
+        EXPECT_EQ(assgment, expv);
+    }
+
+    TEST(xview, view_on_fixed)
+    {
+        xt::xtensor_fixed<double, xt::xshape<3>> a{1. / 8, 1, -1. / 8};
+        auto v = xt::view(a, xt::all(), xt::newaxis());
+        EXPECT_EQ(v.dimension(), 2u);
+        EXPECT_EQ(v.shape(), (std::array<std::size_t, 2>{3, 1}));
+
+        auto b = a * xt::view(a, xt::all(), xt::newaxis());
+
+        xt::xarray<double> exp = {{0.015625, 0.125, -0.015625}, {0.125, 1., -0.125}, {-0.015625, -0.125, 0.015625}};
+
+        EXPECT_EQ(b, exp);
+    }
+
+    TEST(xview, periodic)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+        xt::xtensor<size_t, 2> b = {{0, 1, 2}, {30, 40, 50}};
+        auto view = xt::view(a, xt::keep(1), xt::all());
+        view.periodic(-1, 3) = 30;
+        view.periodic(-1, 4) = 40;
+        view.periodic(-1, 5) = 50;
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xview, front)
+    {
+        xt::xtensor<size_t, 2> a = {{1, 2, 3}, {4, 5, 6}};
+        auto v = xt::view(a, 0, xt::all());
+        auto w = xt::view(a, 1, xt::all());
+        EXPECT_EQ(v.front(), 1);
+        EXPECT_EQ(w.front(), 4);
+    }
+
+    TEST(xview, back)
+    {
+        xt::xtensor<size_t, 2> a = {{1, 2, 3}, {4, 5, 6}};
+        auto v = xt::view(a, 0, xt::all());
+        auto w = xt::view(a, 1, xt::all());
+        EXPECT_EQ(v.back(), 3);
+        EXPECT_EQ(w.back(), 6);
+    }
+
+    TEST(xview, flat)
+    {
+        xt::xtensor<size_t, 2, xt::layout_type::row_major> a = {{0, 1, 2}, {3, 4, 5}};
+        xt::xtensor<size_t, 2, xt::layout_type::row_major> b = {{0, 1, 2}, {30, 40, 50}};
+        auto view = xt::view(a, 1, xt::all());
+        view.flat(0) = 30;
+        view.flat(1) = 40;
+        view.flat(2) = 50;
+        EXPECT_EQ(a, b);
+    }
+
+    TEST(xview, assign_through_multiple_leading_newaxis)
+    {
+        SUBCASE("updates the underlying tensor for every element")
+        {
+            xt::xtensor<uint8_t, 2> tensor = xt::zeros<uint8_t>({4, 3});
+            auto view = xt::view(tensor, xt::newaxis(), xt::newaxis(), xt::newaxis(), xt::all(), xt::all());
+
+            uint8_t value = 0;
+            for (std::size_t row = 0; row < 4; ++row)
+            {
+                for (std::size_t col = 0; col < 3; ++col)
+                {
+                    view(std::size_t{0}, std::size_t{0}, std::size_t{0}, row, col) = value;
+                    EXPECT_EQ(tensor(row, col), value);
+                    ++value;
+                }
+            }
+
+            EXPECT_EQ(tensor, xt::arange<uint8_t>(12).reshape({4, 3}));
+        }
+
+        SUBCASE("preserves bool assignment semantics")
+        {
+            xt::xtensor<bool, 2> tensor = xt::zeros<bool>({4, 3});
+            auto view = xt::view(tensor, xt::newaxis(), xt::newaxis(), xt::newaxis(), xt::all(), xt::all());
+
+            for (std::size_t row = 0; row < 4; ++row)
+            {
+                for (std::size_t col = 0; col < 3; ++col)
+                {
+                    view(std::size_t{0}, std::size_t{0}, std::size_t{0}, row, col) = true;
+                    EXPECT_TRUE(tensor(row, col));
+                }
+            }
+
+            EXPECT_EQ(tensor, xt::ones<bool>({4, 3}));
+        }
+    }
+
+    TEST(xview, in_bounds)
+    {
+        xt::xtensor<size_t, 2> a = {{0, 1, 2}, {3, 4, 5}};
+        auto view = xt::view(a, xt::keep(1), xt::all());
+        EXPECT_TRUE(view.in_bounds(0, 0) == true);
+        EXPECT_TRUE(view.in_bounds(2, 0) == false);
+    }
+
+    TEST(xview, strides_compute_out_of_bounds)
+    {
+        // check that the compute_strides_impl does not access `a` strides out
+        // of bound! Can be observed with Valgrind or MSVC debug
+        xt::xtensor<double, 1> a = {1};
+        auto v1 = xt::view(a, xt::all(), xt::newaxis());
+        EXPECT_EQ(v1.dimension(), 2ul);
+        EXPECT_EQ(v1.strides().size(), 2ul);
+        EXPECT_EQ(v1.strides()[0], 0);
+        EXPECT_EQ(v1.strides()[1], 0);
+    }
+
+    template <class E>
+    auto transform(E& x)
+    {
+        x += 2;
+    }
+
+    TEST(xview, nontrivial_strides)
+    {
+        using farray = xt::xtensor<float, 2, xt::layout_type::column_major>;
+        const farray x_orig = xt::random::randn<float>({2, 2});
+
+        using namespace xt::placeholders;
+
+        farray x_view = x_orig;
+
+        auto x1 = xt::view(x_view, xt::all(), xt::range(_, 1));
+        auto x2 = xt::view(x_view, xt::all(), xt::range(1, _));
+
+        transform(x1);
+        transform(x2);
+        EXPECT_TRUE(xt::allclose(x_view, float(2) + x_orig));
+
+        for (auto it = x1.begin(); it != x1.end(); ++it)
+        {
+            *it += 5;
+        }
+        for (auto it = x2.begin(); it != x2.end(); ++it)
+        {
+            *it += 5;
+        }
+        EXPECT_TRUE(xt::allclose(x_view, float(7) + x_orig));
+    }
+
+    TEST(xview, element)
+    {
+        xarray<int> a = {{1, 2, 3}, {4, 5, 6}};
+        auto v = view(a, 0);
+        std::array<std::size_t, 2> idx = {0, 1};
+        int res = v.element(idx.cbegin(), idx.cend());
+        EXPECT_EQ(res, 2);
+    }
+
+    TEST(xview, view_reshape_view)
+    {
+        xtensor<int, 1> a = {0, 1, 2};
+        xtensor<int, 1> b = {2, 3, 4};
+        auto tmp = reshape_view(a, {3});
+        auto res = view(std::move(tmp), xt::all());
+        noalias(view(reshape_view(a, {3}), xt::all())) = b;
+        EXPECT_EQ(tmp, res);
+    }
+
+    TEST(xview, view_on_bool)
+    {
+        xt::xarray<bool> a{{false, false}, {false, false}};
+        xt::xarray<bool> b{{true, true}, {true, true}};
+        xt::view(a, 0) = xt::view(b, 0);
+        EXPECT_TRUE(a(0, 0));
+        EXPECT_TRUE(a(0, 1));
+        EXPECT_FALSE(a(1, 0));
+        EXPECT_FALSE(a(1, 1));
+    }
+
+    TEST(xview, first_rows_on_2dim_xarray)
+    {
+        xt::xarray<int> array{
+            {1, 2},
+            {3, 4},
+        };
+
+        const auto first_row = xt::row(array, 0);
+        const auto second_row = xt::row(array, 1);
+
+        EXPECT_EQ(first_row(0), 1);
+        EXPECT_EQ(first_row(1), 2);
+        EXPECT_EQ(second_row(0), 3);
+        EXPECT_EQ(second_row(1), 4);
+    }
+
+    TEST(xview, last_rows_on_2dim_xarray)
+    {
+        xt::xarray<int> array{
+            {1, 2},
+            {3, 4},
+            {5, 6},
+        };
+
+        const auto last_row = xt::row(array, -1);
+        const auto second_last_row = xt::row(array, -2);
+
+        EXPECT_EQ(last_row(0), 5);
+        EXPECT_EQ(last_row(1), 6);
+        EXPECT_EQ(second_last_row(0), 3);
+        EXPECT_EQ(second_last_row(1), 4);
+    }
+
+    TEST(xiew, row_on_2dim_xtensor)
+    {
+        xt::xtensor<int, 2> tensor{
+            {1, 2},
+            {3, 4},
+        };
+
+        const auto row0 = xt::row(tensor, 0);
+        const auto row1 = xt::row(tensor, 1);
+
+        EXPECT_EQ(row0(0), 1);
+        EXPECT_EQ(row0(1), 2);
+        EXPECT_EQ(row1(0), 3);
+        EXPECT_EQ(row1(1), 4);
+    }
+
+    TEST(xiew, row_on_2dim_xtensor_fixed)
+    {
+        xt::xtensor_fixed<int, xshape<2, 2>> tensor_fixed{
+            {1, 2},
+            {3, 4},
+        };
+
+        const auto row0 = xt::row(tensor_fixed, 0);
+        const auto row1 = xt::row(tensor_fixed, 1);
+
+        EXPECT_EQ(row0(0), 1);
+        EXPECT_EQ(row0(1), 2);
+        EXPECT_EQ(row1(0), 3);
+        EXPECT_EQ(row1(1), 4);
+    }
+
+    TEST(xview, row_on_3dim_array)
+    {
+        xt::xarray<int> arr{
+            {{1, 2}, {3, 4}},
+            {{5, 6}, {7, 8}},
+        };
+
+        XT_ASSERT_THROW(const auto row = xt::row(arr, 0), std::invalid_argument);
+    }
+
+    TEST(xview, first_cols_on_2dim_xarray)
+    {
+        xt::xarray<int> array{
+            {1, 2},
+            {3, 4},
+        };
+
+        const auto first_col = xt::col(array, 0);
+        const auto second_col = xt::col(array, 1);
+
+        EXPECT_EQ(first_col(0), 1);
+        EXPECT_EQ(first_col(1), 3);
+        EXPECT_EQ(second_col(0), 2);
+        EXPECT_EQ(second_col(1), 4);
+    }
+
+    TEST(xview, last_cols_on_2dim_xarray)
+    {
+        xt::xarray<int> array{
+            {1, 2, 3},
+            {4, 5, 6},
+        };
+
+        const auto last_col = xt::col(array, -1);
+        const auto second_last_col = xt::col(array, -2);
+
+        EXPECT_EQ(last_col(0), 3);
+        EXPECT_EQ(last_col(1), 6);
+        EXPECT_EQ(second_last_col(0), 2);
+        EXPECT_EQ(second_last_col(1), 5);
+    }
+
+    TEST(xview, col_on_2dim_xtensor)
+    {
+        xt::xtensor<int, 2> tensor{
+            {1, 2},
+            {3, 4},
+        };
+
+        const auto col0 = xt::col(tensor, 0);
+        const auto col1 = xt::col(tensor, 1);
+
+        EXPECT_EQ(col0(0), 1);
+        EXPECT_EQ(col0(1), 3);
+        EXPECT_EQ(col1(0), 2);
+        EXPECT_EQ(col1(1), 4);
+    }
+
+    TEST(xview, col_on_2dim_xtensor_fixed)
+    {
+        xt::xtensor_fixed<int, xshape<2, 2>> tensor_fixed{
+            {1, 2},
+            {3, 4},
+        };
+
+        const auto col0 = xt::col(tensor_fixed, 0);
+        const auto col1 = xt::col(tensor_fixed, 1);
+
+        EXPECT_EQ(col0(0), 1);
+        EXPECT_EQ(col0(1), 3);
+        EXPECT_EQ(col1(0), 2);
+        EXPECT_EQ(col1(1), 4);
+    }
+
+    TEST(xview, col_on_3dim_array)
+    {
+        xt::xarray<int> arr{
+            {{1, 2}, {3, 4}},
+            {{5, 6}, {7, 8}},
+        };
+
+        XT_ASSERT_THROW(const auto col = xt::col(arr, 0), std::invalid_argument);
+    }
+
+    TEST(xview, drop_on_1dim_array)
+    {
+        auto my_array = xt::xtensor<double, 1>({1, 2, 3});
+
+        // drop(1) creates a view excluding index 1
+        auto v1 = xt::view(my_array, xt::drop(1));
+        EXPECT_EQ(v1, (xt::xtensor<double, 1>{1, 3}));
+
+        // Assign through the drop view
+        xt::view(my_array, xt::drop(1)) = 0.;
+        EXPECT_EQ(my_array, (xt::xtensor<double, 1>{0, 2, 0}));
+
+        // Reset, then test drop with a variable (the original compilation issue)
+        my_array = xt::xtensor<double, 1>({1, 2, 3});
+        const size_t index = 1;
+        auto v2 = xt::view(my_array, xt::drop(index));
+        EXPECT_EQ(v2, (xt::xtensor<double, 1>{1, 3}));
+    }
 }
diff --git a/test/test_xview_semantic.cpp b/test/test_xview_semantic.cpp
index 5c04d8251..83207ec59 100644
--- a/test/test_xview_semantic.cpp
+++ b/test/test_xview_semantic.cpp
@@ -1,15 +1,17 @@
 /***************************************************************************
-* 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 "gtest/gtest.h"
-#include "xtensor/xview.hpp"
+ * 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. *
+ ****************************************************************************/
+
+#include "xtensor/core/xnoalias.hpp"
+#include "xtensor/views/xview.hpp"
+
+#include "test_common_macros.hpp"
 #include "test_xsemantic.hpp"
-#include "xtensor/xnoalias.hpp"
 
 namespace xt
 {
@@ -32,7 +34,10 @@ namespace xt
 
     template <class F, class C>
     view_op_tester<F, C>::view_op_tester()
-        : operation_tester<F, C>(), x_slice(0), y_slice(0, 2), z_slice(1, 4)
+        : operation_tester<F, C>()
+        , x_slice(0)
+        , y_slice(0, 2)
+        , z_slice(1, 4)
     {
         vres_rr = this->a;
         vres_rc = this->a;
@@ -78,387 +83,383 @@ namespace xt
         using storage_type = C;
     };
 
-    using testing_types = ::testing::Types<xarray_dynamic, xtensor_dynamic>;
-    TYPED_TEST_CASE(view_semantic, testing_types);
+#define VIEW_SEMANTIC_TEST_TYPES xarray_dynamic, xtensor_dynamic
 
-    TYPED_TEST(view_semantic, a_plus_b)
+    TEST_SUITE("view_semantic")
     {
-        view_op_tester<std::plus<>, TypeParam> t;
-        auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
-
+        TEST_CASE_TEMPLATE("a_plus_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major + row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa + viewra;
-            EXPECT_EQ(t.vres_rr, b);
-        }
+            view_op_tester<std::plus<>, TypeParam> t;
+            auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
 
-        {
-            SCOPED_TRACE("row_major + column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa + viewca;
-            EXPECT_EQ(t.vres_rc, b);
-        }
+            SUBCASE("row_major + row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa + viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major + central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa + viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            SUBCASE("row_major + column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa + viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
+
+            SUBCASE("row_major + central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa + viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
+
+            SUBCASE("row_major + unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa + viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("a_minus_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major + unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa + viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            view_op_tester<std::minus<>, TypeParam> t;
+            auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
 
-    TYPED_TEST(view_semantic, a_minus_b)
-    {
-        view_op_tester<std::minus<>, TypeParam> t;
-        auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
+            SUBCASE("row_major - row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa - viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major - row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa - viewra;
-            EXPECT_EQ(t.vres_rr, b);
-        }
+            SUBCASE("row_major - column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa - viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major - column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa - viewca;
-            EXPECT_EQ(t.vres_rc, b);
-        }
+            SUBCASE("row_major - central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa - viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major - central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa - viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            SUBCASE("row_major - unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa - viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("a_times_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major - unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa - viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            view_op_tester<std::multiplies<>, TypeParam> t;
+            auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
 
-    TYPED_TEST(view_semantic, a_times_b)
-    {
-        view_op_tester<std::multiplies<>, TypeParam> t;
-        auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
+            SUBCASE("row_major * row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa * viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major * row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa * viewra;
-            EXPECT_EQ(t.vres_rr, b);
-        }
+            SUBCASE("row_major * column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa * viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major * column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa * viewca;
-            EXPECT_EQ(t.vres_rc, b);
-        }
+            SUBCASE("row_major * central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa * viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major * central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa * viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            SUBCASE("row_major * unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa * viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("a_divdide_by_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major * unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa * viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            view_op_tester<std::divides<>, TypeParam> t;
+            auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
 
-    TYPED_TEST(view_semantic, a_divdide_by_b)
-    {
-        view_op_tester<std::divides<>, TypeParam> t;
-        auto viewa = view(t.a, t.x_slice, t.y_slice, t.z_slice);
+            SUBCASE("row_major / row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa / viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major / row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa / viewra;
-            EXPECT_EQ(t.vres_rr, b);
-        }
+            SUBCASE("row_major / column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa / viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major / column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa / viewca;
-            EXPECT_EQ(t.vres_rc, b);
-        }
+            SUBCASE("row_major / central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa / viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major / central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa / viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            SUBCASE("row_major / unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb = viewa / viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("a_plus_equal_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major / unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb = viewa / viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            view_op_tester<std::plus<>, TypeParam> t;
 
-    TYPED_TEST(view_semantic, a_plus_equal_b)
-    {
-        view_op_tester<std::plus<>, TypeParam> t;
+            SUBCASE("row_major += row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb += viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major += row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb += viewra;
-            EXPECT_EQ(t.vres_rr, b);
-        }
+            SUBCASE("row_major += column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb += viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major += column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb += viewca;
-            EXPECT_EQ(t.vres_rc, b);
-        }
+            SUBCASE("row_major += central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb += viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major += central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb += viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            SUBCASE("row_major += unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb += viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("a_minus_equal_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major += unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb += viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            view_op_tester<std::minus<>, TypeParam> t;
 
-    TYPED_TEST(view_semantic, a_minus_equal_b)
-    {
-        view_op_tester<std::minus<>, TypeParam> t;
+            SUBCASE("row_major -= row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb -= viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major -= row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb -= viewra;
-            EXPECT_EQ(t.vres_rr, b);
-        }
+            SUBCASE("row_major -= column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb -= viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major -= column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb -= viewca;
-            EXPECT_EQ(t.vres_rc, b);
-        }
+            SUBCASE("row_major -= central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb -= viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major -= central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb -= viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            SUBCASE("row_major -= unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb -= viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("a_times_equal_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major -= unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb -= viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            view_op_tester<std::multiplies<>, TypeParam> t;
 
-    TYPED_TEST(view_semantic, a_times_equal_b)
-    {
-        view_op_tester<std::multiplies<>, TypeParam> t;
+            SUBCASE("row_major *= row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb *= viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major *= row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb *= viewra;
-            EXPECT_EQ(t.vres_rr, b);
-        }
+            SUBCASE("row_major *= column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb *= viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major *= column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb *= viewca;
-            EXPECT_EQ(t.vres_rc, b);
-        }
+            SUBCASE("row_major *= central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb *= viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major *= central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb *= viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            SUBCASE("row_major *= unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb *= viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("a_divide_by_equal_b", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major *= unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb *= viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            view_op_tester<std::divides<>, TypeParam> t;
 
-    TYPED_TEST(view_semantic, a_divide_by_equal_b)
-    {
-        view_op_tester<std::divides<>, TypeParam> t;
+            SUBCASE("row_major /= row_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
+                viewb /= viewra;
+                EXPECT_EQ(t.vres_rr, b);
+            }
 
-        {
-            SCOPED_TRACE("row_major /= row_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewra = view(t.ra, t.x_slice, t.y_slice, t.z_slice);
-            viewb /= viewra;
-            EXPECT_EQ(t.vres_rr, b);
+            SUBCASE("row_major /= column_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
+                viewb /= viewca;
+                EXPECT_EQ(t.vres_rc, b);
+            }
+
+            SUBCASE("row_major /= central_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
+                viewb /= viewcta;
+                EXPECT_EQ(t.vres_rct, b);
+            }
+
+            SUBCASE("row_major /= unit_major")
+            {
+                TypeParam b = t.a;
+                auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
+                auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
+                viewb /= viewua;
+                EXPECT_EQ(t.vres_ru, b);
+            }
         }
 
+        TEST_CASE_TEMPLATE("broadcast_equal", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major /= column_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewca = view(t.ca, t.x_slice, t.y_slice, t.z_slice);
-            viewb /= viewca;
-            EXPECT_EQ(t.vres_rc, b);
+            using container_1d = redim_container_t<TypeParam, 1>;
+            using container_2d = redim_container_t<TypeParam, 2>;
+            container_2d a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+            container_2d b = a;
+            auto viewa = view(a, all(), range(1, 4));
+            auto viewb = view(b, all(), range(1, 4));
+            container_1d c = {1, 2, 3};
+            viewa = c;
+            noalias(viewb) = c;
+            container_2d res = {{1, 1, 2, 3}, {5, 1, 2, 3}, {9, 1, 2, 3}};
+
+            EXPECT_EQ(res, a);
+            EXPECT_EQ(res, b);
         }
 
+        TEST_CASE_TEMPLATE("scalar_equal", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major /= central_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewcta = view(t.cta, t.x_slice, t.y_slice, t.z_slice);
-            viewb /= viewcta;
-            EXPECT_EQ(t.vres_rct, b);
+            using container_2d = redim_container_t<TypeParam, 2>;
+            container_2d a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+            auto viewa = view(a, all(), range(1, 4));
+            int b = 1;
+            viewa = b;
+            container_2d res = {{1, 1, 1, 1}, {5, 1, 1, 1}, {9, 1, 1, 1}};
+
+            EXPECT_EQ(res, a);
         }
 
+        TEST_CASE_TEMPLATE("higher_dimension_broadcast", TypeParam, VIEW_SEMANTIC_TEST_TYPES)
         {
-            SCOPED_TRACE("row_major /= unit_major");
-            TypeParam b = t.a;
-            auto viewb = view(b, t.x_slice, t.y_slice, t.z_slice);
-            auto viewua = view(t.ua, t.x_slice, t.y_slice, t.z_slice);
-            viewb /= viewua;
-            EXPECT_EQ(t.vres_ru, b);
-        }
-    }
+            using container_2d = redim_container_t<TypeParam, 2>;
 
-    TYPED_TEST(view_semantic, broadcast_equal)
-    {
-        using container_1d = redim_container_t<TypeParam, 1>;
-        using container_2d = redim_container_t<TypeParam, 2>;
-        container_2d a = {{1,  2,  3,  4},
-                          {5,  6,  7,  8},
-                          {9, 10, 11, 12}};
-        container_2d b = a;
-        auto viewa = view(a, all(), range(1, 4));
-        auto viewb = view(b, all(), range(1, 4));
-        container_1d c = {1, 2, 3};
-        viewa = c;
-        noalias(viewb) = c;
-        container_2d res = {{1, 1, 2, 3},
-                            {5, 1, 2, 3},
-                            {9, 1, 2, 3}};
-
-        EXPECT_EQ(res, a);
-        EXPECT_EQ(res, b);
-    }
+            container_2d a = {{1, 2, 3}, {4, 5, 6}};
+            container_2d b = {{11, 12, 13}};
+            container_2d res = {{11, 12, 13}, {4, 5, 6}};
 
-    TYPED_TEST(view_semantic, scalar_equal)
-    {
-        using container_2d = redim_container_t<TypeParam, 2>;
-        container_2d a = {{1, 2, 3, 4},
-                          {5, 6, 7, 8},
-                          {9, 10, 11, 12}};
-        auto viewa = view(a, all(), range(1, 4));
-        int b = 1;
-        viewa = b;
-        container_2d res = {{1, 1, 1, 1},
-                            {5, 1, 1, 1},
-                            {9, 1, 1, 1}};
-
-        EXPECT_EQ(res, a);
+            auto viewa = view(a, 0, all());
+            XT_EXPECT_ANY_THROW(viewa = b);
+        }
     }
 
-    TYPED_TEST(view_semantic, higher_dimension_broadcast)
-    {
-        using container_2d = redim_container_t<TypeParam, 2>;
-
-        container_2d a = { {1, 2, 3}, {4, 5, 6} };
-        container_2d b = { {11, 12, 13} };
-        container_2d res = { { 11, 12, 13 }, { 4, 5, 6 } };
-
-        auto viewa = view(a, 0, all());
-        EXPECT_ANY_THROW(viewa = b);
-    }
+#undef VIEW_SEMANTIC_TEST_TYPES
 }
diff --git a/tools/check_circular.py b/tools/check_circular.py
new file mode 100755
index 000000000..e0bc3fc75
--- /dev/null
+++ b/tools/check_circular.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import networkx as nx
+
+def build_graph(path):
+    graph = nx.DiGraph()
+    for f in os.listdir(path):
+        graph.add_node(f)
+        cnt = 0
+        with open(path+"/"+f) as fp:
+            line = fp.readline()
+            enter_include = False
+            exit_include = False
+            while line and not exit_include:
+                if line.startswith('#include "'):
+                    enter_include = True
+                    node = line.split()[1].replace('"', '')
+                    graph.add_node(node)
+                    graph.add_edge(f, node)
+                elif enter_include:
+                    exit_include = True
+                line = fp.readline()
+    return graph
+
+def main():
+    graph = build_graph("../include/xtensor")
+    cycle = list(nx.simple_cycles(graph))
+    for x in cycle:
+        print(x)
+    exception_message = ' - '.join([str(y) for y in cycle])
+    if len(cycle) != 0:
+        raise Exception('CircularInclude', exception_message)
+
+main()
diff --git a/xtensor.pc.in b/xtensor.pc.in
index 9d57bfd29..0352e0bd1 100644
--- a/xtensor.pc.in
+++ b/xtensor.pc.in
@@ -1,5 +1,4 @@
 prefix=@CMAKE_INSTALL_PREFIX@
-libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@
 includedir=${prefix}/include
 
 Name: xtensor
diff --git a/xtensorConfig.cmake.in b/xtensorConfig.cmake.in
index 42be38785..ec72abb55 100644
--- a/xtensorConfig.cmake.in
+++ b/xtensorConfig.cmake.in
@@ -1,5 +1,6 @@
 ############################################################################
-# Copyright (c) 2016, Johan Mabille and Sylvain Corlay                     #
+# Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          #
+# Copyright (c) QuantStack
 #                                                                          #
 # Distributed under the terms of the BSD 3-Clause License.                 #
 #                                                                          #
@@ -19,6 +20,52 @@ include(CMakeFindDependencyMacro)
 find_dependency(xtl @xtl_REQUIRED_VERSION@)
 
 if(NOT TARGET @PROJECT_NAME@)
-  include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
-  get_target_property(@PROJECT_NAME@_INCLUDE_DIRS xtensor INTERFACE_INCLUDE_DIRECTORIES)
+    include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
+    get_target_property(@PROJECT_NAME@_INCLUDE_DIRS @PROJECT_NAME@ INTERFACE_INCLUDE_DIRECTORIES)
+endif()
+
+if(XTENSOR_USE_XSIMD)
+    find_dependency(xsimd @xsimd_REQUIRED_VERSION@)
+    target_link_libraries(@PROJECT_NAME@ INTERFACE xsimd)
+    target_compile_definitions(@PROJECT_NAME@ INTERFACE XTENSOR_USE_XSIMD)
+endif()
+
+if(XTENSOR_USE_TBB)
+    find_dependency(TBB)
+    target_link_libraries(@PROJECT_NAME@ INTERFACE TBB::tbb)
+    target_compile_definitions(@PROJECT_NAME@ INTERFACE XTENSOR_USE_TBB)
+endif()
+
+if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_GREATER_EQUAL 3.11)
+    if(NOT TARGET xtensor::optimize)
+        add_library(xtensor::optimize INTERFACE IMPORTED)
+        # Microsoft compiler
+        if(CMAKE_${COMPILER_LANGUAGE}_COMPILER_IS_MSVC)
+            target_compile_options(xtensor::optimize INTERFACE /EHsc /MP /bigobj)
+        # gcc, clang, ...
+        else()
+            include(CheckCXXCompilerFlag)
+            CHECK_CXX_COMPILER_FLAG(-march=native arch_native_supported)
+            if(arch_native_supported)
+              target_compile_options(xtensor::optimize INTERFACE -march=native)
+          endif()
+        endif()
+    endif()
+
+    if(NOT TARGET xtensor::use_xsimd)
+        find_package(xsimd QUIET)
+        if (xsimd_FOUND)
+            add_library(xtensor::use_xsimd INTERFACE IMPORTED)
+            target_link_libraries(xtensor::use_xsimd INTERFACE xsimd)
+            target_compile_definitions(xtensor::use_xsimd INTERFACE XTENSOR_USE_XSIMD)
+        endif()
+    endif()
+
+    if(NOT TARGET xtensor::use_TBB)
+        find_package(TBB QUIET)
+        if (TBB_FOUND)
+            add_library(xtensor::use_TBB INTERFACE IMPORTED)
+            target_compile_definitions(xtensor::use_TBB INTERFACE XTENSOR_USE_TBB)
+        endif()
+    endif()
 endif()