Numpy Probleme mit Arrays von poly1d Objekten

Question

Ich mag würde zunächst mit der Tatsache ausgehen, daß es möglich ist, in numpy, eine Reihe von poly1d Objekten zu erstellen:

random_poly = np.frompyfunc(lambda i, j: np.poly1d(np.random.randint(1, 4, 3)), 2, 1) 
def random_poly_array(shape):  
    return np.fromfunction(random_poly, shape) 

a1 = random_poly_array((3,3)) 

Dies funktioniert gut, und wir können auch Matrizen aus dieser Form gemacht multiplizieren np.dot mit:

a2 = random_poly_array((3,3)) 
a1_x_a2 = np.dot(a1, a2) 

jedoch die meisten anderen Methoden nicht funktionieren. Zum Beispiel können Sie nicht eine Liste bestimmter poly1d Objekte nehmen und es in ein Array umwandeln:

np.array([np.poly1d([1,2,3]), np.poly1d([1,2,3])]) 

Wie das wird ValueError: cannot copy sequence with size 2 to array axis with dimension 3 erhöhen. Hinzufügen zu der Verwirrung,

np.array([np.poly1d([1,2]), np.poly1d([1,2])]) 

wird keinen Fehler aus, sondern schaffen eine 2x2 Array von nur 2 Jahren. Das Hinzufügen von dtype=object hat keine Auswirkungen, und numpy wird weiterhin versuchen, die poly1d Objekte in Arrays zu konvertieren.

---

Der Grund, warum dies problematisch ist, ist, dass man nicht eine Reihe von Dimension d und wandelt es in eine Reihe von poly1d Objekten der Dimension d-1 nehmen. Ich hätte

erwartet

arr = np.arange(1, 10).reshape(3,3) 
np.apply_along_axis(np.poly1d, 0, arr) 

Um ein Array von poly1d Objekte zurück, sondern gibt sie einen unalterated Array. Noch schlimmer, wenn arr=np.arange(9).reshape(3,3), wird es einen Fehler werfen, da das erste poly1d Objekt erstellt eine Länge von 2 statt 3 aufgrund der Null-Koeffizienten haben wird. Also, meine Frage ist das: Gibt es eine machbare Methode, poly1d Arrays in numpy zu erstellen? Wenn nicht, warum nicht?

Answer 1

Mit dem Konzept der Nonenumpy zwingen nicht ein Objekt in ein Array zu übertragen, etwas aufmerksam gemacht durch Paul Panzer, habe ich eine Funktion, die die letzte Achse in ein poly1d Objekt verwandeln:

def array_to_poly(arr): 
    return np.apply_along_axis(lambda poly: [None, np.poly1d(poly)], -1, arr)[..., 1] 

wenn wir jedoch mit missbrauchen mehr als einem System in einer einzigen Funktion in Ordnung sind, dann können wir es über beliebige Achsen machen anwenden:

def array_to_poly(arr, axis=-1): 
    temp_arr = np.apply_along_axis(lambda poly: [None, np.poly1d(poly)], axis, arr) 
    n = temp_arr.ndim 
    s = [slice(None) if i != axis%n else 1 for i in range(n)] 
    return temp_arr[s] 

Testing mit arr = np.arange(1, 25).reshape(2,3,4) erhalten wir:

In [ ]: array_to_poly(arr, 0) 
Out[ ]: 
array([[poly1d([ 1, 13]), poly1d([ 2, 14]), poly1d([ 3, 15]), 
     poly1d([ 4, 16])], 
     [poly1d([ 5, 17]), poly1d([ 6, 18]), poly1d([ 7, 19]), 
     poly1d([ 8, 20])], 
     [poly1d([ 9, 21]), poly1d([10, 22]), poly1d([11, 23]), 
     poly1d([12, 24])]], dtype=object) 

In [ ]: array_to_poly(arr, 1) 
Out[ ]: 
array([[poly1d([1, 5, 9]), poly1d([ 2, 6, 10]), poly1d([ 3, 7, 11]), 
     poly1d([ 4, 8, 12])], 
     [poly1d([13, 17, 21]), poly1d([14, 18, 22]), poly1d([15, 19, 23]), 
     poly1d([16, 20, 24])]], dtype=object) 

In [ ]: array_to_poly(arr, 2) 
Out[ ]: 
array([[poly1d([1, 2, 3, 4]), poly1d([5, 6, 7, 8]), 
     poly1d([ 9, 10, 11, 12])], 
     [poly1d([13, 14, 15, 16]), poly1d([17, 18, 19, 20]), 
     poly1d([21, 22, 23, 24])]], dtype=object) 

wie erwartet.