通过内部数据索引和顺序访问数组元素

Question

This algorithmic problem is a bit too complex for me:

I have an NumPy array of data which is internally indexed in a peculiar way. The data is an output of two arrays spliced together (which I don't have), with distinct ordering. I set the parameter max to be a positive integer, and the data output has the index format

[ 00 10 20 ... max0 11 12 ... max1 22 23....max2 33....max max ]

The parameter max determines the output of the array (ie the length of the array) and the ordering.

For several examples, for max=2 , the data is of the order

[00 10 20 11 21 22]

Setting max=3 gives

[00 10 20 30 11 21 31 22 32 33]

And max=4 is

[00 10 20 30 40 11 21 31 41 22 32 42 33 43 44]

And so on.

I would like to write an algorithm to make a list/array of only the 3x values, ie the values with first index 3. That is, I would only like to access certain data values, organized by the first index.

However, this is determined by the parameter max . As you can see, this determines where the datum is placed by the array index. My only idea is to make some sort of sorting tree, but I am not sure how to execute that with this max parameter.

Answer 1

This list comprehension (or iteration) produces the indexs that you show

[[j*10+i for j in range(i,max+1)] for i in range(max+1)]

max=2: [[0, 10, 20], [11, 21], [22]]
max=3: [[0, 10, 20, 30], [11, 21, 31], [22, 32], [33]]
max=4: [[0, 10, 20, 30, 40], [11, 21, 31, 41], [22, 32, 42], [33, 43], [44]]

These lists of lists can be flattened. But this arrangement may make it easier to think about the problem.

Or is it more useful to generate tuples:

In [134]: [[(j,i) for j in range(i,max+1)] for i in range(max+1)]
Out[134]: 
[[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0)],
 [(1, 1), (2, 1), (3, 1), (4, 1)],
 [(2, 2), (3, 2), (4, 2)],
 [(3, 3), (4, 3)],
 [(4, 4)]]

It isn't clear what you want to do with these numbers or indices, but here's an example of putting them in a 2d array:

In [150]: dlist=[[j*10+i for j in range(i,max+1)] for i in range(max+1)]
In [151]: ilist=[[(j,i) for j in range(i,max+1)] for i in range(max+1)]

In [152]: import itertools

In [155]: M=np.zeros((max+1,max+1),int)
In [157]: for (i,j),d in zip(itertools.chain(*ilist),itertools.chain(*dlist)):
    M[i,j]=d

In [158]: M
Out[158]: 
array([[ 0,  0,  0,  0,  0],
       [10, 11,  0,  0,  0],
       [20, 21, 22,  0,  0],
       [30, 31, 32, 33,  0],
       [40, 41, 42, 43, 44]])

The 1st 5 numbers go in the 1st column, 2nd 4 in the next, etc.

itertools.chain is one way of flattening a list of lists.

The layout of M looks like a lower-triangle. There's a numpy function to generate those indices:

In [176]: np.tril_indices(5)
Out[176]: 
(array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4], dtype=int32),
 array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4], dtype=int32))

So I could have filled M with:

data =  np.dot([10,1],np.tril_indices(5))
M[np.tril_indices(5)] = data

Digging into the code of tril_indices I find that the starting point is a mask of 1s generated by:

I=((np.arange(max)-np.arange(max)[:,None])<0).astype(int)
array([[0, 0, 0, 0],
       [1, 0, 0, 0],
       [1, 1, 0, 0],
       [1, 1, 1, 0]])