Eine Vektor-Klasse (nicht nur) für die Knotenschachtel, Teil 2

Einer meiner Gründe für die Programmierung einer Klasse PVector für die NodeBox war, daß ich über eine schon etwas ältere, fünfteilige Coding Challenge von Daniel Shiffman gestolpert war, in der er (in P5.js, dem JavaScript-Mode von Processing) evolutionäres Lenk- und Steuerungsverhalten von Vehikeln programmierte. Der Begriff »Vehikel« stammt von Valentin Braitenberg (1926-2011), dem ehemaligen Direktor des Max-Planck-Instituts für biologische Kybernetik in Tübingen. Er zeigte damals, daß verblüffend einfache Mechanismen ein überraschend komplexes Verhalten bewirken können. Es gibt darüber ein wunderbares, kleines Büchlein von ihm – Vehikel, Experimente mit kybernetischen Wesen –, das ich Euch allen nur empfehlen kann.

Shiffmans Experimente orientieren sich aber eher an Craig Reynolds bekannter Computersimulation Boids und an die (in StarLogo geschriebenen) und in seinem wunderbaren Buch Turtles, Termites, and Traffic Jams veröffentlichten Ameisensimulationen von Mitchel Resnick. Wie dem auch sei – es geht ihm (Shiffman) in erster Linie um autonome (Software-) Agenten und ihre evolutionäre Weiterentwicklung. Und genau das wollte ich nachprogrammieren. Und nicht in Processing.py, dem Python-Mode von Processing, denn da wäre die Klasse PVector ja schon implementiert, sondern in der NodeBox. Denn für mich sieht die Knotenschachtel nach einer hervorragenden Umgebung für interaktive Simulationen aus und genau das möchte ich einmal ausprobieren.

Das war aber dann doch nicht so einfach, wie ich ursprünglich dachte, denn Shiffman setzte in seiner Coding-Challenge schon auf weitere Videos auf, die er (dieses Mal im Java-Mode von Processing) schon früher veröffentlicht hatte und die im Wesentlichen das sechste Kapitel seines Buches The Nature of Code behandelt (auch dieses Buch kann ich Euch nur wärmstens empfehlen). Ich mußte also nicht nur die Klasse PVector nachprogrammieren, sondern mich auch noch durch eine Menge von Videos wühlen.

Da die Navigation bei YouTube nicht immer einfach ist, hier erst einmal die Links zu allen nötigen Videos:

• Playlist: Autonomous Agents and Steering - The Nature of Code (insgesamt 10 Videos)
• Coding-Challenge #69: Evolutionary Steering Behaviors, Part 1, Part 2, Part 3, Part 4 und als (Bonus-) Nachschlag Part 5

Ich denke, daß ich mit der am Sonnabend veröffentlichten Klasse PVector alle diese Simulationen auch in der Knotenschachtel nachropgrammieren kann, der Vollständigkeit halber habe ich ihr aber noch ein paar Methoden gegönnt. Da sind erst einmal die Getter und Setter:

    def set(self, v):
        self.x = v.x
        self.y = v.y
    
    def get(self):
        v = PVector(self.x, self.y)
        return v

Dann noch die elementweise Multiplikation und Division mit einem zweiten Vektor und die Berechnung des Skalarproduktes:

    # Elementweise Multiplikation eines Vektor mit einem anderen Vektor
    def mult2(self, v):
        self.x *= v.x
        self.y *= v.y

    # Elementweise Division eines Vektor mit einem anderen Vektor
    def div2(self, v):
        self.x /= v.x
        self.y /= v.y

    # Berechnung des Skalarprodukts (inneren Produkts) eines Vektors
    def dot(self, v):
        return self.x*v.x + self.y*v.y

Und last but not least noch den euklidischen Abstand zweier Vektoren, die Begrenzung der Magnitude eines Vektors (das hatte ich im ersten Beitrag noch per Fuß erledigt) und die Berechnung des Winkels der Rotation eines Vektors:

    # Berechnung der euklidischen Distanz zwischen zwei Vektoren
    def dist(self, v):
        dx = self.x - v.x
        dy = self.y - v.y
        return (math.sqrt(dx*dx + dy+dy))
    
    # Begrenzt die Magnitude eines Vektors auf max
    def limit(self, max):
        if self.mag() > max:
            self.normalize()
            self.mult(max)
    
    # Berechnet den Winkel der Rotation eines Vektors
    def heading(self):
        angle = math.atan2(-self.y, self.x)
        return -1*angle

Alle diese Methoden habe ich mit einem alten Buch zur Linearen Algebra auf den Knien hingeschrieben. Sie sind entweder gar nicht oder noch nicht ausreichend getestet – nutzt sie daher mit Vorsicht. Insbesondere bei div2() seid Ihr als Programmierer dafür verantwortlich, daß der zweite Vektor nirgendwo Null ist (denn Ihr wißt, die Division durch Null ist verboten). Ich werde mir allerdings bei Gelegenheit noch ein paar Tests ausdenken und komme dann noch einmal darauf zurück.

Darüber hinaus ist mir eingefallen, daß diese Klasse PVector ja nicht nur für die NodeBox nützlich sein kann. Sie ist pures Python und kann daher überall dort eingesetzt werden, wo Vektoren benötigt werden. Ich denke hier vor allem an das turtle-Modul. Das besitzt zwar selber eine rudimentäre Vektor-Implementierung, die aber nur vier Methoden kennt. Vielleicht fahre ich bei den geplanten Simulationen zweigleisig: Einmal mit der Tropfenschachtel und dann reite ich auch noch die Schildkröte für alle die, die keinen Mac ihr eigen nennen. Reizen täte mich das schon. Still digging!

(Kommentieren)