Wie mathematisch einer gewünschten Lösung nähern?

[Cyberstorm]

Hallo zusammen,

ich habe einen Algorithmus der mir etwas ausrechnet. Der nötige Input für den Algorithmus damit der gewünschte output herauskommt ist unbekannt.
Ich kann nur das Ergebnis bewerten.

Ich bin mir unsicher, wie ich am effektivsten die Zahl X verändere um mich möglichst schnell meinem Ziel zu nähern

Delphi-Quellcode:

function GetOffset(Input, Offset: Extended; Tolerance: Extended = 1) : Single;
var
  Error: Extended;
begin
  Error:=999;

  while Error > Tolerance do
    begin      
      Result:=Rechne(Input, X); 
      Error:=Abs(Result - Input - Offset);
    end;
end;

Danke & Grüße

[Medium]

DIe Antwort auf diese Frage hängt sehr stark vom Verhalten der Funktion über mehrere X ab. Daher wäre, wenn dieses komplett unbekannt ist, das aller erste und nötige das Durchspielen für eine große Menge an Werten. Wenn man sich das aufzeichnet, kann man oft schon grob sagen, was da letztlich für eine Funktionsklasse (im mathematischen Sinne) hinter steckt, und dort ansetzen.

[BUG]

Im Grunde sucht du die Nullstelle der Funktion f(x) = Rechne(Input, X) - Input - Offset mit Input ist konstant.
Dafür gibt es für stetige Funktionen einige Ansätze (z.B. Sekantenverfahren, für eine Variable auch: Intervallhalbierung oder Regula falsi).
Für nicht-stetige Funktionen (also mit Sprüngen) hast du eher schlechte Chancen.

Medium hat recht: Du solltest erst einmal versuchen herauszufinden, wie die Funktion aussieht.

[Cyberstorm]

Hallo,
danke für eure Antworten.
Die Funktion (Rechne) berechnet den Abstand in Metern zwischen zwei GeoKoordinaten in Dezimalgrad (ala google maps).

Und ich habe immer nur jeweils eine Variable die ich verändere (X) weil mich nur der Lat-Abstand bzw. der Long-Abstand interessieren.

Die Funktion verhält sich also ähnlich wie X:
X wird größer --> Result wird größer.
X wird kleiner --> Result wird kleiner.


Welches der Verfahren würde für diesen Fall am effektivsten funktionieren?

Danke & Grüße

[Mavarik]

Kannst Du nochmal erläutern was Du erreichen willst?

Welchen Punkt suchst Du?

Mavarik

[Cyberstorm]

Ich möchte von von einer gegebenen Geo-Koordinate die GeoKoordinate mit einem Abstand von X metern in Lat bzw. Long errechnen.

[gammatester]

Zitat:

Zitat von Cyberstorm (Beitrag 1221515)

Delphi-Quellcode:

function GetOffset(Input, Offset: Extended; Tolerance: Extended = 1) : Single;
var
  Error: Extended;
begin
  Error:=999;

  while Error > Tolerance do
    begin      
      Result:=Rechne(Input, X); 
      Error:=Abs(Result - Input - Offset);
    end;
end;

Wie soll da irgendetwas sinnvoll funktionieren? Änderungen in der Schleife können nur über den geheimnisvollen globalen :evil: Parameter X erfolgen, aber die Fehlerabschätzung kann nicht in die nächste Iteration eingehen, da Error lokal ist und nicht an Rechne übergeben wird!

Neben schlechtem Design scheint mir auch die Logik löchrig zu sein. Normalweise ändert man X innnerhalb der Schleife abhängig von Error (und eventuellen Nebenbedingungen).

[Mavarik]

Zitat:

Zitat von Cyberstorm (Beitrag 1221540)

Ich möchte von von einer gegebenen Geo-Koordinate die GeoKoordinate mit einem Abstand von X metern in Lat bzw. Long errechnen.

In welche Richtung?

[jfheins]

Ich habe dir da malwas zusammengetippt. Es ist in MATLAB geschrieben, aber die Formeln sollten sich ja übertragen lassen.
Das ganze verwendet das Newton-Verfahren, weil es a) schnell konvergiert und b) die Ableitung relativ einfach ist (konstant)
Zumindest habe ich das probiert, in der einen Richtung gewinnt man leider nur 1,6 Stellen pro iteration, da stimmt was noch nicht ganz.

Code:

%% Punkt definieren
clc
% lat (Breite), lon (Länge)
p1 = [43.45; 8.54];


% Punkt 2 abschätzen

%% 3000 km nach Westen
distanz = 3000000;
richtung = [0; -1];

erdradius = 6378137;
m = 1 ./ (erdradius * [1; cos(p1(1) * pi/180)]);% lokale Ableitung
winkel = richtung * distanz .* m;
p2 = p1 + winkel * 180/pi;

% Grenzen prüfen
if (p2(1) > 90)
    p2(1) = 180 - p2(1); % Über den Pol drüber gekommen
    p2(2) = p2(2) + 180;
elseif(p2(1) < -90)
    p2(1) = -180 - p2(1); % Über den Pol drüber gekommen
    p2(2) = p2(2) + 180;
end
p2(2) = mod(p2(2) + 180, 360) - 180;
% Ergebnis der Schätzung
fprintf('Schätzung:\n');
disp(p2);
fprintf('\nFehler: %.2f Meter\n', abs(distanz - vdist(p1, p2)));


%% Näherung mit 4 Iterationen
for i=1:4
    fehler = richtung .* (distanz - vdist(p1, p2));
    m = 1 ./ (erdradius * [1; cos(p2(1) * pi/180)]);% lokale Ableitung
    w = fehler .* m;
    p2 = p2 + w * 180/pi;
    
    fprintf('\nFehler: %.3f Meter\n', abs(distanz - vdist(p1, p2)));
end
fprintf('Schätzung:\n');
disp(p2);

Gibt bei mir z.B. folgendes aus:

Zitat:

Schätzung:
43.45
-28.582

Fehler: 20591.00 Meter

Fehler: 499.968 Meter

Fehler: 12.233 Meter

Fehler: 0.299 Meter

Fehler: 0.007 Meter
Schätzung:
43.45
-28.843

Das ist jetzt noch ein wenig fehleranfällig (bes. wenn man über den Pol kommt) aber sollte das prinzip demonstrieren. vdist() ist eine Funktion, die die Distanz zwischen den Punkten berechnet.

[LeisureSuitLarry]

Näherungsweise (die Erde ist eher eliptisch) kann man den Abstand zwischen zwei Punkten auf der Erde so berechnen:

Delphi-Quellcode:

const RErde=6366.71; //Radius Erde in km

{ Umwandlung ° in radiant } 
  Lat1:=la1*torad; // Latitude Punkt 1
  Lon1:=lo1*torad; // Longitude Punkt 1
  lat2:=la2*torad; // Latitude Punkt 1
  lon2:=lo2*torad; // Longitude Punkt 1
  Distanz:=ArcCOS(SIN(Lat1)*SIN(Lat2)+COS(Lat1)*COS(Lat2)*COS(Lon1-Lon2))*RErde;