DynamicArray class

(Shortest import: from brian2.memory.dynamicarray import DynamicArray)

class brian2.memory.dynamicarray.DynamicArray(shape, dtype=<class 'float'>, factor=2, use_numpy_resize=False, refcheck=True)

Bases: object

An N-dimensional dynamic array class

The array can be resized in any dimension, and the class will handle allocating a new block of data and copying when necessary.

Warning

The data will NOT be contiguous for >1D arrays. To ensure this, you will either need to use 1D arrays, or to copy the data, or use the shrink method with the current size (although note that in both cases you negate the memory and efficiency benefits of the dynamic array).

Initialisation arguments:

shape, dtype

The shape and dtype of the array to initialise, as in Numpy. For 1D arrays, shape can be a single int, for ND arrays it should be a tuple.

factor

The resizing factor (see notes below). Larger values tend to lead to more wasted memory, but more computationally efficient code.

use_numpy_resize, refcheck

Normally, when you resize the array it creates a new array and copies the data. Sometimes, it is possible to resize an array without a copy, and if this option is set it will attempt to do this. However, this can cause memory problems if you are not careful so the option is off by default. You need to ensure that you do not create slices of the array so that no references to the memory exist other than the main array object. If you are sure you know what you’re doing, you can switch this reference check off. Note that resizing in this way is only done if you resize in the first dimension.

The array is initialised with zeros. The data is stored in the attribute data which is a Numpy array.

Some numpy methods are implemented and can work directly on the array object, including len(arr), arr[...] and arr[...]=.... In other cases, use the data attribute.

Notes

The dynamic array returns a data attribute which is a view on the larger _data attribute. When a resize operation is performed, and a specific dimension is enlarged beyond the size in the _data attribute, the size is increased to the larger of cursize*factor and newsize. This ensures that the amortized cost of increasing the size of the array is O(1).

Examples

>>> x = DynamicArray((2, 3), dtype=int)
>>> x[:] = 1
>>> x.resize((3, 3))
>>> x[:] += 1
>>> x.resize((3, 4))
>>> x[:] += 1
>>> x.resize((4, 4))
>>> x[:] += 1
>>> x.data[:] = x.data**2
>>> x.data
array([[16, 16, 16,  4],
       [16, 16, 16,  4],
       [ 9,  9,  9,  4],
       [ 1,  1,  1,  1]])

Methods

resize(newshape)	Resizes the data to the new shape, which can be a different size to the current data, but should have the same rank, i.e. same number of dimensions.
resize_along_first(newshape)
shrink(newshape)	Reduces the data to the given shape, which should be smaller than the current shape.

Details

resize(newshape)

Resizes the data to the new shape, which can be a different size to the current data, but should have the same rank, i.e. same number of dimensions.

resize_along_first(newshape)

shrink(newshape)

Reduces the data to the given shape, which should be smaller than the current shape. resize() can also be used with smaller values, but it will not shrink the allocated memory, whereas shrink will reallocate the memory. This method should only be used infrequently, as if it is used frequently it will negate the computational efficiency benefits of the DynamicArray.