• Wir präsentieren Dir heute ein Stellenangebot für einen Frontend-Entwickler Angular / Java in Braunschweig. Hier geht es zur Jobanzeige

C Schleife Fehler Suche

J

jack_1

Mitglied
Hallo, ich habe Daten in einer .csv die eine Autofahrt beschreiben.
Das Auto startet bei der Postion (0,0)-> (x,y). Es bewegt sich nur in 2 Dimensionen.
Die .csv-Datei enthält zwei durch Kommas (,) getrennte Werte. Die Werte beinhalten:
-Die Beschleunigung des Autos in die Richtung in den es aktuell zeigt.
-Die Rotation in der sich das Auto aktuell befindet

Dabei rotiert das Auto immer am Anfang, dann beschleunigt es 1 sekunde, bleibt stehen
rotiert erneut und beschleunigt wieder. usw...

Ich muss nun die Maximale Distanz von der Startposition berechnen und den gesamten zurückgelegten Weg berechnen.
Allerdings erhalte ich in C wenn ich das Skript ausführe leicht andere Werte als Schlussendlich rauskommen müsste.

Kann sich jemand mal meine Schleife bzw. Algorithmus ansehen? Habe ich dort irgendwo einen Fehler
wie ich die zurückgelegte Strecke berechne?



C:
    while ((token = strtok_r(save, "\n", &save)))
    {
        char* token1;
        char* save1 = token;
        double acceleration = atof(strtok_r(save1, ",", &save1));
        double rotation = atof(strtok_r(save1, ",", &save1));


        direction += rotation;
        double ax = acceleration * cos(direction);
        double ay = acceleration * sin(direction);

        double vx = v0x + ax;
        double vy = v0y + ay;

        double x = vx + (ax/2) + x0;
        double y = vy + (ay/2) + y0;


        fprintf(file, "%f,%f\n", x, y, direction);

        double distance = sqrt(x*x + y*y);
        if(distance > max_distance) max_distance = distance;
        total_distance += sqrt((x-x0)*(x-x0) + (y-y0)*(y-y0));


        if(sqrt(vx*vx + vy*vy) > max_speed) max_speed = sqrt(vx*vx + vy*vy);

        v0x = vx;
        v0y = vy;
        x0 = x;
        y0 = y;
    }
 
kneitzel

kneitzel

Top Contributor
Also ich meine, dass dies hier falsch sein müsste:
Java:
        double x = vx + (ax/2) + x0;
        double y = vy + (ay/2) + y0;

vx / vy sind schon die neuen Geschwindigkeiten. Damit hast Du als zurückgelegte Strecke die alte Geschwindigkeit + 1.5 Fache der Beschleunigung.
Ich denke eher, dass Du da eine Gleichmäßige Beschleunigung annehmen willst, und daher wird die alte Geschwindigleit (v0x bzw v0y) + 1/2 ax bzw ay genommen:
Java:
        double x = v0x + (ax/2) + x0;
        double y = v0y + (ay/2) + y0;

Aber das zeigt nur: Du hast schlicht zu viele sehr ähnlich klingende Bezeichnungen. Das ist jetzt etwas durch das Modell geschuldet, aber da würde ich optimieren.

Ich denke, dass Du v0x, v0y, x0 und y0 umbennenen kannst in die Variablen ohne 0. Die entsprechenden lokalen Variablen sollten gehen.

Und dann berechnest Du wie gehabt:
- erst die Beschleunigung in x und y Richtung aus.
- Dann den neuen Ort x/y
- Dann passt Du die Geschwindigkeit an
 
J

jack_1

Mitglied
Danke für die Tipps. Ja ich glaube das könnte der Fehler gewesen sein. Aber dennoch habe ich nun noch eine kleine Differenz im Vergleich zur Lösung. Die Differenz ist nicht groß aber dennoch ärgert es mich dass es nicht ganz korrekt ist. Naja dann muss ich wohl noch weitersuchen :)
 
J

jack_1

Mitglied
So ein paar Stunden später und ich habe die Lösung gefunden. Dieser Ausdruck war falsch:
C:
        double x = vx + (ax/2) + x0;
        double y = vy + (ay/2) + y0;
Wie du oben geschrieben hast musste ich vx durch v0x austauschen. Und ax/2 ist nicht korrekt, weiß nicht warum ich ax/2 verwendet habe. Jedenfalls passt es so mit diesen Ausdruck:

C:
        double x = v0x + ax + x0;
        double y = v0y + ay + y0;
 
kneitzel

kneitzel

Top Contributor
Da ist einfach die Frage, wie die Beschleunig genommen wird. Eine Beschleunigung ist ja nicht so, dass da von jetzt auf gleich die Geschwindigkeit anders ist.

Davon wird aber wohl ausgegangen. Und dann ist die Geschwindigkeit = Ausgangsgeschwindigkeit + Beschleuigung*Zeit

Einheiten sind ja weggelassen. Aber nehmen wir mal an Du hast die Strecke in m, Geschwindigkeit in m/s, Beschleunigung in m/s² und eine Zeiteinheit ist 1s.

Wenn die Beschleunigung gleichmäßig über 1 Sekunde erfolgt, dann wäre die Geschwindigkeitszuwachs nach 1s: Beschleunigung in m/s2 * 1s.

Mathematisch sind das Ableitungen. Und man könnte die Strecke jetzt mit Integration ermitteln.
Aber wir können es uns einfach herleiten, so die Beschleunigung gleichmäßig ist. Denn dann haben wir eine Gerade. Und damit ist die Fläche unter der Geraden einfach auszurechnen, denn das ist ein Rechteck (Startgeschwindigkeit * Zeit) und dann ein Rechtwinkliges Dreieck. Damit ist die Fläche Gewonnene Geschwindigkeit * zeit / 2.
Zeit war 1s, damit haben wir also Startgeschwindigkeit + 1/2 Beschleunigung. (Argh, das tut im Herzen weh, das so zu schreiben. 5 Äpfel und 3 Birnen addiert gibt wie viele Zitronen? Also startgeschwindigkeit * 1s + 1/2 Beschleunigung * 1s² haben wir natürlich ...)

==> Damit ist das 1/2 das genau.

Nun das hast Du nur dann nicht, wenn die Beschleunigung sofort ist. Also Du beschleunigst mit unendlicher Beschleunigung für einen Zeitraum, der gegen 0 geht, so dass Du einen Geschwindigkeitszuwachs von ax bzw ay hast. In einem Graph hättest Du dann Stufen. Zu einem Zeitpunkt t hast Du dann keine klare Geschwindigkeit sondern Du hast je nachdem ob Du von rechts oder links kommst einen unterschiedlichen Grenzwert.
Aber wenn man sich das graphisch anschaut, dann hast Du als Fläche ein Rechteck - aus (v0 + vdelta) * Zeit.

Also einfach eine Vereinfachung, die aber nicht wirklich etwas vereinfacht da auch mit gleichmäßiger Beschleunigung einfach zu rechnen ist
 
J

jack_1

Mitglied
Danke für die Infos, nun ist es für mich klar. Ja es ist schon so gedacht dass die Beschleunigung sofort auftritt
 

Ähnliche Java Themen

Anzeige

Neue Themen


Oben