Filling 1D arrays into 3D arrays vectorisation

Question

I have a function init_tensor() which broadcasts a 2d matrix of dimension (N,N) into 3d block matrix of dim (M,N,N) so that there are M matrices of dimension NXN:

def init_tensor(input_state, sample_size):
    return np.broadcast_to(input_state, (sample_size,)+input_state.shape)

So for example if I want to create 3 (4x4) matrices then I could do:

init_tensor(np.eye(4, dtype=complex), 3)
Out[462]: 
array([[[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]],

       [[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]],

       [[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
        [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]]])

The problem I have is that I have some arrays with dim (1,M) which I'd like to fill into the 3D array as its elements. For a simple case if M was 3 and I have:

lambda1 = [l11,l12,l13]
lambda2 = [l21,l22,l23]
lambda3 = [l31,l32,l33]
tau1 = [t11,t12,t13]
tau2 = [t21,t22,t23]
tau3 = [t31,t32,t33]

I'd like a vectorised way where I can fill them into the tensor such that it becomes:

array([[[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [   t11,    l11, 0.+0.j, 0.+0.j],
        [   t21, 0.+0.j,    l21, 0.+0.j],
        [   t31, 0.+0.j, 0.+0.j,    l31]],

       [[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [   t12,    l12, 0.+0.j, 0.+0.j],
        [   t22, 0.+0.j,    l22, 0.+0.j],
        [   t32, 0.+0.j, 0.+0.j,    l32]],

       [[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
        [   t13,    l13, 0.+0.j, 0.+0.j],
        [   t23, 0.+0.j,    l23, 0.+0.j],
        [   t33, 0.+0.j, 0.+0.j,    l33]]])

The depth of the tensor matrix will always be the same as the length of the 1D arrays, and the value of M can vary between 1 to 100.

If you dropped the `complex` it would be easier to visualize what you trying to do. — hpaulj, Mar 11 '20 at 18:43
There's a collection of `np.tri*` functions for accessing and filling upper and lower triangles. — hpaulj, Mar 11 '20 at 18:54

score 0 · Accepted Answer · answered Mar 12 '20 at 07:26

You can use numpys advanced indexing to get this result:

import numpy as np

m = 3
n = 4
arr = np.ones((m, n, n), dtype=int)

lmbda = 10 * np.arange(1, (n-1)**2+1).reshape(n-1, n-1)
# lmbda = [[l11,l12,l13]
#          [l21,l22,l23]
#          [l31,l32,l33]]
# array([[10, 20, 30],
#        [40, 50, 60],
#        [70, 80, 90]])
tau = -10 * np.arange(1, (n-1)**2+1).reshape(n-1, n-1)
# array([[-10, -20, -30],
#        [-40, -50, -60],
#        [-70, -80, -90]])

arr[:, range(1, n), range(1, n)] = lmbda.T
arr[:, range(1, n), 0] = tau.T  # arr[:, 1:, 0] = tau.T  # alternative
# array([[[  1,   1,   1,   1],
#         [-10,  10,   1,   1],
#         [-40,   1,  40,   1],
#         [-70,   1,   1,  70]],
#        [[  1,   1,   1,   1],
#         [-20,  20,   1,   1],
#         [-50,   1,  50,   1],
#         [-80,   1,   1,  80]],
#        [[  1,   1,   1,   1],
#         [-30,  30,   1,   1],
#         [-60,   1,  60,   1],
#         [-90,   1,   1,  90]]])

it's weird how your method works with the way you're generating your tensor but when I do the same with mine it gives `ValueError: assignment destination is read-only` — user3613025, Mar 12 '20 at 11:23
And what is your way of generating the arrays. Maybe use ´arr = arr.copy()´. See also this [question](https://stackoverflow.com/questions/39554660/np-arrays-being-immutable-assignment-destination-is-read-only) — scleronomic, Mar 14 '20 at 21:27

Filling 1D arrays into 3D arrays vectorisation

1 Answers1