xtensor

https://github.com/xtensor-stack/xtensor
Admin
xtensor is a C++ library providing multi-dimensional arrays with broadcasting and lazy computing for...
Tokens:68,741
Snippets:755
Trust Score:7.2
License:BSD-3-Clause
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install xtensor from source

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Build and install the header-only library using CMake.

```bash
cmake -DCMAKE_INSTALL_PREFIX=your_install_prefix
make install
```

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

### Install documentation tools

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Install Breathe and the Read the Docs theme via pip.

```bash
pip install breathe sphinx_rtd_theme
```

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

### Install xtensor using vcpkg

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Clone the vcpkg repository and use it to install the xtensor port.

```bash
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
./vcpkg install xtensor
```

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

### Install documentation build tools

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/dev-build-options.md

Command to install the necessary dependencies for building the xtensor documentation.

```bash
conda install breathe doxygen sphinx_rtd_theme -c conda-forge
```

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

### Install xtensor from source with MinGW

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/installation.md

Build and install xtensor using MinGW Makefiles.

```c++
mkdir build
cd build
cmake -G "MinGW Makefiles" -DCMAKE_INSTALL_PREFIX=path_to_prefix ..
mingw32-make
mingw32-make install
```

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

### Configure pkg-config and Additional Directories

Source: https://github.com/xtensor-stack/xtensor/blob/master/CMakeLists.txt

Sets up pkg-config files and installs project-specific tag files and configurations.

```cmake
configure_file(${PROJECT_NAME}.pc.in
               "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
                @ONLY)
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
        DESTINATION "${CMAKE_INSTALL_DATADIR}/pkgconfig/")

install(DIRECTORY ${XTENSOR_TAGFILES_DIR}
        DESTINATION ${XTENSOR_DATA_DIR})

install(DIRECTORY ${XTENSOR_TAGCONFS_DIR}
        DESTINATION ${XTENSOR_CONF_DIR})
```

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

### Expected output of the first example

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/getting_started.md

Displays the console output generated by running the initial array arithmetic example.

```c++
{7, 11, 14}
```

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

### Install xtensor with Spack

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/installation.md

Install and load the xtensor package using the Spack package manager.

```c++
spack install xtensor
spack load --dependencies xtensor
```

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

### Install xtensor from source with CMake on Windows

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/installation.md

Build and install xtensor from the source directory on Windows using NMake.

```c++
mkdir build
cd build
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=path_to_prefix ..
nmake
nmake install
```

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

### Configure CMake Installation for xtensor

Source: https://github.com/xtensor-stack/xtensor/blob/master/CMakeLists.txt

Standard CMake installation commands for exporting targets and installing header files.

```cmake
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)

install(TARGETS xtensor
        EXPORT ${PROJECT_NAME}-targets)

# Makes the project importable from the build directory
export(EXPORT ${PROJECT_NAME}-targets
       FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake")

install(DIRECTORY ${XTENSOR_INCLUDE_DIR}/xtensor
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
```

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

### Install xtensor from source with CMake on Unix

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/installation.md

Build and install xtensor from the source directory on Unix platforms.

```c++
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=path_to_prefix ..
make install
```

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

### Usage of custom adaptor

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/external-structures.md

Example showing how the custom adaptor supports mathematical expressions.

```cpp
using tensor_type = raw_tensor_adaptor<double>;
tensor_type a, b, c;
// .... init a, b and c
tensor_type d = a + b - c;
```

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

### Compile xtensor example with G++

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/getting_started.md

Provides the command to compile a source file by specifying the include paths for xtensor and xtl headers.

```bash
g++ -I /path/to/xtensor/ -I /path/to/xtl/ example.cpp -o example
```

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

### Install xtensor on Debian

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/installation.md

Install the xtensor-dev package using the apt-get package manager.

```c++
sudo apt-get install xtensor-dev
```

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

### Build xtensor tests with custom gtest source

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/dev-build-options.md

Example of configuring the build directory while specifying a custom path for gtest sources.

```bash
mkdir build
cd build
cmake -DGTEST_SRC_DIR=/usr/share/gtest ../
make xtest
```

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

### Broadcasting example with xarray

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/iterating_expression.md

An example demonstrating an xfunction resulting from the addition of two xarray objects with different shapes.

```c++
xarray<int> a = {{0, 1,  2,  3},
                 {4, 5,  6,  7},
                 {8, 9, 10, 11}};
xarray<int> b = {0, 1, 2, 3};
auto r = a + b;
```

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

### Install Breathe via Conda

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Alternative installation method for Breathe using the conda-forge channel.

```bash
conda install -c conda-forge breathe
```

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

### Build xtensor tests with assertions

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/dev-build-options.md

Example of configuring the build directory and enabling tests and assertions via CMake.

```bash
mkdir build
cd build
cmake -DBUILD_TESTS=ON -DXTENSOR_ENABLE_ASSERT=ON ../
make xtest
```

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

### Install dependencies via Conda

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Install GTest and CMake using the conda-forge channel.

```bash
conda install -c conda-forge gtest cmake
```

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

### Generate Package Configuration Files

Source: https://github.com/xtensor-stack/xtensor/blob/master/CMakeLists.txt

Configures and installs the project's Config.cmake and ConfigVersion.cmake files to support find_package.

```cmake
set(XTENSOR_CMAKECONFIG_INSTALL_DIR "${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}" CACHE
    STRING "install path for xtensorConfig.cmake")

configure_package_config_file(${PROJECT_NAME}Config.cmake.in
                              "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
                              INSTALL_DESTINATION ${XTENSOR_CMAKECONFIG_INSTALL_DIR})

# xtensor is header-only and does not depend on the architecture.
# Remove CMAKE_SIZEOF_VOID_P from xtensorConfigVersion.cmake so that an xtensorConfig.cmake
# generated for a 64 bit target can be used for 32 bit targets and vice versa.
set(_XTENSOR_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})
unset(CMAKE_SIZEOF_VOID_P)
write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
                                 VERSION ${${PROJECT_NAME}_VERSION}
                                 COMPATIBILITY AnyNewerVersion)
set(CMAKE_SIZEOF_VOID_P ${_XTENSOR_CMAKE_SIZEOF_VOID_P})
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
              ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
        DESTINATION ${XTENSOR_CMAKECONFIG_INSTALL_DIR})
install(EXPORT ${PROJECT_NAME}-targets
        FILE ${PROJECT_NAME}Targets.cmake
        DESTINATION ${XTENSOR_CMAKECONFIG_INSTALL_DIR})
```

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

### Install xtensor with mamba

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Use the conda-forge channel to install the xtensor package via mamba or conda.

```bash
mamba install -c conda-forge xtensor
```

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

### Perform generic iteration

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/concepts.md

Example of using standard library algorithms with xtensor expressions using default traversal.

```c++
std::copy(a.cbegin(), a.cend(), b.begin());
```

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

### Build documentation

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/dev-build-options.md

Commands to navigate to the documentation directory and trigger the HTML build process.

```bash
cd docs
make html
```

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

### Initialize Project and Directories

Source: https://github.com/xtensor-stack/xtensor/blob/master/CMakeLists.txt

Sets the minimum CMake version, defines the project as CXX, and establishes paths for include directories and configuration assets.

```cmake
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)
```

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

### Initialize and compute with 2-D arrays

Source: https://github.com/xtensor-stack/xtensor/blob/master/notebooks/xtensor.ipynb

Includes necessary headers for xarray, xio, and xview. Demonstrates creating 2-D and 1-D arrays and performing element-wise addition using views.

```cpp
#include <iostream>

#include "xtensor/xarray.hpp"
#include "xtensor/xio.hpp"
#include "xtensor/xview.hpp"
```

```cpp
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::view(arr1, 1) + arr2
```

```cpp
arr1
```

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

### Build and run tests

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Standard procedure to configure and build the test suite.

```bash
mkdir build
cd build
cmake -DBUILD_TESTS=ON ../
make xtest
```

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

### Build and run commands

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/getting_started.md

Standard shell commands to build the project in a separate directory and execute the binary.

```bash
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=your_prefix ..
make
./first_program
```

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

### Initialize and Print xtensor Containers

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/quickref/basic.md

Demonstrates initialization of xarray, xtensor, and xtensor_fixed containers and printing them to standard output.

```c++
#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;
```

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

### Generate HTML documentation

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Build the documentation from the docs subdirectory.

```bash
make html
```

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

### Inherit from xconst_iterable

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/iterating_expression.md

Example of a class inheriting from xconst_iterable to enable iteration capabilities.

```c++
template <class CT, class X>
class xbroadcast : public xexpression<xbroadcast<CT, X>>,
                   public xconst_iterable<xbroadcast<CT, X>>
{
    // ...
};
```

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

### Define Benchmark Executable and Dependencies

Source: https://github.com/xtensor-stack/xtensor/blob/master/benchmark/CMakeLists.txt

Sets up the benchmark executable target and links required libraries including xtensor and Google Benchmark.

```cmake
set(XTENSOR_BENCHMARK_TARGET benchmark_xtensor)
add_executable(${XTENSOR_BENCHMARK_TARGET} EXCLUDE_FROM_ALL ${XTENSOR_BENCHMARK} ${XTENSOR_HEADERS})
target_link_libraries(${XTENSOR_BENCHMARK_TARGET} PUBLIC xtensor ${GBENCHMARK_LIBRARIES})
```

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

### Initialize and compute array operations

Source: https://github.com/xtensor-stack/xtensor/blob/master/README.md

Demonstrates creating 2-D and 1-D arrays and performing element-wise addition using views.

```cpp
#include <iostream>
#include "xtensor/xarray.hpp"
#include "xtensor/xio.hpp"
#include "xtensor/xview.hpp"

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> res = xt::view(arr1, 1) + arr2;

std::cout << res;
```

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

### Scalar Computed Assignment Example

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/concepts.md

Demonstrates using the computed assignment operator with a scalar value.

```c++
#include <xtensor/containers/xarray.hpp>
#include <xtensor/io/xio.hpp>

int main(int argc, char* argv)
{
    xarray<int> a = { 1, 2, 3 };
    a += 4;
    std::cout << a << std::endl;
    // outputs { 5, 6, 7 }
}
```

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

### Configure Build Environment and Compiler Flags

Source: https://github.com/xtensor-stack/xtensor/blob/master/benchmark/CMakeLists.txt

Sets up build types, compiler flags for Clang/GNU/Intel, and handles MSVC-specific configurations.

```cmake
cmake_minimum_required(VERSION 3.22)
include(FetchContent)

if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
    project(xtensor-benchmark)

    find_package(xtensor REQUIRED CONFIG)
    set(XTENSOR_INCLUDE_DIR ${xtensor_INCLUDE_DIRS})
endif ()

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")
    # 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
    # visibility to hidden (very important to obtain small binaries)
    if (NOT ${U_CMAKE_BUILD_TYPE} MATCHES DEBUG)
        # Default symbol visibility
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")

        # Check for Link Time Optimization support
        # (GCC/Clang)
        # LTO had to be removed as google benchmark doesn't build with it
        # CHECK_CXX_COMPILER_FLAG("-flto" HAS_LTO_FLAG)
        # if (HAS_LTO_FLAG)
        #     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
        # endif()

        # Intel equivalent to LTO is called IPO
        if (CMAKE_CXX_COMPILER_ID MATCHES "Intel")
            CHECK_CXX_COMPILER_FLAG("-ipo" HAS_IPO_FLAG)
            if (HAS_IPO_FLAG)
                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ipo")
            endif()
        endif()
    endif()
endif()

if(MSVC)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc /MP /bigobj")
    set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
    foreach(flag_var
            CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
            CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
        string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
    endforeach()
endif()
```

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

### Assignment with Broadcasting

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/assignment.md

Example of an assignment operation involving broadcasting where a temporary variable is used to avoid aliasing.

```c++
xarray<double> a = {1, 2, 3, 4};
xarray<double> b = {{1, 2, 3, 4},
                    {5, 6, 7, 8}};
a = a + b;
```

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

### Configure Linux/OSX Build Options

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/build-options.md

Recommended compiler flags for Unix-like systems to enable native architecture optimizations.

```cmake
target_link_libraries(... xtensor xtensor::optimize)

# OR

target_compile_options(target_name PRIVATE -march=native)
```

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

### Define inner types in xarray

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/implementation_classes.md

Example of aliasing inner types from a storage type within an xarray implementation.

```c++
using value_type = typename storage_type::value_type;
using reference = typename storage_type::reference;
using const_reference = typename storage_type::const_reference;
...
```

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

### Initialize xarray and xtensor

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/pitfall.md

Demonstrates the difference between initializing an xarray with a shape-like initializer list versus an xtensor with a fixed dimension.

```c++
xt::xarray<double> a({1, 3, 4, 2});
```

```c++
xt::xarray<double> a = {1, 3, 4, 2};
```

```c++
auto a = xt::xarray<double>::from_shape({1, 3, 4, 2});
```

```c++
xt::xtensor<double, 4> a = {1, 3, 4, 2};
```

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

### Initialize Containers in NumPy and xtensor

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/numpy.md

Demonstrates the initialization of multi-dimensional arrays using NumPy and the corresponding xt::xarray and xt::xtensor types in C++.

```python
np.array([[3, 4], [5, 6]])
```

```cpp
xt::xarray<double>({{3, 4}, {5, 6}})
```

```cpp
xt::xtensor<double, 2>({{3, 4}, {5, 6}})
```

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

### Minimal CMakeLists.txt configuration

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/getting_started.md

Basic configuration file to link xtensor and its dependencies.

```cmake
cmake_minimum_required(VERSION 3.1)
project(first_example)

find_package(xtl REQUIRED)
find_package(xtensor REQUIRED)

add_executable(first_example src/example.cpp)

if(MSVC)
    set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
endif()

target_link_libraries(first_example xtensor xtensor::optimize xtensor::use_xsimd)
```

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

### Demonstrating inconsistent scalar assignment behavior

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/scalar.md

This example illustrates the behavior if scalar assignment did not trigger a resize, which would be inconsistent with 0-D expression semantics.

```c++
#include <xtensor/containers/xarray.hpp>

xt::xarray<double> a = {{0., 1., 2.}, {3., 4., 5.}};
double s = 1.2;
a = 1.2;
std::cout << a << std::endl;
// prints {{1.2, 1.2, 1.2}, {1.2, 1.2, 1.2}}
```

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

### Initialize xt::xtensor_fixed

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/container.md

Demonstrates initializing an xt::xtensor_fixed container with a compile-time fixed shape.

```c++
#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>()
```

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

### Project directory structure

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/getting_started.md

Recommended folder layout for an xtensor project.

```bash
first_example
   |- src
   |   |- example.cpp
   |- CMakeLists.txt
```

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

### Using Placeholder Syntax for Ranges

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/view.md

Shows how to use the underscore placeholder for range boundaries.

```c++
#include <xtensor/containers/xarray.hpp>
#include <xtensor/views/xview.hpp>

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));
```

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

### Initialize xarray with dynamic shape

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/quickref/basic.md

Demonstrates creating and initializing an xarray container, which supports dynamic reshaping.

```c++
#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);
```

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

### Demonstrate expression node storage

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/expression_tree.md

Shows how expressions hold references to lvalues and move rvalues.

```c++
xarray<double> some_function();

xarray<double> a = xt::ones({2, 2});
auto f = a + some_function();
```

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

### Array builder functions

Source: https://github.com/xtensor-stack/xtensor/blob/master/notebooks/xtensor.ipynb

Demonstrates creating arrays using linspace, ones, arange, and broadcasting.

```cpp
#include "xtensor/xbuilder.hpp"
```

```cpp
xt::xarray<double> ar = xt::linspace<double>(0.0, 10.0, 12);
ar.reshape({4, 3});
ar
```

```cpp
xt::xarray<double> fones = xt::ones<float>({2, 2});
fones
```

```cpp
xt::arange<int>(1569325055)
```

```cpp
#include <vector>
#include "xtensor/xbroadcast.hpp"
```

```cpp
xt::broadcast(xt::linspace<double>(0.0, 10.0, 4),
              std::vector<std::size_t>({3, 4}))
```

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

### Initialize xtensor with static dimensions

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/quickref/basic.md

Demonstrates creating an xtensor container where the number of dimensions is fixed at compile time.

```c++
#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);
```

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

### Initialize xt::xtensor

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/container.md

Demonstrates initializing an xt::xtensor container with a specified shape.

```c++
#include <array>
#include <xtensor/containers/xtensor.hpp>

std::array<size_t, 3> shape = { 3, 2, 4 };
xt::xtensor<double, 3> a(shape);
// this is equivalent to
// xt::xtensor<double, 3, xt::layout_type::row_major> a(shape);
```

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

### Configure Core Test Library

Source: https://github.com/xtensor-stack/xtensor/blob/master/test/CMakeLists.txt

Creates a static library for common test files and configures precompiled headers for faster build times.

```cmake
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)
```

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

### Naive xstepper step implementation

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/iterating_expression.md

A basic implementation of the step method for container-based expressions that does not account for broadcasting.

```c++
template <class C>
inline void xstepper<C>::step(size_type dim, size_type n)
{
    m_it += n * p_c->strides()[dim];
}
```

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

### Compute basic histogram and bin edges

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/histogram.md

Demonstrates the standard usage of xt::histogram and xt::histogram_bin_edges with a simple dataset.

```cpp
#include <xtensor/containers/xtensor.hpp>
#include <xtensor/misc/xhistogram.hpp>
#include <xtensor/io/xio.hpp>

int main()
{
    xt::xtensor<double,1> data = {1., 1., 2., 2., 3.};

    xt::xtensor<double,1> count = xt::histogram(data, std::size_t(2));

    xt::xtensor<double,1> bin_edges = xt::histogram_bin_edges(data, std::size_t(2));

    return 0;
}
```

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

### Copy Configuration Files

Source: https://github.com/xtensor-stack/xtensor/blob/master/CMakeLists.txt

Copies tag files and configuration directories from the source tree to the binary output directory.

```cmake
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")
```

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

### Configure Windows Build Options

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/build-options.md

Recommended compiler flags for Windows, including the mandatory /bigobj flag.

```cmake
target_link_libraries(... xtensor xtensor::optimize)
set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)

# OR

target_compile_options(target_name PRIVATE /EHsc /MP /bigobj)
set(CMAKE_EXE_LINKER_FLAGS /MANIFEST:NO)
```

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

### Define Test Library and Targets

Source: https://github.com/xtensor-stack/xtensor/blob/master/test/CMakeLists.txt

Sets up include directories, links dependencies, and defines the custom xtest target for running the test suite.

```cmake
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)
```

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

### Manual Loop Equivalent

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/expression.md

Shows the manual loop implementation that the expression engine optimizes to achieve equivalent performance.

```c++
xt::xarray<double> res(n);
for(size_t i = 0; i < n; ++i)
{
    res(i) = x(i) + y(i) * sin(z(i));
}
```

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

### Customize histogram binning algorithm

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/histogram.md

Shows how to specify a custom binning algorithm using xt::histogram_bin_edges and pass the resulting edges to xt::histogram.

```cpp
#include <xtensor/containers/xtensor.hpp>
#include <xtensor/misc/xhistogram.hpp>
#include <xtensor/io/xio.hpp>

int main()
{
    xt::xtensor<double,1> data = {1., 1., 2., 2., 3.};

    xt::xtensor<double,1> bin_edges = xt::histogram_bin_edges(data, std::size_t(2), xt::histogram_algorithm::uniform);

    xt::xtensor<double,1> prob = xt::histogram(data, bin_edges, true);

    std::cout << bin_edges << std::endl;
    std::cout << prob << std::endl;

    return 0;
}
```

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

### Create Transposed Views in C++

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/view.md

Demonstrates creating a transposed view of an expression. Note that dynamic layout expressions will throw a transpose_error.

```c++
#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);
// tr == { {0, 3}, {1, 4}, {2, 5} }

xt::xarray<int, layout_type::dynamic> b = { {0, 1, 2}, {3, 4, 5} };
auto tr2 = xt::transpose(b);
// => throw transpose_error
```

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

### Build combined test library

Source: https://github.com/xtensor-stack/xtensor/blob/master/test/CMakeLists.txt

Creates a single executable containing all test cases with optional feature support.

```cmake
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}>)
```

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

### Select evaluation strategy for reducers in C++

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/operator.md

Demonstrates choosing between immediate and lazy evaluation strategies when performing reduction operations.

```c++
#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);
// or select the default:
// auto res = xt::sum(a, {1, 3}, xt::evaluation_strategy::lazy);
```

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

### Creating an xfunction expression

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/expression_tree.md

Demonstrates the creation of an xfunction instance through basic arithmetic operations on xarray containers.

```c++
xarray<double> a = xt::ones({2, 2});
xarray<double> b = xt::ones({2, 2});

auto f = (a + b);
```

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

### Manage Dependencies and Benchmark Targets

Source: https://github.com/xtensor-stack/xtensor/blob/master/benchmark/CMakeLists.txt

Handles Google Benchmark dependency resolution and defines the list of benchmark source files.

```cmake
if(DOWNLOAD_GBENCHMARK OR GBENCHMARK_SRC_DIR)
    FetchContent_Declare(googletest
            GIT_REPOSITORY https://github.com/google/googletest.git
            GIT_TAG main)

    FetchContent_Declare(googlebenchmark
            GIT_REPOSITORY https://github.com/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)
endif()

find_package(xsimd)
if (xsimd_FOUND)
    include_directories(${xsimd_INCLUDE_DIRS})
    add_definitions("-DXTENSOR_USE_XSIMD=1")
endif()

include_directories(${XTENSOR_INCLUDE_DIR})
include_directories(${GBENCHMARK_INCLUDE_DIRS})

set(XTENSOR_BENCHMARK
    benchmark_assign.cpp
    benchmark_builder.cpp
    benchmark_container.cpp
    benchmark_creation.cpp
    benchmark_increment_stepper.cpp
    benchmark_lambda_expressions.cpp
    benchmark_math.cpp
    benchmark_random.cpp
    benchmark_reducer.cpp
    benchmark_views.cpp
    benchmark_xshape.cpp
    benchmark_view_access.cpp
    benchmark_view_assignment.cpp
    benchmark_view_adapt.cpp
    benchmark_stl.cpp
    main.cpp
)
```

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

### Creating Dynamic Strided Views

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/view.md

Demonstrates building a slice vector dynamically at runtime and using it with xt::strided_view. Note that xt::keep and xt::drop are not supported.

```c++
#include <xtensor/containers/xarray.hpp>
#include <xtensor/views/xstrided_view.hpp>

auto a = xt::xarray<int>::from_shape({3, 2, 3, 4, 5});

xt::xstrided_slice_vector sv({xt::range(0, 1), xt::newaxis()});
sv.push_back(1);
sv.push_back(xt::all());

auto v1 = xt::strided_view(a, sv);
// v1 has the same behavior as the static view

// Equivalent but shorter
auto v2 = xt::strided_view(a, { xt::range(0, 1), xt::newaxis(), 1, xt::all() });
// v2 == v1

// ILLEGAL:
auto v2 = xt::strided_view(a, { xt::all(), xt::all(), xt::all(), xt::keep(0, 3), xt::drop(1, 4) });
// xt::drop and xt::keep are not supported with strided views
```

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

### Create dynamic views with xt::dynamic_view

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/view.md

Dynamic views support slices from xt::keep() and xt::drop() at the cost of performance compared to strided views.

```c++
#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()});
sv.push_back(1);
sv.push_back(xt::all());
sv.push_back(xt::keep(0, 2, 3));
sv.push_back(xt::drop(1, 2, 4));

auto v1 = xt::dynamic_view(a, sv});

// Equivalent but shorter
auto v2 = xt::dynamic_view(a, { xt::range(0, 1), xt::newaxis(), 1, xt::all(), xt::keep(0, 2, 3), xt::drop(1, 2, 4) });
// v2 == v1
```

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

### Exposing constrained functions to Python

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/bindings.md

Demonstrates how to register a constrained function with pybind11, requiring explicit template instantiation.

```c++
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>>);
}
```

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

### Using Range Syntax with Strided Views

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/view.md

Shows the shorthand range syntax introduced in xtensor 0.16.3 for defining strided views.

```c++
#include <xtensor/containers/xarray.hpp>
#include <xtensor/views/xstrided_view.hpp>

using namespace xt::placeholders;

auto a = xt::xarray<int>::from_shape({3, 2, 3, 4, 5});
auto v1 = xt::strided_view(a, {_r|0|1, 1, _r|_|2, _r|_|_|-1});
// The previous line is equivalent to
auto v2 = xt::strided_view(a, {xt::range(0, 1), 1, xt::range(_, 2), xt::range(_, _, -1)});
```

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

### Create optional assemblies

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/missing.md

Uses xoptional_assembly to combine value and mask expressions into a single container optimized for element-wise operations.

```cpp
xt::xarray<double> v
    {{ 1.0, 2.0 },
     { 3.0, 4.0 }};

xt::xarray<bool> hv
    {{ true, true  },
     { true, false }};

xt::xoptional_assembly<xt::xarray<double>, xt::xarray<bool>> assembly(v, hv);
std::cout << assembly << std::endl;
```

```c++
{{ 1,  2 },
 { 3, N/A}}
```

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

### Initialize xtensor matrix

Source: https://github.com/xtensor-stack/xtensor/blob/master/notebooks/xtensor.ipynb

Create a 2D double-precision xtensor matrix for linear algebra operations.

```cpp
xt::xtensor<double, 2> m = {{1.5, 0.5}, {0.7, 1.0}};
```

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

### SIMD acceleration link library

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/getting_started.md

Link flag for enabling xsimd acceleration.

```cmake
target_link_libraries(... xtensor::use_xsimd)
```

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

### Define Optional Build Features

Source: https://github.com/xtensor-stack/xtensor/blob/master/CMakeLists.txt

Sets user-configurable options for SIMD and parallelization support, preventing conflicting configurations.

```cmake
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()
```

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

### Initialize xarray with dynamic layout and manual strides

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/container.md

Initializes an xarray with a dynamic layout by providing explicit shape and stride vectors.

```c++
#include <vector>
#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);
```

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

### Print Configuration

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/numpy.md

Functions to configure the display format of tensors and floating point numbers.

```APIDOC
## xt::print_options

### Description
Configures the display settings for xtensor expressions.

### Methods
- **set_precision(int)**: Sets the floating point precision.
- **set_threshold(int)**: Sets the threshold for triggering summary display.
- **set_edgeitems(int)**: Sets the number of items to show at the edges of each dimension.
- **set_line_width(int)**: Sets the maximum line width for output.
```

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

### Implementing xfunction methods

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/expression_tree.md

Illustrates the internal implementation of operator() and broadcast_shape for an xfunction node.

```c++
template <class F, class... CT>
template <class... Args>
inline auto xfunction<F, CT...>::operator()(Args... args) const -> const_reference
{
    return m_functor(m_first(args...), m_second(args...));
}

template <class F, class... CT>
template <class S>
inline bool xfunction<F, CT...>::broadcast_shape(S& shape) const
{
    return m_first.broadcast_shape(shape) && m_second.broadcast_shape(shape);
}
```

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

### Implement resize methods for xtensor containers

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/external-structures.md

Use utility functions from xstrides.hpp to compute strides based on shape and layout during container resizing.

```c++
#include <xtensor/core/xstrides.hpp> // for utility functions

template <class T>
void resize(const shape_type& shape)
{
    if(m_shape != shape)
        resize(shape, layout::row_major);
}

template <class T>
void resize(const shape_type& shape, layout l)
{
    m_raw.m_shape = shape;
    m_raw.m_strides.resize(shape.size());
    m_raw.m_backstrides.resize(shape.size());
    size_type data_size = compute_strides(m_shape, l, m_strides, m_backstrides);
    m_raw.m_data.resize(data_size);
}

template <class T>
void resize(const shape_type& shape, const strides_type& strides)
{
    m_raw.m_shape = shape;
    m_raw.m_strides = strides;
    m_raw.m_backstrides.resize(shape.size());
    adapt_strides(m_raw.m_shape, m_raw.m_strides, m_raw.m_backstrides);
    m_raw.m_data.resize(compute_size(m_shape));
}
```

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

### Instantiate and return xfunction

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/developer/expression_tree.md

The final step in make_xfunction where the function type is instantiated and returned.

```c++
return type(functor_type(), std::forward<E>(e)...);
```

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

### Creating Sliced Views in xtensor

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/view.md

Demonstrates various ways to slice an xarray, including dimension reduction, expansion, and non-contiguous indexing.

```c++
#include <vector>
#include <xtensor/containers/xarray.hpp>
#include <xtensor/views/xview.hpp>

std::vector<size_t> shape = {3, 2, 4};
xt::xarray<int> a(shape);

// View with same number of dimensions
auto v1 = xt::view(a, xt::range(1, 3), xt::all(), xt::range(1, 3));
// => v1.shape() = { 2, 2, 2 }
// => v1(0, 0, 0) = a(1, 0, 1)
// => v1(1, 1, 1) = a(2, 1, 2)

// View reducing the number of dimensions
auto v2 = xt::view(a, 1, xt::all(), xt::range(0, 4, 2));
// => v2.shape() = { 2, 2 }
// => v2(0, 0) = a(1, 0, 0)
// => v2(1, 1) = a(1, 1, 2)

// View increasing the number of dimensions
auto v3 = xt::view(a, xt::all(), xt::all(), xt::newaxis(), xt::all());
// => v3.shape() = { 3, 2, 1, 4 }
// => v3(0, 0, 0, 0) = a(0, 0, 0)

// View with non contiguous slices
auto v4 = xt::view(a, xt::drop(0), xt::all(), xt::keep(0, 3));
// => v4.shape() = { 2, 2, 2 }
// => 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
```

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

### Instantiate optional tensors

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/missing.md

Demonstrates creating a 2-D tensor with missing values using xt::xtensor_optional and its equivalent representation using xt::xtensor with xtl::xoptional.

```cpp
xt::xtensor_optional<double, 2> m
    {{ 1.0 ,       2.0         },
     { 3.0 , missing<double>() }};
```

```cpp
xt::xtensor<xtl::xoptional<double>, 2> m
    {{ 1.0 ,       2.0         },
     { 3.0 , missing<double>() }};
```

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

### Define Custom Benchmark Targets

Source: https://github.com/xtensor-stack/xtensor/blob/master/benchmark/CMakeLists.txt

Creates custom targets for running standard benchmarks and power-governor-aware performance benchmarks.

```cmake
add_custom_target(xbenchmark
    COMMAND benchmark_xtensor
    DEPENDS ${XTENSOR_BENCHMARK_TARGET})

add_custom_target(xpowerbench
    COMMAND echo "sudo needed to set cpu power governor to performance"
    COMMAND sudo cpupower frequency-set --governor performance
    COMMAND benchmark_xtensor --benchmark_out=results.csv --benchmark_out_format=csv
    COMMAND sudo cpupower frequency-set --governor powersave
    DEPENDS ${XTENSOR_BENCHMARK_TARGET})
```

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

### Initialize xarray with dynamic layout and layout type

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/container.md

Initializes an xarray with a dynamic layout by specifying the layout type instead of manual strides.

```c++
#include <vector>
#include <xtensor/containers/xarray.hpp>

std::vector<size_t> shape = { 3, 2, 4 };
xt::xarray<double, xt::layout_type::dynamic> a(shape, xt::layout_type::row_major);
```

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

### Initialize xchunked_array with dynamic shape

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/quickref/basic.md

Demonstrates creating an in-memory chunked array with specified total and chunk shapes.

```c++
#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);
```

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

### Configure NPY test files

Source: https://github.com/xtensor-stack/xtensor/blob/master/test/CMakeLists.txt

Copies NPY test files from the source directory to the binary directory for test execution.

```cmake
set(XNPY_FILES
    bool
    bool_fortran
    double
    double_fortran
    int
    unsignedlong
    unsignedlong_fortran
)

foreach(filename IN LISTS XNPY_FILES)
    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()
```

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

### Create a vectorized xfunction with a lambda

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/closure-semantics.md

Uses a lambda to compute expressions like sin(A) + cos(A) efficiently, enabling xsimd acceleration.

```cpp
template <class E>
inline auto sin_plus_cos(E&& e) noexcept
{
    auto func = [](auto x) -> decltype(sin(x) + cos(x)) {
        return sin(x) + cos(x);
    };
    return detail::make_lambda_function(std::move(func), std::forward<E>(e));
}
```

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

### Expected output format

Source: https://github.com/xtensor-stack/xtensor/blob/master/docs/source/api/xio.md

Shows the default string representation of a 2x3 xarray.

```text
{{ 1., 2., 3.},
 { 4., 5., 6.}}
```
Tokens:
Raw