• Consistent set of tools to improve and unify scientific computing workflows,
• An interface between metal and humans, metal and flesh.

From day 1, Jupyter was developed by scientists for scientists and educators

Programming languages are not only used to build complex systems, but also to explore and gain insight about

• A computing resource
• A data set
• The outcome of a simulation

• Taylored for performances
• With a massive community
• Especially in HPC

This hurts productivity of C++ software developers.

• C++ is generally considered as a difficult programming language
• Heterogeneous set of tools...
• ... that don't always play well together
• making scientific workflows hard to reproduce

Xtensor is a flexible expression system in which any data structure can be plugged, offering the most expressive API to the users.

• A C++ template library for multi-dimensional array manipulation

  [xtensor]

  • Followings the idioms of the C++ STL

    (iterator pairs, clear value semantics)

  • But also an API similar to that of numpy

• Python bindings to enable xtensor APIs on numpy arrays.

  [xtensor-python]

• Julia bindings to enable xtensor APIs on Julia arrays.

  [xtensor-julia]

• R bindings to enable xtensor APIs on R arrays.

  [xtensor-r]

• Cookiecutter projects for authoring of Python, Julia, and R extensions.

  [xtensor-cookiecutter]

• BLAS bindings to enable BLAS operations on xtensor expressions.

  [xtensor-blas]

• SIMD acceleration kernels.

  [xsimd]
• All open-source (BSD License).

Ever heard of numpy ?

C++: Using an algorithm from the STL on a numpy array

#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

double sum_of_sines(xt::pyarray<double>& m)
{
    auto sines = xt::sin(m);
    // sines does not actually hold any value, which are only computed upon access
    return std::accumulate(sines.begin(), sines.end(), 0.0);
}

PYBIND11_PLUGIN(xtensor_python_test)
{
    xt::import_numpy();
    pybind11::module m("xtensor_python_test", "Test module for xtensor python bindings");

    m.def("sum_of_sines", sum_of_sines,
        "Computes the sum of the sines of the values of the input array");

    return m.ptr();
}

Python: Using an algorithm from the STL on a numpy array

import numpy as np
import xtensor_python_test as xt

a = np.arange(15).reshape(3, 5)
xt.sum_of_sines(v)

C++: Create a universal function from a C++ scalar function

#include "pybind11/pybind11.h"
#define FORCE_IMPORT_ARRAY
#include "xtensor-python/pyvectorize.hpp"
#include <numeric>
#include <cmath>

namespace py = pybind11;

double scalar_func(double i, double j)
{
    return std::sin(i) - std::cos(j);
}

PYBIND11_PLUGIN(xtensor_python_test)
{
    xt::import_numpy();
    py::module m("xtensor_python_test", "Test module for xtensor python bindings");

    m.def("vectorized_func", xt::pyvectorize(scalar_func), "");

    return m.ptr();
}

Python: Create a numpy-style universal function from a C++ scalar function

import numpy as np
import xtensor_python_test as xt

x = np.arange(15).reshape(3, 5)
y = [1, 2, 3, 4, 5]
xt.vectorized_func(x, y)

C++: Using an algorithm from the STL on a Julia array

#include <numeric>                        // Standard library import for std::accumulate
#include "jlcxx/jlcxx.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

double sum_of_sines(xt::jltensor<double, 2> m)
{
    auto sines = xt::sin(m);  // sines does not actually hold values.
    return std::accumulate(sines.cbegin(), sines.cend(), 0.0);
}

JULIA_CPP_MODULE_BEGIN(registry)
    jlcxx::Module mod = registry.create_module("xtensor_julia_test");
    mod.method("sum_of_sines", sum_of_sines);
JULIA_CPP_MODULE_END

Julia: Using an algorithm from the STL on a Julia array

using xtensor_julia_test

arr = [[1.0 2.0]
       [3.0 4.0]]

sum_of_sines(arr)

C++: Create a numpy-style universal function from a C++ scalar function

#include "jlcxx/jlcxx.hpp"
#include "xtensor-julia/jlvectorize.hpp"

double scalar_func(double i, double j)
{
    return std::sin(i) - std::cos(j);
}

JULIA_CPP_MODULE_BEGIN(registry)
    jlcxx::Module mod = registry.create_module("xtensor_julia_test");
    mod.method("vectorized_func", xt::jlvectorize(scalar_func));
JULIA_CPP_MODULE_END

Julia: Create a numpy-style universal function from a C++ scalar function

using xtensor_julia_test

x = [[ 0.0  1.0  2.0  3.0  4.0]
     [ 5.0  6.0  7.0  8.0  9.0]
     [10.0 11.0 12.0 13.0 14.0]]
y = [1.0, 2.0, 3.0, 4.0, 5.0]
xt.vectorized_func(x, y)

C++: Using an algorithm from the STL on a R array

// [[Rcpp::export]]
double sum_of_sines(xt::rarray<int> m)
{
    auto sines = xt::sin(m);  // sines does not actually hold values.
    return std::accumulate(sines.cbegin(), sines.cend(), 0.0);
}

R: Using an algorithm from the STL on a R array

library('xtensor_r_test')

arr <- array(c(c(1, 2), c(3, 4)), dim = c(2, 2)

xtensor_r_test::sum_of_sines(arr)

Generate your packaged xtensor extension

• With a few examples from the documentation
• Unit-tests
• HTML documentation
• Packaging boilerplate (setup.py, build.jl)

BLAS-based implementation of numpy.linalg

• ISO results with numpy.linalg is main goal
• Seeking adoption by Python to C++ compilers (Pythran, Jet)
• Works with any BLAS implementation (openblas, mkl, netlib)
• See the numpy to xtensor cheat sheet

GitHub

• xeus: github.com/QuantStack/xeus/
• xeus-cling: github.com/QuantStack/xeus-cling/
• xproperty: github.com/QuantStack/xproperty/
• xframe: github.com/QuantStack/xframe/
• xtensor: github.com/QuantStack/xtensor/
• xtensor-blas: github.com/QuantStack/xtensor-blas/
• xtensor-python: github.com/QuantStack/xtensor-python/
• xtensor-r: github.com/QuantStack/xtensor-r/
• xtensor-julia: github.com/QuantStack/xtensor-julia/
• xsimd: github.com/QuantStack/xsimd/
• xtensor-fftw: github.com/egpbos/xtensor-fftw/
• xwidgets: github.com/QuantStack/xwidgets/
• xleaflet: github.com/QuantStack/xleaflet/
• xplot: github.com/QuantStack/xplot/
• xwebrtc: github.com/QuantStack/xwebrtc/