NF: add strided_scalar function

Function to return scalar broadcast out to form full array of given
shape.

Author: matthew-brett

nibabel/fileslice.py

@@ -747,3 +747,26 @@ def fileslice(fileobj, sliceobj, shape, dtype, offset=0, order='C',
     bytes = read_segments(fileobj, segments, n_bytes)
     sliced = np.ndarray(sliced_shape, dtype, buffer=bytes, order=order)
     return sliced[post_slicers]
+
+
+def strided_scalar(shape, scalar=0.):
+    """ Return array shape `shape` where all entries point to value `scalar`
+
+    Parameters
+    ----------
+    shape : sequence
+        Shape of output array.
+    scalar : scalar
+        Scalar value with which to fill array.
+
+    Returns
+    -------
+    strided_arr : array
+        Array of shape `shape` for which all values == `scalar`, built by
+        setting all strides of `strided_arr` to 0, so the scalar is broadcast
+        out to the full array `shape`.
+    """
+    shape = tuple(shape)
+    scalar = np.array(scalar)
+    strides = [0] * len(shape)
+    return np.lib.stride_tricks.as_strided(scalar, shape, strides)

nibabel/tests/test_fileslice.py

@@ -14,7 +14,8 @@
                          predict_shape, read_segments, _positive_slice,
                          threshold_heuristic, optimize_slicer, slice2len,
                          fill_slicer, optimize_read_slicers, slicers2segments,
-                         calc_slicedefs, _simple_fileslice, slice2outax)
+                         calc_slicedefs, _simple_fileslice, slice2outax,
+                         strided_scalar)
 
 from nose.tools import assert_true, assert_false, assert_equal, assert_raises
 
@@ -627,6 +628,23 @@ def test_predict_shape():
     assert_equal(predict_shape((1, slice(None), None), (2, 3)), (3, 1))
 
 
+def test_strided_scalar():
+    # Utility to make numpy array of given shape from scalar using striding
+    for shape, scalar in product(
+        ((2,), (2, 3,), (2, 3, 4)),
+        (1, 2, np.int16(3))):
+        expected = np.zeros(shape, dtype=np.array(scalar).dtype) + scalar
+        observed = strided_scalar(shape, scalar)
+        assert_array_equal(observed, expected)
+        assert_equal(observed.shape, shape)
+        assert_equal(observed.dtype, expected.dtype)
+        assert_array_equal(observed.strides, 0)
+        observed[..., 0] = 99
+        assert_array_equal(observed, expected * 0 + 99)
+    # Default scalar value is 0
+    assert_array_equal(strided_scalar((2, 3, 4)), np.zeros((2, 3, 4)))
+
+
 def _check_bytes(bytes, arr):
     barr = np.ndarray(arr.shape, arr.dtype, buffer=bytes)
     assert_array_equal(barr, arr)