Das, was ich eben gezeigt habe, wäre ein Beispiel für eine Tabelle, in der ich Daten habe. Wie kann ich diese Daten irgendwie auswerten? Man kann in solchen Arrays aber auch zum Beispiel Kennlinien speichern. Stellen Sie sich vor, Sie hätten für irgendeine Regelungstechnik mit aufwendigsten Simulationen am Supercomputer ausgerechnet,

dass das die perfekte Kennlinie wäre, die diese Regelungstechnik fahren muss. Wenn irgendwie eine bestimmte Temperatur gemessen wird, dann stellen Sie die Umdrehungszahl auf so und so viel.

Angenommen, das wäre eine Kennlinie, von der Sie wissen, dass das das Optimum ist und die jetzt verwendet werden soll, um von einem Sensor, das wäre X, um von einem Sensor zu irgendeinem Aktuator umzurechnen. Und genau so soll der Motor gesteuert werden und nicht anders, wenn das hier die Temperatur ist oder die Spannung oder die Luftfeuchtigkeit.

Auch sowas kann ich dann natürlich in ein Array ablegen und dann versuchen auszuwerten. Mal gucken, ich hoffe, das klappt. Wir sehen, wie das jetzt funktionieren müsste. Ich lege in das Array Punkte rein, sowas können wir bisher noch nicht, deshalb müssen wir uns ein bisschen durchlügen.

Ich lege Punkte in das Array jeweils mit XY-Werten. Und der Gedanke ist folgender, ich brauche eine Funktion, der gebe ich irgendeinen X-Wert. Und diese Funktion liefert einen sinnvollen Y-Wert, einen interpolierten Y-Wert.

Durchlegen Sie jetzt hier nicht jeden möglichen X-Wert in das Array. Das wäre ja wieder ein bisschen massiv, sondern ich lege nur so ein paar Stützstellen in das Array rein. Und dazwischen soll linear interpoliert werden.

So speichert man üblicherweise solche Kennlinien ab. Natürlich könnte man auch komplizierter interpolieren, dass ihr einen schönen Bogen macht, aber warum so kompliziert? Wenn das nicht genau genug ist hier mit dieser linearen Interpolation, dann setzt man eben noch ein paar Stützstellen mehr rein und dann haut das wieder hin.

Mal gucken, ob wir das gebaut kriegen. Also was ich nun habe, ist eigentlich was? Frage an Sie. Was habe ich nun eigentlich? Wie speichere ich mir mit den bisherigen Mitteln so einen Satz an Punkten?

Also ein zweidimensionales Array ist der Vorschlag. Ich speichere mir in einer Spalte das X und in einer Spalte das Y, dass da sowas steht. X ist gleich von mir aus 1 und dann soll Y 3 sein.

X ist gleich 2 und dann soll Y 5 sein. X ist gleich 7 und dann soll Y gleich 13 sein und so weiter. Das abspeichern, das ist ein zweidimensionales Array, ein zweidimensionales Feld. Wenn Sie das hier so aufmalen, sehen Sie das? Das ist nicht mehr einfach nur eine Liste.

Das sind nicht so viele Zahlen in eine Reihe geschrieben, sondern das sind zwei Spalten und vielleicht ziemlich viele Zeilen. Ein zweidimensionales Array. Mal gucken, 1, 3, 2, 5, 7, 13. Nehmen wir tatsächlich mal double, was auf dem kleinen Chip nicht funktionieren würde, vernünftig.

Deshalb habe ich einen großen Chip eingestellt für den Simulator. Dann nennen wir das mal B. So, und das soll jetzt zweidimensional sein. Initialisierung.

Und an der Stelle würde man tatsächlich die Initialisierung ins Programm reinschreiben, gerne mal. Wenn dieses eine vorgegebene Kennlinie ist, dann kann ich sie auch fest einprogrammieren. Geschickt wäre vielleicht, die aus einer Datei einzulesen oder ähnliches. Man könnte sie dann auch fest einprogrammieren. Nun möchte ich haben 1, 3, 2, 5, 7, 13. Das sähe dann so aus.

Wir können ja jetzt ja nicht schreiben 1, 3, 2, 5, 7, 13. Warum wäre das krumm? Ich brauche hier Zeilen und Spalten. Das ist alles ein bisschen klammerig.

So könnte man das dann hinschreiben. In der ersten Zeile steht 1, 3. Jetzt kommt die nächste Zeile. 2, 5 in der nächsten Zeile. Und die dritte Zeile ist 7, 13. Das wäre die Abbildung von diesem Array hier.

1, 3, 2, 5, 7, 13 in C. Erste Zeile, zweite Zeile, dritte Zeile. Vielleicht sieht das netter aus, wenn Sie es untereinander schreiben. Dann kann man es vielleicht besser erkennen. Ich stelle mir das mit 3 Dimensionen vor. Es wird fürchterlich, wenn man das so ausbuchstabiert.

Okay. Zeile, Zeile, Zeile. Und jetzt ist C noch ganz uselig. Es will von der hinteren Dimension die Größe haben. Es sind immer zwei nebeneinander. So. Make. Gucken wir uns das an.

Wenn ich bis da unten durchklicke und einen Schritt weiter gehe. Da ist B. So. B hat diese drei Zeilen.

Erste Zeile, zweite Zeile, dritte Zeile. So sieht das aus. Das wäre jetzt mein Array.

Und nun möchte ich damit solche Spielereien veranstalten. Ich möchte sagen, dass ich eine Funktion habe, der ich ein X gebe. Und die soll jetzt die lineare Interpolation ausführen.

Ich mache das noch mal ein bisschen anders hier. Der gebe ich das X. Und die Funktion soll die lineare Interpolation hier ausführen. Also hier eine Funktion. Die liefert den hübschen Wert zurück.

Linea schreibe ich jetzt einfach hier vor, weil ich faul bin. Linea Interpolation, wir sind ja nicht so...

Linea Interpolation, der muss sich jetzt was geben. Die sollte zum Schluss was zurückliefern. Und die möchte ich hier dann aufrufen. Was haben wir hier? Y ist gleich.

Linea Interpolation. Von irgendwas. Selber Trick wie vorhin. Ich könnte dieser Funktion jetzt einfach dieses Array mitgeben.

Ich könnte dieses Array auch da oben einbauen in die Funktion. Das wäre vielleicht sogar raffinierter. Aber wo wir jetzt das so angefangen haben, fangen wir das mal an. Also ich möchte der Funktion dieses Array mitgeben. Und Sie ahnen das, was ich wieder sagen muss. Das sind drei Zeilen.

Dieses Array hier sollte immer diese zwei Spalten haben. Das wäre es blödsinnig. Ein Spalte X, ein Spalte Y. Insofern ist das klar. Aber ich sollte noch sagen, dass sie drei Zeilen hat. Und so geht das dann hier auch. Hier warte ich jetzt also einen Zeiger.

Den darf ich wieder X nennen. Hier oben hieß der auch schon X. Aber das X bleibt hier in den Schweifklammern verborgen. Hier nenne ich den auch mal wieder X. Ein Zeiger auf ein 2D Array, das hinten zwei Spalten hat. Das sieht in C wirklich haarsträubend aus. Aber lässt sich nicht anders machen.

Und davon muss ich jetzt sagen, wie viele Zeilen es sind in Length. So haben wir das bisher.

Dann gucken wir einmal an, was bisher passiert. Wenn es funktioniert. Ja, sehr schön. Eine übliche Lösung wäre jetzt hier 42 reinzuschreiben.

In C++ und in anderen neuen Sprachen könnte man hier einfach noch klar machen, mit einer Exception, dass das nicht erlaubt ist. In C haben sie nicht so allzu viele Möglichkeiten. Ich schreibe hier jetzt mal 42 rein, dass es kompilieren kann. Hier ist B und jetzt kommt der Funktionsaufruf.

Für X kriege ich jetzt ein Array. Was er mir anzeigt, ist die allererste Zeile. Der Debugger weiß nicht, wie viele Zeilen es sind.

Der ist ein bisschen dumm. Der Debugger weiß nicht, wie viele Zeilen es sind. Er sieht aber, es muss dann mindestens die eine sein. Und gibt mir das allererste hier aus. Na ja, sei es so. Und als Länge habe ich drei. Hier oben ist jetzt die Arbeit zu machen. Ich habe das Array mit meinen Datenpunkten.

Ich habe die Länge von diesem Array, wie viele Zeilen es sind. Eine Sache fehlt mir noch, fehlt mir dabei auf. Wenn Sie sich das hier unten angucken. Was fehlt mir noch? Das ist so offensichtlich, dass ich es gerade auch vergessen habe. Ich sollte sagen, ja, welcher X-Wert denn? Nehmen wir mal, was weiß ich, 3,14.

Welcher X-Wert denn? Aus welchem X-Wert soll denn das Y berechnet werden? Dieses X hier fehlt mir. Schau ich mal dran. Sagen wir hier, 3,14. Woraus soll denn das Y berechnet werden? Und was ist die Datentabelle mit der Kennlinie?

Und wie viele Zeilen hat diese Datentabelle? Das heißt, hier oben brauche ich auch noch einen Double-Wert. Ups, zu weit, zu weit, zu weit, zu weit. Hier brauche ich auch noch einen Double-Wert. Und Sie sehen, ich sollte den X nennen. Und ich sollte diese Tabelle doch nicht X nennen, sondern vielleicht T wie Tabelle.

So, jetzt haben wir alle Zutaten endgültig. Wie gehe ich jetzt vor? Ich weiß den X-Wert. Ich weiß diese Datenpunkte.

Also um den Punkt davor und dann danach zu finden, gehe ich einfach meine X-Werte durch. Ich nehme an, dass die schön sortiert sind natürlich von klein nach groß. Sonst wird es ganz fürchterlich. Also stillschweigende Annahmen. Die X-Werte sind von klein nach groß sortiert. Dann gehen Sie diese X-Werte durch. Die 1 ist kleiner als die 3,14. Die 2 ist kleiner als die 3,14.

Aber die 7 ist größer. Ah, also muss die 2 davor gelegen haben und die 7 dahinter gelegen haben. So mache ich das. Ich gehe durch meine X-Werte durch und gucke nach dem ersten, der größer ist. So muss das hier stehen. Die Xe durchgehen.

Schreit nach einer Vorschleife. Das frage ich Sie gleich mal gerade.

Wo höre ich mit der Vorschleife auf? Also Vorsicht dieses. Dieses int ist jetzt ja nicht 2, noch was oder 3, noch was. Das macht der Index, der wievelte Punkt. Nach dem wievelten Punkt höre ich auf. Netterweise habe ich das hier hinten übergeben. So, gleich nochmal gucken, ob das auch wirklich an dem Kanten genau hinkommt. Aber das wäre mein erster Gedanke.

Ich gucke, wie viele Zeilen stehen drin. Und die gehe ich eben durch. Und nun gucke ich nach der Zeile, in der ein X steht, das größer ist als das X, was ich übergeben habe. Das heißt, ich muss mir merken, wo der nächste ist.

Irgendetwas auf minus eins zu setzen, was üblicherweise positiv oder null ist, ist auch noch ein Trick, um sich zu merken, dass der noch nicht gesetzt ist. Dann möchte ich mir merken, wo denn der nächste drin steht. Wenn das X kleiner ist als der X-Wert in der Tabelle, dann soll Folgendes passieren.

Lass uns mal gerade schwer nachdenken. Hier möchte ich mit dem X-Wert in der Tabelle vergleichen. In der Iten-Zeile möchte ich den X-Wert haben.

Schauen wir uns das hier in dem Dingens an. Ich möchte in die Iten-Zeile und dann den X-Wert. Also sie gehen zur Koordinate 0, 1, 2. 0, 1, 2.

Zur Koordinate 2 hier. Und hier bleiben sie bei der 0. Das ist die 0 und das ist die 1. 2, 0. Da finde ich den X-Wert. Oder für das allgemeine i, i, 0. Da finde ich meinen X-Wert. Ich schaue, ob der X-Wert, der übergeben ist, kleiner ist als der, der da steht.

Dann weiß ich, ich bin jetzt weit genug. Dieses i, das ist die Nummer von dem Nächstgrößeren. So sieht das aus. Wenn ich den Nächstgrößeren gefunden habe, kann ich was mit der Schleife tun.

Ich gehe meine Punkte durch, aufsteige in der X-Reihenfolge. Und habe nun den gefunden, dessen X-Wert größer ist als der übergebene X-Wert. Was können Sie nun mit der Schleife tun?

Die Weitere hier muss ich ja nicht angucken. Es ging mir nur darum, hier den Nächsten zu finden. Das heißt, hier kann ich die Schleife ganz einfach mit einem Break abwürgen. Ich bin ja fertig, was soll ich die anderen noch angucken? Es würde dann auch falsch werden vor allen Dingen. Diese Bedingung ist für die Nächsten ja auch wahr. Die Nächsten sind ja auch größer als X. Und ich würde die ganzen Nächsten da reinschreiben. Das wäre ungeschickt.

Ich weiß, der Nächste ist nun richtig gesetzt. Was sollte man noch denn davor? Previous nenne ich den mal Pref. Das ist der also davor. Next minus 1. Jetzt weiß ich die Nummern von dem Punkt davor. Und die Nummer von dem Punkt dahinter.

Nicht ganz. Was jetzt ein bisschen usselig noch ist, ist, wenn ich Gleichheit habe. Das muss man vielleicht mal gerade gucken, ob man das geregelt kriegt. Wenn ich Gleichheit habe, wo kann es ärgerlich werden? Was passiert, wenn X hier auf dem allerersten Punkt sitzt?

Welchen möchten Sie eigentlich rauskriegen? Den ersten oder den? Schwierig, schwierig. Was passiert, wenn X auf diesem letzten Punkt sitzt? Das müsste man sich noch genau überlegen. Angesichts der Zeit schreibe ich hier nur mal dran. To do. Sehr unsauber.

To do, was passiert mit den Randpunkten. Das mache ich das nächste Mal nochmal vor. Das ist jetzt keine Sache, die die Race angeht, sondern die allgemeine Programmlogik angeht. Solange wir in der Mitte sitzen mit unserem Punkt, ist die Welt in Ordnung. Und das wird funktionieren. Am Rand kann es böse Überraschungen geben.

So, jetzt habe ich die beiden Punkte am Rand. Jetzt mache ich einfach Gradengleichung. Ich brauche eine Gerade, die durch diese beiden Punkte durchgeht. Und da nehme ich dann den passenden X-Wert raus.

Das kann man jetzt netterweise einfach mit den üblichen Funktionen hinschreiben. Da kommt jetzt einfach die Gradengleichung hier. Und ich gebe zum Schluss das Y zurück. Wenn ich ganz professionell bin, oder ich soll vielleicht eher sagen, wenn ich ganz faul bin,

schreibe ich das hier in eine Zeile. Ich schreibe nur noch return und da steht die Gradengleichung in der Form. Ich brauche da gar nicht eine extra Variable reinzuschreiben. Hier kommt einfach die Formel für die Gerade. Ich weiß jetzt, der wievielte Punkt davor ist.

Eins weniger. Und ich schreibe jetzt hier einfach die Gradengleichung hin. Das muss ja sein. Steigung mal irgendwas mit dem X-Wert, den ich da habe. Steigung mal X plus Achsenabschnitt.

Wir können jetzt versuchen, den Achsenabschnitt auszurechnen und die Steigung auszurechnen. Das ist natürlich ein bisschen aufwändig. Es gibt einen Trick. Wenn Sie von diesem X das X davor abziehen und hier das Y davor addieren,

haben Sie dasselbe und Sie müssen sich nicht den Achsenabschnitt ausdenken. Wenn hier das X gleich dem X, dem vorherigen Wert ist, wenn Sie mit dem X auf diesem Wert sind, soll genau Y für diesen vorherigen Wert rauskommen.

Wenn X genau auf dem steht, steht vorne Steigung mal Null, kommt genau das Y raus. Wenn ich dann mit meinem X weiter gehe, geht das mit der Steigung. Das ist die Gradengleichung, ohne dass ich jetzt den Achsenabschnitt ausgerechnet habe. Nur, ich habe ein bisschen geflunkert hier.

Ich kenne die Steigung nicht, ich kenne das vorherige X nicht und ich kenne das Y nicht, was zu dem gehört. Wie kriegen Sie hier das vorherige X? Da oben hatten wir das schon mal. Da war es die ite Zeile. Hier brauche ich die Zeile mit der Nummer X previus

und die Spalte mit der Nummer Null. So muss das aussehen. Ich muss das natürlich gleich nochmal in Aktion zeigen. Und dieses Y previus ist auch, das heißt natürlich nicht so, einfach nur die Nummer.

Dieses Y, was machen Sie um das Y da hinten zu kriegen? Sie gehen in die andere Spalte, da hinten die 1, zweite Spalte. Nullte Spalte, das hier war die Nullte Spalte und hier gehe ich in die erste, wenn man das so zählt, ab Null.

Hier gehe ich in die erste Spalte. Haben wir den und jetzt brauche ich noch die Steigung. Da muss irgendwas stehen durch irgendwas. Einfach die Y-Werte durch die X-Werte in der Differenz. Die Differenz der Y-Werte, das wäre der nächste

minus der vorherige. Das wäre die Differenz der Y-Werte. Ich hoffe, dass das mit etwas Mühe zu erkennen ist, dass das mal die Y-Werte sind und die teile ich durch die Differenz der X-Werte, also aus der Spalte mit der Nummer Null.

Das wäre meine Steigung hier vorne. Ich gucke mir diese beiden an. Was ist deren Y-Differenz durch was ist deren X-Differenz? Dann habe ich die Steigung. Das ist der hier. Mal das, was ich eben schon diskutiert hatte.

Mit viel Glück funktioniert das. Probieren wir vielleicht mal mehrere aus. Fangen wir vielleicht mal an, tatsächlich mit 3, nein, mit 2, um zu sehen, ob dann auch etwas Vernünftiges rauskommt. Und dann gucken wir vielleicht mal 3,14. Und zwischendurch auch noch 2,14.

Oder hier vielleicht dann auf der Mitte lieber. Zwischen 2 und 7. 2 plus 7 ist 9. 4,5. Das lässt sich auch noch halbwegs machen. Mal gerade gucken, ob das sinnvoll ist. Was haben wir hier noch? Oh, ganz übel.

Komma an der Stelle. Kein Simikolon. So, ich sage, was ist denn der beste Wert für die 2? Dann sollte jetzt mit der 5 wieder zurückkommen.

Die 2 ist einer der Datenpunkte. Okay, er kommt mit der 5 zurück. Ich gehe ein bisschen weg aus der 2. Hier auf der X-Achse ein bisschen raus aus der 2. Und er kommt mit etwas mehr als 5. Das ist nicht ganz unplausibel,

weil bei der 2 die 5 rauskam. 4,5 jetzt ist auf der halben Strecke zwischen der 2 und der 7. Das Ergebnis sollte auf der halben Strecke zwischen der 5 und der 13 liegen. 9,0. So sieht das dann aus. Aber wie gesagt, das Ding ist noch nicht fertig. Die eklige Arbeit ist, sich zu überlegen, was am Rand passiert.

Was mache ich denn, wenn dieser X-Wert kommt oder dieser? Noch viel schlimmer, was passiert, wenn dieser X-Wert kommt oder dieser? Dann müsste man vielleicht dafür sorgen, dass das hier auf diesem Niveau abgeschnitten wird. Kostet noch mal ein paar Ifs. Mir ging es heute erstmal jetzt hier um die Rays. Und weniger um diese saubere Nachbildung der Funktion.