Produkt kartezjański tablic

Witam,

problem mam taki:
mam sobie tablicę:

$a=array(array(1,2,3),array('aaa','bbb')

z niej muszę utworzyć tak kombinację aby wygenerować tablice zawerającą pary elementów z pierwszej i drugiej tablicy, dla każdej możliwości, tzn wynik powinien być nastepujący:

array(array(1,'aaa'),array(2,'aaa'),array(3,'aaa'),array(1,'bbb'),array(2,'bbb'),array(3,'bbb'));

liczba elementów może byc różna w tablicach, jak i może być różna liczba tablic, ale zawsze ma być tak żeby wartości z pierwszej tablicy były na 1 miejscu, drugiej na drugim itp.

Obecnie znalazłem taki kod:

function comb($a){
   $out = array();
   if (count($a) == 1) {
      $x = array_shift($a);
      foreach ($x as $v) $out[] = array($v);
      return $out;
   }
   foreach ($a as $k => $v){
      $b = $a;
      unset($b[$k]);
      $x = comb($b);
      foreach ($v as $v1){
         foreach ($x As $v2) 
         $out[] = array_merge(array($v1), $v2);
      }
   }
   return $out;
}
 

Ale on niestety generuje wszystkie możliwe mutacje, nie zważając na pozycję, a nie wiem jak to zmienić.

nie wiem czy dobrze rozumiem, ale czy zwykłe zagnieżdżone pętle tego nie rozwiązują?

fun generuj(atab, btab)
    restult = array()
    foreach element a in atab
        foreach element b in btab
            array += (a,b)

niespecjalnie, bo nie wiem ile mam tablic

No to algorytm trzeba zapuścić na wyniku dla pierwszych dwóch i reszty. Czyli za każdym razem wejściowa tablica skraca się o jeden element.
Żeby móc to zastosować ten algorytm na wejściowej tablicy trzeba przygotować jej pierwszy element tak, aby wyglądał jak po pierwszym kroku obliczeń (czyli każdy element pierwszej tablicy przekształcamy w tablicę jednoelementową)

def scalDwieTablice(xs, ys):
    # do kazdego elementu pierwszej tablicy (ktory jest tablica/krotka)
    # dodaj kolejny element z drugiej tablicy
    rs = []
    for x in xs:
        for y in ys:
           rs.append(x + [y])
    return rs

def redukuj(megalista):
    if len(megalista) <= 1:
        return megalista
    head = [scalDwieTablice(megalista[0], megalista[1])] + megalista[2:]
    return redukuj(head)

def algorytm(xss):
    # kazdy element pierwszej (zerowej) tablicy przeksztalcamy na liste 1-elementowa
    return redukuj([[[x] for x in xss[0]]] + xss[1:])

# pierwsze dwa wywolania sa takie same. Pierwsze pokazuje jak wyglada pierwszy
# element tablicy wejsciowej, czyli to, co robi funkcja algorytm
print redukuj ([ [[1],[2]], ['a','b'] ])
print algorytm([ [1,2],     ['a','b'] ])

print algorytm([ [1,2], ['a','b','c'], ['M','N']])
print algorytm([ [1,2], ['a','b'], ['M','N'], ['X','Y']])

[[[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]]
[[[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]]
[[[1, 'a', 'M'], [1, 'a', 'N'], [1, 'b', 'M'], [1, 'b', 'N'], [1, 'c', 'M'], [1, 'c', 'N'], [2, 'a', 'M'], [2, 'a', 'N'], [2, 'b', 'M'], [2, 'b', 'N'], [2, 'c', 'M'], [2, 'c', 'N']]]
[[[1, 'a', 'M', 'X'], [1, 'a', 'M', 'Y'], [1, 'a', 'N', 'X'], [1, 'a', 'N', 'Y'], [1, 'b', 'M', 'X'], [1, 'b', 'M', 'Y'], [1, 'b', 'N', 'X'], [1, 'b', 'N', 'Y'], [2, 'a', 'M', 'X'], [2, 'a', 'M', 'Y'], [2, 'a', 'N', 'X'], [2, 'a', 'N', 'Y'], [2, 'b', 'M', 'X'], [2, 'b', 'M', 'Y'], [2, 'b', 'N', 'X'], [2, 'b', 'N', 'Y']]]
 

już wiem jak to się nazywa: Produkt kartezjański.