Python neuere Version

[Brando]

Hallo

in einer alten Version mit Spyder funktioniert folgender Pythoncode zum Gram-Schmidt verfahren:

Code: Alles auswählen

import numpy as np

matrix_ausgang = Matrix()

def gs_cofficient(v1, v2):
  return np.dot(v2, v1) / np.dot(v1, v1)

def multiply(cofficient, v):
  return map((lambda x : x * cofficient), v)

def proj(v1, v2):
  return multiply(gs_cofficient(v1, v2) , v1)

def gs(X):
  #X=np.matrix([Z]).astype(float) 
  Y = []
  for i in range(len(X)):
    temp_vec = X[i]
    for inY in Y :
      proj_vec = proj(inY, X[i])
      temp_vec = map(lambda x, y : x - y, temp_vec, proj_vec)
    Y.append(temp_vec)
  w=widgets.Textarea(
               description='orthogonalisierte vektoren sind jetzt', 
               value = str(Y),
          )
  display(w) 
  return Y

wobei gs zuerst aufgerufen wird und zwar mit bspw. einer 2 mal 2 Matrix die orthogonalisiert werden soll. Wenn ich das jetzt in einer neueren Pythonversion durchführen lasse erhalte ich keine zwei Vektoren als Ergebnis sondern:


[array([2, 3]), <map object at 0x7fe4a79545f8>]

D.h. 2 , 3 stimmt noch, das ist der erste Vektor von gram-schmidt. Aber dann wird ein map object zurückgegeben, gemäß der Codezeile: temp_vec = map(lambda x, y : x - y, temp_vec, proj_vec)

Muss ich dieses Objekt eventuell casten?

[BlackJack]

@Brando: Man kann in Python keine Werte casten. In Python 2 hat `map()` eine Liste zurückgegeben, in Python 3 verhält es sich wie `itertools.imap()` in Python 2.

Edit: Lösung in diesem Fall wäre aber IMHO eine „list comprehension“ anstelle von `map()` zu verwenden, denn das wäre auch in Python 2 die naheliegendere Lösung, statt sich eine anonyme Funktion zu erstellen.

[Brando]

Würde die Lösung dann einfach sein:

Statt
temp_vec = map(lambda x, y : x - y, temp_vec, proj_vec)

verwende:

temp_vec=temp_vec-proj_vec

?

[Sirius3]

@Brando: das ist die Lösung wenn Du mit numpy-Arrays arbeitest. Da ist dann auch die multiply-Funktion absolut überflüssig.

Und die for-Schleife über den Index ist auch unschön, und die Einrückung mit 2 Leerzeichen, und und und...

@BlackJack: statt einer anonymen Funktion könnte man auch operator.sub benutzen.

[Brando]

D.h. ich kann multiply weglassen? Wie wird dann proj-vec bestimmt?

[Brando]

Als einfache Multiplikation der Parameterwerte!?

[Sirius3]

@Brando: man rechnet einfach mit Vektoren, fast so, wie es im Lehrbuch steht. Hier man mit ordentlichen Namen, korrekter Einrückung und ohne Zeugs, das nicht in die Funktion gehört:

Code: Alles auswählen

def process_gram_schmidt(vectors):
    result = []
    for next_vector in vectors:
        for vector in result:
            next_vector = next_vector - next_vector.dot(vector) / vector.dot(vector) * next_vector
        result.append(next_vector)
    return result