Numpy: Как создать указанный массив c (итератор был бы еще лучше)

Question

Мне нужен массив или итератор для l oop on со следующими характеристиками c:

1 ° У меня есть набор из $ d $ векторов размера $ n $ (случайный, отсортировано), скажем, x [0], ..., x [d-1].

2 ° Я хочу, чтобы каждое повторяемое значение было размером od вектора $ d $ со всеми комбинациями потенциальных значений из вышеуказанный вектор. Что означает:

y[0]       : [x[0,0], x[1,0],....,x[d-1,0]]
y[1]       : [x[0,1], x[1,0],....,x[d-1,0]]
y[2]       : [x[0,0], x[1,1],....,x[d-1,0]]
...
y[-1]      : [x[0,n-1], x[1,n-1],...., x[d-1,n-1]]

Как мне создать этот массив или этот итератор?

для примера, для d = 3 и n = 3 это даст следующие векторы:

y[0]       : [x[0,0], x[1,0], x[2,0]]
y[1]       : [x[0,1], x[1,0], x[2,0]]
y[2]       : [x[0,2], x[1,0], x[2,0]]

y[3]       : [x[0,0], x[1,1], x[2,0]]
y[4]       : [x[0,1], x[1,1], x[2,0]]
y[5]       : [x[0,2], x[1,1], x[2,0]]

y[6]       : [x[0,0], x[1,2], x[2,0]]
y[7]       : [x[0,1], x[1,2], x[2,0]]
y[8]       : [x[0,2], x[1,2], x[2,0]]

y[9]       : [x[0,0], x[1,0], x[2,1]]
y[10]      : [x[0,1], x[1,0], x[2,1]]
y[11]      : [x[0,2], x[1,0], x[2,1]]

y[12]      : [x[0,0], x[1,1], x[2,1]]
y[13]      : [x[0,1], x[1,1], x[2,1]]
y[14]      : [x[0,2], x[1,1], x[2,1]]

y[15]      : [x[0,0], x[1,2], x[2,1]]
y[16]      : [x[0,1], x[1,2], x[2,1]]
y[17]      : [x[0,2], x[1,2], x[2,1]]

y[18]      : [x[0,0], x[1,0], x[2,2]]
y[19]      : [x[0,1], x[1,0], x[2,2]]
y[20]      : [x[0,2], x[1,0], x[2,2]]

y[21]      : [x[0,0], x[1,1], x[2,2]]
y[22]      : [x[0,1], x[1,1], x[2,2]]
y[23]      : [x[0,2], x[1,1], x[2,2]]

y[24]      : [x[0,0], x[1,2], x[2,2]]
y[25]      : [x[0,1], x[1,2], x[2,2]]
y[26]      : [x[0,2], x[1,2], x[2,2]]

Я даже не знаю, сколько должно быть в зависимости от (n, d) ...

У вас есть идея?

Answer 1

Могут быть более аккуратные способы сделать это, но я думаю, что это делает то, о чем просят.

import numpy as np

def rows( d, n ):
    """ Generates row indices. """
    arr = np.zeros( shape = d, dtype = np.int )

    def inc_row( arr ):
        for ix in range(0, len(arr)):
            arr[ ix ] += 1
            if arr[ ix ] < n:
                return arr   # If arr[ix] doesn't roll over return arr
            arr[ ix ] = 0      # Reset arr[ix] to zero if it rolls over
        return None   # Return None once all indices reset to zero. 

    while not arr is None:
        yield arr
        arr = inc_row( arr )

def permutations( base, d, n ):
    """ Generate the required combinations of values from base. """
    cols = np.arange( d )
    res = []
    for row in rows( d, n ):
        res.append( base[ row, cols ] )
    return np.array(res)

d = 3
n = 2

base = np.fromfunction( lambda x,y : x+y/10, shape = (n,d))
# For testing 'base' array values indicate location r.c

print(base)
# [[0.  0.1 0.2]
#  [1.  1.1 1.2]]

print(permutations( base, d, n ))
# [[0.  0.1 0.2]
#  [1.  0.1 0.2]
#  [0.  1.1 0.2]
#  [1.  1.1 0.2]
#  [0.  0.1 1.2]
#  [1.  0.1 1.2]
#  [0.  1.1 1.2]
#  [1.  1.1 1.2]]

HTH