named-arrays 0.1.8

Numpy arrays with labeled axes, similar to xarray but with support for uncertainties

named_arrays

named_arrays is an implementation of a named tensor, which assigns names to each axis of an n-dimensional array such as a numpy array.

When using a numpy array, we often have to insert singleton dimensions to align axes before using binary operators etc. This is not necessary when using a named tensor implementation such as xarray or named_arrays, axes are aligned automatically using their names.

Installation

named_arrays is available on PyPi and can be installed using pip

pip install named-arrays

Examples

ScalarArray

The fundamental type of named_arrays is the ScalarArray, which is a composition of a numpy ndarray-like object and a tuple of axis names which must have the same length as the number of dimensions in the array.

import numpy as np
import named_arrays as na

a = na.ScalarArray(np.array([1, 2, 3]), axes=('x',))

If we create another array with a different axis name, it will be broadcasted automatically against the first array if we add them together

b = na.ScalarArray(np.array([4, 5]), axes=('y',))
c = a + b
c

ScalarArray(
    ndarray=[[5, 6],
             [6, 7],
             [7, 8]],
    axes=('x', 'y'),
)

All the usual numpy reduction operations use the axis name instead of the axis index

c.mean('x')

ScalarArray(
    ndarray=[6., 7.],
    axes=('y',),
)

To index the array we can use a dictionary with the axis names as the keys

c[dict(x=0)]

ScalarArray(
    ndarray=[5, 6],
    axes=('y',),
)

ScalarLinearSpace

We recommend that you rarely directly create instances of ScalarArray directly. Instead, you can use the implicit array classes: ScalarLinearSpace, ScalarLogarithmicSpace, and ScalarGeometricSpace to create arrays in a similar fashion to numpy.linspace(), numpy.logspace(), and numpy.geomspace() with the advantage of being able to access the inputs to these functions at a later point.

d = na.ScalarLinearSpace(0, 1, axis='z', num=4)
d

ScalarLinearSpace(start=0, stop=1, axis='z', num=4, endpoint=True)

Thses implicit array classes work just like ScalarArray and can be used with any of the usual array operations.

a + d

ScalarArray(
    ndarray=[[1.        , 1.33333333, 1.66666667, 2.        ],
             [2.        , 2.33333333, 2.66666667, 3.        ],
             [3.        , 3.33333333, 3.66666667, 4.        ]],
    axes=('x', 'z'),
)