Lineare Interpolation
0 1 0 0 0 0 
dedlfix
0
0 0 0 0
Lineare Interpolation
Tabellenkalk
Der Martin
Camping_RIDERHallo Forum,
ich habe eine Reihe von Daten, die alle 15 Minuten erfasst werden:
Datum = 2015.01.01 06:00:00, Wert = 1224,167
Datum = 2015.01.01 06:15:00, Wert = 1344,207
Datum = 2015.01.01 06:30:00, Wert = 1524,367
Datum = 2015.01.01 06:45:00, Wert = 1555,707
...
Datum = 2015.01.02 06:15:00, Wert = 1024,57
Datum = 2015.01.02 06:30:00, Wert = 1924,50
...
Meine Aufgabe ist, alle zwischenwerte, z.B. für 2015.01.01 06:00:00 und 2015.01.01 06:15:00, zu ermitteln (Interpolation), damit ich eine glatte Linie ziehen kann. Momentan habe ich nur eizelene Punkte.
Hat jemand mit der linearen Interpolation Erfahrung und weiß, wie das geht. Ein Beispiel wäre schön.
Danke im Voraus.
-
Hallo Forum,
ich habe eine Reihe von Daten, die alle 15 Minuten erfasst werden:
Datum = 2015.01.01 06:00:00, Wert = 1224,167 Datum = 2015.01.01 06:15:00, Wert = 1344,207 Datum = 2015.01.01 06:30:00, Wert = 1524,367 Datum = 2015.01.01 06:45:00, Wert = 1555,707 ... Datum = 2015.01.02 06:15:00, Wert = 1024,57 Datum = 2015.01.02 06:30:00, Wert = 1924,50 ...Meine Aufgabe ist, alle zwischenwerte, z.B. für 2015.01.01 06:00:00 und 2015.01.01 06:15:00, zu ermitteln (Interpolation), damit ich eine glatte Linie ziehen kann. Momentan habe ich nur eizelene Punkte.
Hat jemand mit der linearen Interpolation Erfahrung und weiß, wie das geht. Ein Beispiel wäre schön.
Danke im Voraus
Mit welcher programmiersprache willst du das machen?
Ich empfehle dir das problem mit spielines zu loesen und hierfuer zb das statistik tool r zu benutzen das passende funktionen bereitstellt. Das problem bei linearer int. Ist dass deine daten meistens keine regulaere datenmatrix ergeben und die poly int damit nicht funktioniert. Eventuell reicht dir auch die interpolation mittels lagrangschen basisplynomen
Schau mal hier unter skript bei inrerpolation, beispiele sind dabei: http://www3.math.tu-berlin.de/Vorlesungen/WS13/NumMath1/
-
Hi,
danke. Das Ganze soll in C# realisiert werden. Die Daten, die alle 15 Minuten erfasst sind, sollen nach der Interpolation minutenweise vorhanden sein, also z.B.:
Datum = 2015.01.01 06:00:00, Wert = 1224,167 Datum = 2015.01.01 06:01:00, Wert = Datum = 2015.01.01 06:02:00, Wert = Datum = 2015.01.01 06:03:00, Wert = Datum = 2015.01.01 06:04:00, Wert = Datum = 2015.01.01 06:05:00, Wert = Datum = 2015.01.01 06:06:00, Wert = Datum = 2015.01.01 06:07:00, Wert = Datum = 2015.01.01 06:08:00, Wert = Datum = 2015.01.01 06:09:00, Wert = Datum = 2015.01.01 06:10:00, Wert = Datum = 2015.01.01 06:11:00, Wert = Datum = 2015.01.01 06:12:00, Wert = Datum = 2015.01.01 06:13:00, Wert = Datum = 2015.01.01 06:14:00, Wert = Datum = 2015.01.01 06:15:00, Wert = 1344,207 Datum = 2015.01.01 06:16:00, Wert = Datum = 2015.01.01 06:17:00, Wert = ... Datum = 2015.01.02 06:30:00, Wert = 1924,50Gruß
-
Hallo,
danke. Das Ganze soll in C# realisiert werden. Die Daten, die alle 15 Minuten erfasst sind, sollen nach der Interpolation minutenweise vorhanden sein, also z.B.:
Du willst also Information erfinden.
Datum = 2015.01.01 06:00:00, Wert = 1224,167 Datum = 2015.01.01 06:01:00, Wert = Datum = 2015.01.01 06:02:00, Wert = Datum = 2015.01.01 06:03:00, Wert = Datum = 2015.01.01 06:04:00, Wert = Datum = 2015.01.01 06:05:00, Wert = Datum = 2015.01.01 06:06:00, Wert = Datum = 2015.01.01 06:07:00, Wert = Datum = 2015.01.01 06:08:00, Wert = Datum = 2015.01.01 06:09:00, Wert = Datum = 2015.01.01 06:10:00, Wert = Datum = 2015.01.01 06:11:00, Wert = Datum = 2015.01.01 06:12:00, Wert = Datum = 2015.01.01 06:13:00, Wert = Datum = 2015.01.01 06:14:00, Wert = Datum = 2015.01.01 06:15:00, Wert = 1344,207 Datum = 2015.01.01 06:16:00, Wert = Datum = 2015.01.01 06:17:00, Wert = ... Datum = 2015.01.02 06:30:00, Wert = 1924,50Wenn du es wirklich linear haben möchtest, nimmst du die Differenz zweier benachbarter Werte, teilst die durch 15 und addierst das jeweils pro Minute auf. Dann hast du aber immer bei jedem echten Wert einen Knick drin.
Gruß
Kalk
-
-
-
Moin!
Meine Aufgabe ist, alle zwischenwerte, z.B. für 2015.01.01 06:00:00 und 2015.01.01 06:15:00, zu ermitteln (Interpolation), damit ich eine glatte Linie ziehen kann. Momentan habe ich nur eizelene Punkte.
Es gibt zwei Möglichkeiten:
Interpolieren zwischen den Punkten mit gemessenen Werten, aber Du schreibst: "damit ich eine glatte Linie ziehen kann"
Tja. Wenn Du eine glatte Linie ziehen willst, dann mach folgendes:
- Teile die Datentupel am Median in zwei Hälften mit gleicher Menge. (Bei ungerader Anzahl füge den mittleren Datenpunkt (Median) beiden hinzu).
- Ermittle den Durchschnitt von x (Zeitpunkt) und y (Messwert) für jeder Hälften.
- Ziehe die Linie durch diese gedachten Punkte. ("Dreisatz")
Das Verfahren ist nur für Sachverhalte schlüssig, die einen linearen Verlauf bei zufälligen Abweichungen erwarten lassen.
Jörg Reinholz
(der seine Statistikprüfung in BASIC einem auf Sharp-Pocket-Computer programmiert und gewonnen hat).
-
Hallo,
danke, mein Fehler. Es soll eine Linier gezogen werden. Die Interpolatiosformel sieht ja so aus: y = y1 + ((y2 - y1)*(x - x1) / (x2 - x1)). Demnach habe ich folgendes für eine Zeitspanne implementiert. Die Werte ich bekomme sind aber nicht ganz plausibel.
double y1 = 1234.887; double y2 = 2453.778; DateTime x1 = Convert.ToDateTime("2015-01-01 00:15:00.000"); DateTime x2 = Convert.ToDateTime("2015-01-01 00:30:00.000"); DateTime x = Convert.ToDateTime("2015-01-01 00:16:00.000"); for (int i = 1; i < 15; i++) { double zaehler = (y2 - y1) * (x - x1).TotalSeconds; double nenner = (x2 - x1).TotalSeconds; double result = (zaehler / nenner) + y1; y1 = result; x1 = x.AddMinutes(1); }Sieht ihr da irgendwelche Fehler.
Gruß
-
Moin!
double zaehler = (y2 - y1) * (x - x1).TotalSeconds; double nenner = (x2 - x1).TotalSeconds;Sieht ihr da irgendwelche Fehler.
So, ganz ohne mich mit C# auszukennen:
Müsste das nicht:
double zaehler = (y2 - y1) * (x.TotalSeconds - x1.TotalSeconds); double nenner = (x2.TotalSeconds - x1.TotalSeconds);heissen? Oder kann C# damit umgehen, dass aus den DateTime-Objekten eine Differenz gebildet wird? Das erscheint mir jedenfalls ungewöhnlich.
Und dann:
double result = (zaehler / nenner) + y1; y1 = result; x1 = x.AddMinutes(1);Ist nicht x,y das zu berechnende Wertepaar für Interpolation? Du veränderst aber y1, x1 - das waren wohl (ich spekuliere also!) Deine Messwerte, die Du natürlich NICHT verändern darfst.
Jörg Reinholz
-
Hi,
nein, das hat seine Richtigkeit. Die Daten-Differenz wird zunächst ermittelt und das Ergbenis wird das als Sekunden zurückgegeben.
Gruß
-
Moin!
Hi,
nein, das hat seine Richtigkeit. Die Daten-Differenz wird zunächst ermittelt und das Ergbenis wird das als Sekunden zurückgegeben.
Gut. Dann Prüfe noch ab, ob es richtig ist, y1 auf y zu setzen...
Die Formel wäre übrigens
x0 = Messpunkt 0 (erster Zeitpunkt) x1 = Messpunkt 1 (zweiter Zeitpunkt) y0 = Messwert am Messpunkt 0 y1 = Messwert am Messpunkt 1 x = gesetzter Zeitpunkt y = gesuchter interpolierter Wert y = y0 * (x1-x) / (x1-x0) + y1 * (x-x0) / (x1-x0)mit:
x0=2; x1=4; y0=8; y1=16;ergibt sich
für X=2: y = 8 * (4-2) / (4-2) + 16 * (2-2) / (4-2) = 8*2/2 + 16*0/2 = 8+0 = 8für x=2.5: y = 8 * (4-2.5) / (4-2) + 16 * (2.5-2) / (4-2) = 8*1.5/2 + 16*0.5/2 = 10für X=3: y = 8 * (4-3) / (4-2) + 16 * (3-2) / (4-2) = 8*1/2 + 16*1/2 = 4+8 = 12für x=3.5: y = 8 * (4-3.5) / (4-2) + 16 * (3.5-2) / (4-2) = 8*0.5/2 + 16*1.5/2 = 14für x=4 y = 8 * (4-4) / (4-2) + 16 * (4-2) / (4-2) = 8*0 + 16*2/2 = 0+16 = 16... was doch recht brauchbar aussieht.
(War das in der 8. oder 9. Klasse dran?)
Jörg Reinholz
-
Hi,
danke für deine Bemühung. Die Formel "y = y0 * (x1-x) / (x1-x0) + y1 * (x-x0) / (x1-x0)" is ide Aufgelöste Form von der, was ich als zaehle und nenner in meinem Programm habe. Beide geben dieselbe Ergebenisse zurück.
Das problem liegt anscheint im Datum und dessen Umwandlung in Sekunden. Je ich mich dem zweiten Wert (x2) annähere, desto verdichten sich die berechneten Werte:
double y0 = 1234.887; double y1 = 2453.778; Die berechneten Werte: 1316.1463999999999 1467.8306133333331 1665.0200906666664 1875.3555331555553 2068.1630221037035 2222.4090132622218 2330.3812070731847 2396.192829967486 2430.7439319869941 2446.0999773289977 2451.7305272877325 2453.3685054575462 2453.7234007276725 2453.7743600485114Ich weiss es nicht, ob das so korrekt wäre-
Gruß
-
Moin!
Hi,
danke für deine Bemühung. Die Formel "y = y0 * (x1-x) / (x1-x0) + y1 * (x-x0) / (x1-x0)" is ide Aufgelöste Form von der, was ich als zaehle und nenner in meinem Programm habe. Beide geben dieselbe Ergebenisse zurück.
Das problem liegt anscheint im Datum und dessen Umwandlung in Sekunden. Je ich mich dem zweiten Wert (x2) annähere, desto verdichten sich die berechneten Werte:
double y0 = 1234.887; double y1 = 2453.778; Die berechneten Werte: 1316.1463999999999 1467.8306133333331 1665.0200906666664 1875.3555331555553 2068.1630221037035 2222.4090132622218 2330.3812070731847 2396.192829967486 2430.7439319869941 2446.0999773289977 2451.7305272877325 2453.3685054575462 2453.7234007276725 2453.7743600485114Ich weiss es nicht, ob das so korrekt wäre-
Das ist nicht mehr linear und könnte eine Folge davon sein, dass Du y1 den Wert von y gibst. Richtig ist es auf keinen Fall, also hat Deine Mechanik einen Fehler.
Du willst womöglich folgendes:
X1 Y1 - gesetzte Werte x y - interpoliert :: y = Y1 + (Y2-Y1)/4 wenn delta x jeweils 1/4(x2-X1) ist. x y - interpoliert :: Y = Y + 2*(Y2-Y1)/4 wenn delta x jeweils 1/4(x2-X1) ist. x y - interpoliert :: Y = Y + 3*(Y2-Y1)/4 wenn delta x jeweils 1/4(x2-X1) ist. X2 Y2 x y - interpoliert :: y = Y2 + (Y3-Y2)/4 wenn delta x jeweils 1/4(x3-X2) ist. x y - interpoliert :: Y = Y + 2*(Y3-Y2)/4 wenn delta x jeweils 1/4(x3-X2) ist. x y - interpoliert :: Y = Y + 3*(Y3-Y2)/4 wenn delta x jeweils 1/4(x3-X2) ist. X3 Y3 x y - interpoliert :: y = Y3 + (Y4-Y3)/4 wenn delta x jeweils 1/4(x4-X3) ist. x y - interpoliert :: Y = Y + 2*(Y4-Y3)/4 wenn delta x jeweils 1/4(x4-X3) ist. x y - interpoliert :: Y = Y + 3*(Y4-Y3)/4 wenn delta x jeweils 1/4(x4-X3) ist. X4 Y4 ...Du hast wie im Beispiel konstante Abstände zwischen den Punkten, kannst Dir also allerhand ersparen. Aber, Da, wo zum Zeitpunk X2 der Wert Y2 gemessen wurde, musst Du neu interpolieren und so weiter. Du bekommst dann aber nicht EINE Line über die gesamte Messstrecke, sondern n-1 Linien zwischen den Messpunkten (deren Zahl n sei). Die wird (voraussichtlich!) gezackt sein.
Du hast immer nicht kommuniziert, was Du wirklich willst. Eine gerade Linie oder eine gezackte Linie?
Willst Du jedoch genau eine gerade Linie über alle Messpunkte interpolieren, dann setze in "meine" Formel
y = y0 * (x1-x) / (x1-x0) + y1 * (x-x0) / (x1-x0)- für x0 das arithmetische Mittel der ersten (früheren) Hälfte der Messpunkte.
- für y0 das arithmetische Mittel der zugehörigen Messwerte
- für x1 das arithmetische Mittel der zweiten (späteren) Hälfte der Messpunkte.
- für y1 das arithmetische Mittel der zugehörigen Messwerte
Ist die Zahl der Messpunkte ungerade, dann berechne die vier arithmetischen Mittel jeweils einschließlich des mittleren Messwertes.
Die von Dir gezeigten Zahlen lassen kaum Rückschlüsse auf den Fehler zu. Ich müsste das nachprogrammieren und dann Deine Fehler spekulativ nachahmen. Da gibt es aber sehr viele Möglichkeiten, die ich dann mit Deinen Resultaten vergleichen müsste - was mir schlicht zu viel Aufwand ist. Deinen Fehler sehe ich ggf. in Deinem Code. So lange es nur um Mathe geht ist die Sprache halbwegs (Bis auf die Feinheiten Deiner DateTime-Objekte z.B.) egal.
Jörg Reinholz
-
-
-
-
Tach!
Oder kann C# damit umgehen, dass aus den DateTime-Objekten eine Differenz gebildet wird? Das erscheint mir jedenfalls ungewöhnlich.
Es kann. Das ist auch nicht ungewöhnlich für Programmiersprachen, die Operatorüberladung (operator overloading) kennen. Man kann damit für jeden beliebigen Typ Rechenoperationen definieren. Beispielsweise kann man auch einen Punkt und einen Vektor addieren und bekommt dann einen neuen Punkt.
dedlfix.
-
-
Moin,
double y1 = 1234.887; double y2 = 2453.778; DateTime x1 = Convert.ToDateTime("2015-01-01 00:15:00.000"); DateTime x2 = Convert.ToDateTime("2015-01-01 00:30:00.000"); DateTime x = Convert.ToDateTime("2015-01-01 00:16:00.000"); for (int i = 1; i < 15; i++) { double zaehler = (y2 - y1) * (x - x1).TotalSeconds; double nenner = (x2 - x1).TotalSeconds; double result = (zaehler / nenner) + y1; y1 = result; x1 = x.AddMinutes(1); }Sieht ihr da irgendwelche Fehler.
Die Variable x wird nicht neu gesetzt, glaube das wurde hier schon erwähnt. Aus
y1 = result; x1 = x.AddMinutes(1);sollte ein
y1 = result; x1 = x; x = x.AddMinutes(1);werden, sofern du das wirklich so umsetzen möchtest. Um alle Datenpunkte zu erfassen habe ich mal folgenden Schnipsel verfasst.
List<double> results = new List<double>(); double y1 = 1234.887; double y2 = 2453.778; DateTime x1 = Convert.ToDateTime("2015-01-01 00:15:00.000"); DateTime x2 = Convert.ToDateTime("2015-01-01 00:30:00.000"); DateTime x = x1; while (x <= x2) { double y = y1 + (x - x1).TotalSeconds * (y2 - y1) / (x2 - x1).TotalSeconds; results.Add(y); x = x.AddMinutes(1); }hth bernd
-
-
meine empfehlung als mathestudent mit 2.0 in numerik:
-
schau in das skript das ich oben gepostet habe unter "interpolation mit lagrange basisplinomen"
-
deine ganzen daten dienen nur dazu ein polynom p(x) zu berechnen, bzw die basispolynome
-
du berechnest alle p(x), x=t1,t2,t3,.... die du brauchst
-
du testet deine implementierung indem du die beispiele aus dem skript testest
anstelle des skripts kannst du auch das hier benutzen:
http://www.numerik.mathematik.uni-mainz.de/didaktikseminar/Gruppe2b/Interpolationsformel_von_Lagrange.htm
und das hier als beispiel zum testen der implementierung:
http://www.numerik.mathematik.uni-mainz.de/didaktikseminar/Gruppe2b/Beispiel_von_Lagrange.htm
grundprinzip:
du hast (xi, yi), i=1,...,n als rohdaten gegeben mit einem tackt von 5 minuten (deine rohdaten haben einen FESTEN takt von 15 minuten, warum zur hölle verwendest du also secunden??????? -> die secunden differenz kann dir scheiß egal sein, du hast einen feste takt!). da du einen festen takt hast sollten deine x gewählt werden als x=1,15,30,45,......
du baust dir ein polynom p(x) fuer das gilt: p(xi)=yi wie im link beschrieben! -> speichern musst du dafür nur die Li, i=1,...,n, die du mit einer methode berechnest
hast du die Li, hast du p(x) und kannst die fehlenden werte berechnen per:
(x,p(x)) mit x=2,3....,14,16,17,....,28,29,31,32,.... (x=1,15,30, usw hast du ja schon gegeben)
-
Moin!
Was haben denn Polynome und die krummen Dinger von Lagrange mit der Interpolation auf einer Geraden zu tun?
Jörg Reinholz
-
Moin!
Was haben denn Polynome und die krummen Dinger von Lagrange mit der Interpolation auf einer Geraden zu tun?
Jörg Reinholz
die krummen dinger sind das was man unter einer "glatten linie" versteht (siehe erstes posting des fragenstellers), "genügend glatt" bedeutet "genügend oft stetig differenzierbar". differenzierbar heißt, dass wir in jedem punkt ableiten können, d.h. dass wir keine gerade im bildbereich des polynoms haben, was wiederum den daten entsprechende würde, die im eingangsposting gezeigt wurden
die daten der eingangsfrage sind, wenn man die datenpunkte verbindet, kurvig, daher sollte man die polynominterplation verwenden.
- es ist sehr leicht zu imlementieren
- approximiert die fehlenden werte auf anständige weise, bzw hat eine bessere performance als diese liniare irgendwas
- ihr verzettelt euch in dem zeug, dass ihr oben zusammen gedacht habt. was für informatik gilt gilt übrigens auch für mathematik, man sollte lieber fertige lösungen verwenden und keine neuen zwischen tür und angel entwickeln
-
Moin!
Moin!
Was haben denn Polynome und die krummen Dinger von Lagrange mit der Interpolation auf einer Geraden zu tun?
die krummen dinger sind das was man unter einer "glatten linie" versteht (siehe erstes posting des fragenstellers)
Gut, aber jetzt erkläre mir, was Polynome, die krummen Dinger des Herrn Lagrange und "genügend gerade" Linien mit "Lineare Interpolation" zu schaffen haben, die sich im Titel findet?
Jörg Reinholz
P.S. Ich habe nichts erfunden. Das hat ein gewisser, mathematisch begeisterter Herr, dem der Sage nach eine Birne auf den Kopf fiel (Just als er unter einem vermeintlichen Apfelbaum schlief!) sehr viel früher getan.
-
"Datum = 2015.01.01 06:00:00, Wert = 1224,167 Datum = 2015.01.01 06:15:00, Wert = 1344,207 Datum = 2015.01.01 06:30:00, Wert = 1524,367 Datum = 2015.01.01 06:45:00, Wert = 1555,707 ... Datum = 2015.01.02 06:15:00, Wert = 1024,57 Datum = 2015.01.02 06:30:00, Wert = 1924,50 ..."
-> wende hier beide methoden an, die lineare und die lagrange und vergleiche beide ergebnisse. im übrigens sprechen wir bei der linearen interpolation von polynomen vom grad 1, weil xa+b nach x differenzierbar ist (f'(x)=a -> steigung der geraden).
der fragensteller wollte eine einfache und effiziente lösung und dachte diese in linearer interpolation zu finden (ist mir vor jahren genauso passiert und ich habe mich tagelang mit linearerm zeuges rumgequält und mich über die schlechten ergebnisse gewundert). daher kurz und knapp: benutzt die lagrange basispolynome!
-
Moin!
> Datum = 2015.01.01 06:00:00, Wert = 1224,167 > Datum = 2015.01.01 06:15:00, Wert = 1344,207 > Datum = 2015.01.01 06:30:00, Wert = 1524,367 > Datum = 2015.01.01 06:45:00, Wert = 1555,707 > ... > Datum = 2015.01.02 06:15:00, Wert = 1024,57 > Datum = 2015.01.02 06:30:00, Wert = 1924,50 > ...-> wende hier beide methoden an, die lineare und die lagrange und vergleiche beide ergebnisse. im übrigens sprechen wir bei der linearen interpolation von polynomen vom grad 1, weil xa+b nach x differenzierbar ist (f'(x)=a -> steigung der geraden).
Das wissen wir nicht! Wir wissen auch gar nichts brauchbares über die Herkunft der Zahlen. Das kann eine "Sägezahnfunktion" sein, z.B. eine Produktionsmenge, die nachts um 0:00 auf Null zurück gesetzt und ansonsten aller 15 Minuten abgemessen wird.
Dazu würden die Zahlen passen.
Hier die Lösung mit der in dem Fall sinnvollen lineare Interpolation über einen Tag- aber in PHP
<?php # Eingangsdaten: $ar[strtotime("2015-01-01T06:00:00")]=1224.167; $ar[strtotime("2015-01-01T06:15:00")]=1344.207; $ar[strtotime("2015-01-01T06:30:00")]=1524.367; $ar[strtotime("2015-01-01T06:45:00")]=1555.707; $mitte=count($ar)/2; $median=(count($ar)+1)/2; $_Dx_1=0; $_Dx_2=0; $_Dy_1=0; $_Dy_2=0; $i=1; foreach (array_keys($ar) as $key) { if ($i <= $median) { $_Dx_1=$_Dx_1+$key; $_Dy_1=$_Dy_1+$ar[$key]; } if ($i >= $median) { $_Dx_2=$_Dx_2+$key; $_Dy_2=$_Dy_2+$ar[$key]; } $i++; } $x0=$_Dx_1/ceil($mitte); $y0=$_Dy_1/ceil($mitte); $x1=$_Dx_2/ceil($mitte); $y1=$_Dy_2/ceil($mitte); $arKeys = array_keys($ar); $start = $arKeys[0]; $ende = $arKeys[count($arKeys)-1]; $step=60; # Sekunden for ($x=$start; $x<=$ende; $x=$x+60) { echo $x, "\t", lineareInterpolation ($x, $x0, $y0, $x1, $y1), "\n"; } function lineareInterpolation ($x, $x0, $y0, $x1, $y1) { return ($y0 * ($x1-$x) / ($x1-$x0)) + ($y1 * ($x-$x0) / ($x1-$x0)); }Ergebnisse:
1420088400 1220.2245 1420088460 1228.7528333333 1420088520 1237.2811666667 1420088580 1245.8095 1420088640 1254.3378333333 1420088700 1262.8661666667 1420088760 1271.3945 1420088820 1279.9228333333 1420088880 1288.4511666667 1420088940 1296.9795 1420089000 1305.5078333333 1420089060 1314.0361666667 1420089120 1322.5645 1420089180 1331.0928333333 1420089240 1339.6211666667 1420089300 1348.1495 1420089360 1356.6778333333 1420089420 1365.2061666667 1420089480 1373.7345 1420089540 1382.2628333333 1420089600 1390.7911666667 1420089660 1399.3195 1420089720 1407.8478333333 1420089780 1416.3761666667 1420089840 1424.9045 1420089900 1433.4328333333 1420089960 1441.9611666667 1420090020 1450.4895 1420090080 1459.0178333333 1420090140 1467.5461666667 1420090200 1476.0745 1420090260 1484.6028333333 1420090320 1493.1311666667 1420090380 1501.6595 1420090440 1510.1878333333 1420090500 1518.7161666667 1420090560 1527.2445 1420090620 1535.7728333333 1420090680 1544.3011666667 1420090740 1552.8295 1420090800 1561.3578333333 1420090860 1569.8861666667 1420090920 1578.4145 1420090980 1586.9428333333 1420091040 1595.4711666667 1420091100 1603.9995Die Zahlen für den 2. Tag werfen dann die Frage nach der Herkunft der Zahlen auf. Aber hier eine Kurve hereinzuinterpretieren ist, wenn es sich - die Zahlen legen das nahe - um die "Sägezahn-Sache" handelt, falsch - weil dann höchst merkwürdige Kurven auftauchen (Welchen Grad hat denn ein Polynom, wenn 48 Stunden lang aller 15 Minuten gemessen wird?) die zu unsäglich von der Realität abweichenden Kurven führen und nicht gerade produktiv sind, wenn es um eine Abschätzung des Wertes zu einem nicht gemessenen Zeitpunkt handelt.
Mathematiker zu sein ist sicherlich ein ehrenvoller Zustand. Aber man muss auch ein wenig Realitätssinn bewahren.
Jörg Reinholz
-
Ihr habt beide recht. Casablanca hat aber in seiner Aufgabenstellung widersprüchliche Ziele formuliert, jeder von euch hat nun eine Lösung für eine der unvereinbaren Aufgabenstellungen erarbeitet. Casablanca spricht einerseits von linearer Interpolation und möchte andererseits ein überstimmtes Gleichungssystem durch eine glatte Funktion approximieren. Im allgemeinen Fall sind das aber verschiedene Funktionen. Beides gleichzeitig ist nur dann zu erreichen, wenn die Messdaten zufälligerweise schon auf einer Gerade liegen.
Ihr beide habt nun Lösungen entwickelt, die die zweite Bedingung erfüllen, also die Glätte beibehalten. Ihr verletzt im Gegenzug jeweils die erste Bedingung, allerdings auf unterschiedliche Weise:
Jörg gibt die Interpolations-Bedingung auf, und versucht das überstimmte Gleichungssystem stattdessen durch eine lineare Approximation, genauer mittels linearer Regression zu lösen. Dabei nimmt er also einen Approximations-Fehler in Kauf. D.h. dass die lineare Regression ausgewertet an den ursprünglichen Stützstellen, nicht mehr den Messwerten entspricht. Mit der Wahl für lineare Regression, geht Jörg außerdem implizit davon aus, dass der Approximations-Fehler in der euklidishen Norm minmiert werden soll. Das kann man wieder in Frage stellen, aber die Wahl ist häufig sinnvoll.
Student hingegen hat sich entschieden, die Interpolations-Bedingung zu wahren und stattdessen die Linearität aufzugeben. Er abstrahiert deshalb über den Polynomgrad und lässt auch Polynome höheren Grades zu.
Eine dritte Lösungsmöglichkeit bestünde darin, die Glätte aufzugeben, und dafür die lineare Interpolation beizubehalten. Dann ergibt sich ein Graph, den Jörg hier schon öfter als zackig beschrieben hat.
Bevor wir aber weiter ins Detail gehen und versuchen bestimmte Eigenschaften zu optmieren, wäre es sinnvoll von Casablanca zu hören, was er eigentlich erreichen möchte. Wenn du mit dem mathematischen Geschwafel nicht so viel anfangen kannst, dann zeig uns doch mal eine Skizze, in der du die Messdaten und die angenäherte Funkton einzeichnest, das muss nicht hunterprozentig exakt sein, aber es sollte schematisch erkennbar sein, ob die Funktion genau durch die Messpunkte führen muss, ob die Funktion Ecken haben darf, oder ob sie schön geschwungen sein muss. Außerdem wäre es noch hilfreich zu wissen, ob während der Lebensdauer deines Programms mit neuen Messdaten zu rechnen ist, dann stellt sich nämlich ggf. auch die Frage, ob einmal berechnete Zwischenwerte auch neu berechnet werden dürfen, wenn ein neuer Messpunkt hinzukommt, oder ob er möglichst immer unverändert bleiben soll.
-
Moin!
1.) United hat recht und von mir sein [+] bekommen.
2.) So. Jetzt der Spaß mit dem Interpolieren zwischen den Messpunkten, diese bleiben also als Stützen und dazwischen wird linear interpoliert. Hat also Zacken, die "Linie".
Ist ein Kindrspiel wenn man array_shift() kennt.
array_shift liefert den Wert und löscht das erste Elemnt des Arrays, setzt danach aber das erste auf den Index 0!) So wie ich das gelöst habe ist das aber egal ... denn die Arrays dienen zum Wegwerfen.
In der Schleife wird geprüft, ob x einem der Unterstützungspunkte entspricht, wenn ja wird der Wert (y) zurückgeliefert. Schlagen diese Fehl, dann wird geprüft, ob x zwischen dem kleinsten noch bekannten Untertützungspunkt und dem nächsten liegt.
Wenn ja: interpolieren. wenn nein: bisheriger nächster Punkt wir früherer Punkt, neuer nächster Punkt wird aus Arrays geholt und in den Arrays gelöscht, das spart Schleifen und Speicher. Danach wird natürlich interpoliert, denn einer der Messpunkte kann es logisch nicht sein:
<?php # Eingangsdaten: $ar[strtotime("2015-01-01T06:00:00")]=1224.167; $ar[strtotime("2015-01-01T06:15:00")]=1344.207; $ar[strtotime("2015-01-01T06:30:00")]=1524.367; $ar[strtotime("2015-01-01T06:45:00")]=1555.707; $arKeys = array_keys($ar); $start = $arKeys[0]; $ende = $arKeys[count($arKeys)-1]; $step=60; # Sekunden $step=60; # Sekunden # die zuletzt gesehenen Punkte (x0,y0 ; x1,y1) weren für den Start definiert # außerhalb vin diesen ist eine INTERpolation unzulässig, sonst wäre es eine # Extrapolation ... $x0 = array_shift($arKeys); $y0 = array_shift($ar); $x1 = array_shift($arKeys); $y1 = array_shift($ar); for ($x=$start; $x<=$ende; $x=$x+60) { $y=false; if ($x == $x0) { $y=$y0; } elseif ($x == $x1) { $y=$y1; } elseif ( $x > $x0 && $x < $x1 ) { $y = lineareInterpolation ($x, $x0, $y0, $x1, $y1); } else { # Löschen des jeweils kleinsten (ersten) ArrayElements: $x0 = $x1; $y0 = $y1; $x1 = array_shift($arKeys); $y1 = array_shift($ar); $y = lineareInterpolation ($x, $x0, $y0, $x1, $y1); } echo $x, "\t", $y, "\n"; } function lineareInterpolation ($x, $x0, $y0, $x1, $y1) { return ($y0 * ($x1-$x) / ($x1-$x0)) + ($y1 * ($x-$x0) / ($x1-$x0)); }Ergebnis:
1420088400 1224.167 1420088460 1232.1696666667 1420088520 1240.1723333333 1420088580 1248.175 1420088640 1256.1776666667 1420088700 1264.1803333333 1420088760 1272.183 1420088820 1280.1856666667 1420088880 1288.1883333333 1420088940 1296.191 1420089000 1304.1936666667 1420089060 1312.1963333333 1420089120 1320.199 1420089180 1328.2016666667 1420089240 1336.2043333333 1420089300 1344.207 1420089360 1356.2176666667 1420089420 1368.2283333333 1420089480 1380.239 1420089540 1392.2496666667 1420089600 1404.2603333333 1420089660 1416.271 1420089720 1428.2816666667 1420089780 1440.2923333333 1420089840 1452.303 1420089900 1464.3136666667 1420089960 1476.3243333333 1420090020 1488.335 1420090080 1500.3456666667 1420090140 1512.3563333333 1420090200 1524.367 1420090260 1526.4563333333 1420090320 1528.5456666667 1420090380 1530.635 1420090440 1532.7243333333 1420090500 1534.8136666667 1420090560 1536.903 1420090620 1538.9923333333 1420090680 1541.0816666667 1420090740 1543.171 1420090800 1545.2603333333 1420090860 1547.3496666667 1420090920 1549.439 1420090980 1551.5283333333 1420091040 1553.6176666667 1420091100 1555.707Jörg Reinholz
-
Moin!
Habe gerade mal die Zeit genommen - mit microtime(1). Schmeisst auf meinem Rechner in der Konsole 2700 Werte in 0,033 Sekunden. Mit Kompilieren und Aufruf von PHP (aber aus dem Cache) sieht es so aus:
real 0m0.055s user 0m0.028s sys 0m0.027sJörg Reinholz
-
Habe gerade mal die Zeit genommen - mit microtime(1). Schmeisst auf meinem Rechner in der Konsole 2700 Werte in 0,033 Sekunden.
Das ist extrem langsam, aber ich glaube auch, dass du schlecht getesetet hast. Ich habe zum Vergleich mal eine einfache lineare Interpolationsfunktion in JavaScript geschrieben, damit komme ich auf knapp 454.000.000 Funtionsauswertungen pro Sekunde.
Du solltest beim Benchmarking unbedingt den zu messenden Code in Isolation testen, und ganz besonders solltest du teure I/O-Operationen wie echo vermeiden.
-
Moin!
Du solltest beim Benchmarking unbedingt den zu messenden Code in Isolation testen, und ganz besonders solltest du teure I/O-Operationen wie echo vermeiden.
Warum? Ich wollte wissen wie schnell es MIT den Ausgaben auf die Konsole geht.
Ich erinnere mich noch an einen KC 85, der hat für die Berechnung von z=f(x,y) (und dann nichts zu kompliziertes) in jeweils 100 Schritten (macht 10.000 Berechnungen der Formel) und jeweils das Poken eines Bytes in den Graphikspeicher rund 15 Minuten gebraucht...
Jörg Reinholz
-
lagrangeinterpolation in der vom frangesteller gesuchten programmiersprache, einschließlich tests:
http://www.codecogs.com/library/maths/approximation/interpolation/lagrange.php
das erste was ich als werkstudent im data science gelernt habe war:
- sowenig wie möglich selbst programmieren und testen
- sowenig wie möglich selbst über mathematische logik nachdenken
- die eingesparte zeit lieber zum kicker spielen und kaffee trinken nutzen
-> ich hab zum auffinden meiner lösung 30 sekunden gebracht, wielange wart ihr mit eurem php code beschäftigt?
-
Hallo Student29.05,
das erste was ich als werkstudent im data science gelernt habe war:
- sowenig wie möglich selbst programmieren und testen
- sowenig wie möglich selbst über mathematische logik nachdenken
- die eingesparte zeit lieber zum kicker spielen und kaffee trinken nutzen
-> ich hab zum auffinden meiner lösung 30 sekunden gebracht, wielange wart ihr mit eurem php code beschäftigt?
Und wieviel hast du dabei gelernt?
Der Punkt ist der: klar, man kann sich die Sachen im Internet zusammensuchen und damit möglichst produktiv sein. Das ist aber nicht die Devise von SELFHTML, denn die ist „Die Energie des Verstehens.“
LG,
CK-
Und wieviel hast du dabei gelernt?
ich habe oben schon eine passende erläuterung zu lagrange verlinkt
Der Punkt ist der: klar, man kann sich die Sachen im Internet zusammensuchen und damit möglichst produktiv sein. Das ist aber nicht die Devise von SELFHTML, denn die ist „Die Energie des Verstehens.“
man sollte entwickeln und nicht programmieren. ein entwickler konzentriert sich darauf fertige komponenten herauszusuchen und zusammen zu bauen und um das effizienz gebacken zu kriegen, muss man verschiedene dinge verstehen und lernen. jemand der alles selbst programmiert lernt ehrlich gesagt garnichts, paar zeilen code runterzutippen ist ziemlich leicht, aber unterschiedliche software komponenten zu verknüfpen kann sehr schwer sein.
wenn man zb einen algorithmus in java haben möchte, sollten man folgendes tun:
- heraussuchen welche fertigen algorithmen man zb im statistik tool R benutzen kann
- diese R algorithmen an das java programm einbienden (anstrengender als reinen code zu schreiben und definitiv lehrreicher für software entwickler)
- testen ob die software allen anforderungen entsprecht (sie läuft wie sie laufen soll), gegebenenfalls probleme fixen
dämlich wäre folgende vorgehens weise:
- sich selber einen algorithmus ausdenken und aufgrund von fehlendem fleis eine dreisatz ähnliche lösung wählen
- ihn selbst komplett in java zu implementieren
- ihn dann nach 10 monaten entwicklungsarbeit zu testen und an bugs und logikfehlern zu verzweifeln
-> konzentriert euch mehr auf das gesamtproblem und weniger auf irrelevante feinheiten die menschen mit passenden berufen schon längst gelöst haben
-
Hallo Student29.05,
Und wieviel hast du dabei gelernt?
ich habe oben schon eine passende erläuterung zu lagrange verlinkt
Das habe ich nicht gefragt ;-)
man sollte entwickeln und nicht programmieren.
Ich würde dir recht geben, wenn wir hier bei $softwarekonzern wären. Ich gebe dir nicht recht, weil wir hier in einem Raum des Lernens sind.
ein entwickler konzentriert sich darauf fertige komponenten herauszusuchen und zusammen zu bauen und um das effizienz gebacken zu kriegen, muss man verschiedene dinge verstehen und lernen. jemand der alles selbst programmiert lernt ehrlich gesagt garnichts, paar zeilen code runterzutippen ist ziemlich leicht, aber unterschiedliche software komponenten zu verknüfpen kann sehr schwer sein.
Das sehe ich anders. Ein nicht-triviales Problem und mögliche Lösungen versteht man nur dann wirklich, wenn man einmal selbst eine Lösung implementiert hat. Ich habe z.B. mal einen SMTP-Server geschrieben. Würde ich den in der freien Wildbahn verwenden? Nein. Habe ich dabei etwas gelernt? Ja, eine Menge. Und gleichzeitig hat es mein Verständnis für existierende MTAs deutlich vertieft.
wenn man zb einen algorithmus in java haben möchte, sollten man folgendes tun:
[…]
dämlich wäre folgende vorgehens weise:
[…]
Das hängt vom Ziel ab. Wenn es mein Ziel ist, möglichst schnell zu einem Ergebnis zu kommen hast du recht. Wenn es mein Ziel ist, möglichst viel zu lernen, liegst du falsch.
LG,
CK-
man sollte entwickeln und nicht programmieren.
Ich würde dir recht geben, wenn wir hier bei $softwarekonzern wären. Ich gebe dir nicht recht, weil wir hier in einem Raum des Lernens sind.
kurz und knapp meine thesen:
- man baut sich auch keine eigene daten bank, weil dass schon experten getan haben. man sollte: a) fertige datenbank lösungen benutzen b fertige algorithmische lösungen c) fertige implementierungen
-> weil man selten besser sein kann als die experten die diese lösungen über jahre hinweck gebaut haben
-
lernen sollte man von vornherein dass verwenden von experten lösungen, es ist eine ganz andere aufgabe experten lösungen zu verwenden und zusammen zu bauen als eigene lösungen zu implementieren. lernt man dass eine lernt man das andere nicht.
-
es ist viel schwerer experten lösungen zu verwenden als eigene lösungen zu implementieren, daher sollte man sich auf experten lösungen konzentrieren
Das sehe ich anders. Ein nicht-triviales Problem und mögliche Lösungen versteht man nur dann wirklich, wenn man einmal selbst eine Lösung implementiert hat. Ich habe z.B. mal einen SMTP-Server geschrieben. Würde ich den in der freien Wildbahn verwenden? Nein. Habe ich dabei etwas gelernt? Ja, eine Menge. Und gleichzeitig hat es mein Verständnis für existierende MTAs deutlich vertieft.
- im mathematik studium wird kaum programmiert, paar meiner komilitonen können das garnicht. weißt dass das wir algorithmen (zb aus dem bereich der interpolation) nicht verstanden haben?? mit dem was du da geschrieben hast, behauptest du, dass sich viele mathematiker nicht mit mathe auskennen
wenn man zb einen algorithmus in java haben möchte, sollten man folgendes tun:
[…]
dämlich wäre folgende vorgehens weise:
[…]
Das hängt vom Ziel ab. Wenn es mein Ziel ist, möglichst schnell zu einem Ergebnis zu kommen hast du recht. Wenn es mein Ziel ist, möglichst viel zu lernen, liegst du falsch.
derzeit bastle ich an einer lösung bei welcher ein lugin mit einer c# dll komuniziert, welche wiederum mit einem php server komuniziert, welcher wiederum auf einen passenden R algorithmus zugreifen kann. alerternativ könnte ich den algo. einfach ins plugin schreiben .... ich halte lösung nr 1 für lehrreicher und verbuche lösung nr 2 unter trivial (+ schlechtere performance)
-
Hallo Student29.05,
- man baut sich auch keine eigene daten bank, weil dass schon experten getan haben.
Doch, das habe ich schonmal getan (und ich habe an einer FOSS-Datenbank, PostgreSQL, gearbeitet). Ich würde sie nicht produktiv einsetzen, aber ich habe dadurch genug gelernt um einerseits Datenbanken effizient einsetzen zu können und andererseits Patches für PostgreSQL schreiben zu können. Abgesehen davon verstehe ich dadurch besser, welche Auswirkungen welches Statement auf die Datenbank hat und welche Arbeit dahinter steckt.
man sollte: a) fertige datenbank lösungen benutzen b fertige algorithmische lösungen c) fertige implementierungen
Wie gesagt, das hängt von der Zielsetzung ab.
-> weil man selten besser sein kann als die experten die diese lösungen über jahre hinweck gebaut haben
Das ist richtig und das bestreite ich nicht.
- lernen sollte man von vornherein dass verwenden von experten lösungen, es ist eine ganz andere aufgabe experten lösungen zu verwenden und zusammen zu bauen als eigene lösungen zu implementieren. lernt man dass eine lernt man das andere nicht.
Ich bin das lebende Beispiel, dass mindestens der letzte Teil deiner These falsch ist. ;-) Produktiv verwende ich sehr viel fertige Software und Implementierungen.
- es ist viel schwerer experten lösungen zu verwenden als eigene lösungen zu implementieren, daher sollte man sich auf experten lösungen konzentrieren
Das ist eine Behauptung ohne Beleg. Ich bestreite das. Deine Schlussfolgerung basiert IMHO auf einer falschen Prämisse.
- im mathematik studium wird kaum programmiert, paar meiner komilitonen können das garnicht. weißt dass das wir algorithmen (zb aus dem bereich der interpolation) nicht verstanden haben?? mit dem was du da geschrieben hast, behauptest du, dass sich viele mathematiker nicht mit mathe auskennen
Nicht alles, was hinkt, ist ein Vergleich. In dem Fall müsstest du eher so denken: wenn jemand noch nie eine Interpolation durchgeführt hat, dann wird er sie auch nicht wirklich verstehen. Das hat mit programmieren so erstmal nichts zu tun.
derzeit bastle ich an einer lösung bei welcher ein lugin mit einer c# dll komuniziert, welche wiederum mit einem php server komuniziert, welcher wiederum auf einen passenden R algorithmus zugreifen kann. alerternativ könnte ich den algo. einfach ins plugin schreiben .... ich halte lösung nr 1 für lehrreicher und verbuche lösung nr 2 unter trivial (+ schlechtere performance)
Du hast mich immer noch nicht verstanden ;-) Natürlich ist es unsinnig, etwas „von Hand“ zu machen, wenn man es bereits kann.
Aber abgesehen davon hast du hier genau das gemacht, was ich dir versuche zu erklären. Du hast den schwereren Weg gewählt (du schreibst extra ein Plugin, dass eine C#-DLL nutzt um R über PHP ausführen zu lassen) obwohl jeder Software-Architekt bei diesem Lösungsweg beide Hände über dem Kopf zusammenschlagen und die triviale Lösung implementieren würde (in diesem Fall das Hinschreiben des Algorithmus).
LG,
CK-
Hallo,
- es ist viel schwerer experten lösungen zu verwenden als eigene lösungen zu implementieren, daher sollte man sich auf experten lösungen konzentrieren
Das ist eine Behauptung ohne Beleg.
natürlich ist sie ohne Beleg, weil Schwierigkeitsgrad eine hochgradig subjektive Sache ist. Ich stimme dem Studenten sogar zu, allerdings abhängig von der Komplexität der Aufgabe.
Denn um fertige Lösungen zu verwenden, die jemand anders entwickelt hat, muss man sich zunächst in dessen Denkweise hineinarbeiten, um die Funktionsweise, mindestens aber das API und die Rahmenbedingungen zu verstehen. Dieser Aufwand übersteigt IMO oft schon die Komplexität der eigentlichen Aufgabe.
Mir selbst ist es schon des öfteren so gegangen, dass ich die Idee, eine fertige Lösung zu verwenden, eigentlich ganz vernünftig fand. Aber wenn ich dann zwei, drei Tage über der Dokumentation brüte und noch immer nicht verstanden habe, wie der Entwickler sich das gedacht hat, auf der anderen Seite aber in wenigen Stunden selbst eine Rohfassung des Algorithmus ausgearbeitet habe, dann ist das IMO ein klares Votum gegen die fertige Lösung.
Wohlgemerkt: Diese Erfahrung gilt für verhältnismäßig kleine Aufgaben. Bei größeren Anforderungen wie etwa der Integration eines ausgereiften Javascript-Interpreters oder einer Datenbank-Maschine in das eigene Projekt liegt das Aufwand-Nutzen-Verhältnis sicher anders.
So long,
Martin
-
Aloha ;)
Ich würde dir recht geben, wenn wir hier bei $softwarekonzern wären. Ich gebe dir nicht recht, weil wir hier in einem Raum des Lernens sind.
kurz und knapp meine thesen:
- man baut sich auch keine eigene daten bank, weil dass schon experten getan haben. man sollte: a) fertige datenbank lösungen benutzen b fertige algorithmische lösungen c) fertige implementierungen
Ich verstehe nicht ganz, warum du Christians Argumente inhaltlich so vollkommen ignorierst. Was du schreibst, kann unter Umständen richtig sein. So wie du es hinstellst (als bedingungslose Wahrheit) ist es aber vollkommener Quatsch.
Das liegt einfach daran, dass es grundsätzlich gilt, das Ziel der Sache zu analysieren. Bevor du Aussagen über eine bestimmte Herangehensweise treffen kannst (was du hier tust, indem du die eine der anderen vorziehst) musst du zuerstmal klären, worum es im Endeffekt geht.
Wie Christian schon sagte: Wenn du bei $softwarekonzern arbeitest muss die Lösung vor allem bzgl. Aufwand effizient sein (was für deine Thesen spricht). Wenn du versuchst, Übung im Programmieren zu bekommen, sind deine Thesen falsch. So gibt es viele weitere Umstände (zur Verfügung stehende Programmiersprachen, zur Verfügung stehende Hardware, rechtliche Aspekte ...), die es zunächst zu Bedenken gibt, bevor man sich dazu hinreißen lassen sollte, die eine Herangehensweise über die andere zu stellen.
-> weil man selten besser sein kann als die experten die diese lösungen über jahre hinweck gebaut haben
Dieses Argument ist sehr kurzsichtig. Glaubst du die experten sind zu Experten geworden, weil sie ihr ganzes Leben lang Implementierungen anderer zusammengewürfelt haben (was unbestrittenerweise auch nicht immer einfach ist) und nie ein Stück Software selbst programmiert haben? Sicher nicht.
Außerdem ist auch "besser" wieder ein Wort, das man so undifferenziert nicht hinstellen sollte. "Besser" bezieht sich sinnvollerweise nämlich auf "besser bezüglich des verfolgten Ziels" und hat so bedingungslos für sich selbst keinerlei Bedeutung.
- lernen sollte man von vornherein dass verwenden von experten lösungen, es ist eine ganz andere aufgabe experten lösungen zu verwenden und zusammen zu bauen als eigene lösungen zu implementieren. lernt man dass eine lernt man das andere nicht.
Nein, ich widerspreche. Ich würde sagen:
Man muss wissen, wann es hinsichtlich des verfolgten Ziels besser ist, fertige Lösungen zu verwenden und wann es besser ist, Lösungen selbst zu implementieren. Man sollte grundsätzlich zu beidem in der Lage und bereit sein.
- es ist viel schwerer experten lösungen zu verwenden als eigene lösungen zu implementieren, daher sollte man sich auf experten lösungen konzentrieren
Nein. Das mag für dich so sein (wenn dir das implementieren eigener Lösungen so leicht fällt), ist aber sicher keine allgemeingültige Aussage, die auf jeden Menschen zutrifft. Außerdem: Um "Experten-Lösungen" (was soll das sein, frage ich mich, woran erkenne ich die, wenn ich nichts über ihre Funktionsweise weiß) zu verwenden und entsprechend zusammenzustellen brauche ich, wie du sagst, schon einen gewissen Skill. Da stimme ich zu. Und wo soll der bitteschön herkommen? Um Expertenlösungen zusammenzubauen braucht man Übung in den verwendeten Hochsprachen und mit der zur Verwendung kommenden Programmierlogik. Wo soll die herkommen, außer daher, dass man selbst in diesen Sprachen schonmal (irgendwas) implementiert hat?
Das sehe ich anders. Ein nicht-triviales Problem und mögliche Lösungen versteht man nur dann wirklich, wenn man einmal selbst eine Lösung implementiert hat. Ich habe z.B. mal einen SMTP-Server geschrieben. Würde ich den in der freien Wildbahn verwenden? Nein. Habe ich dabei etwas gelernt? Ja, eine Menge. Und gleichzeitig hat es mein Verständnis für existierende MTAs deutlich vertieft.
- im mathematik studium wird kaum programmiert, paar meiner komilitonen können das garnicht. weißt dass das wir algorithmen (zb aus dem bereich der interpolation) nicht verstanden haben?? mit dem was du da geschrieben hast, behauptest du, dass sich viele mathematiker nicht mit mathe auskennen
Vollkommener Quark. Du hast Christian offensichtlich nicht verstanden, oder zumindest schlägt dein Beispiel genau daneben. Mathematiker (ich bin selbst einer) beschäftigen sich mit Algorithmen auf einer wissenschaftlich-mathematischen Basis und untersuchen Eigenschaften dieser Algorithmen, vollkommen unabhängig von der Implementierung (in letzterem steckt ja genau die Mathematik, wäre ja ein Witz, wenn die Mathematik keine allgemeinen, sondern lediglich implementierungs-abhängige Aussagen treffen würde). Das Programmieren ist aber im Endeffekt zu großen Teilen die Frage nach der Implementierung eines Algorithmus (einen zu finden spielt zwar auch eine Rolle, macht aber nicht den gesamten Umfang aus). Damit hat das Programmieren mit der Mathematik sicherlich Schnittmengen, ist aber ganz bestimmt keine Teilmenge. So what?
Das hängt vom Ziel ab. Wenn es mein Ziel ist, möglichst schnell zu einem Ergebnis zu kommen hast du recht. Wenn es mein Ziel ist, möglichst viel zu lernen, liegst du falsch.
derzeit bastle ich an einer lösung bei welcher ein lugin mit einer c# dll komuniziert, welche wiederum mit einem php server komuniziert, welcher wiederum auf einen passenden R algorithmus zugreifen kann. alerternativ könnte ich den algo. einfach ins plugin schreiben .... ich halte lösung nr 1 für lehrreicher und verbuche lösung nr 2 unter trivial (+ schlechtere performance)
Das Argument mit schlechterer Performance ist ziemlicher Quatsch, weil es bezüglich der Performance auch stark davon abhängt, wie die Implementierung der einzelnen miteinander kommunizierenden Fragmente aussieht und wie viel über den Flaschenhals Schnittstelle kommuniziert werden muss, es ist also hier gar nicht möglich, so allgemeine Aussagen über Performance zu treffen. Außerdem leuchtet es bei den gar so trivialen Algorithmen (du meinst ja sie seien trivial zu implementieren) nicht ein, wieso es performanter sein soll, Daten über zig Schnittstellen zu reichen und dabei zig weitere Aktivitätsträger (= Prozesse) anzuwerfen. Das ist so ziemlich das Gegenteil von performant (was anderes ist es, wenn es gute Gründe gibt, das eine oder andere Spezialsystem zu nutzen, das hast du aber nirgends vorausgesetzt).
Du magst vollkommen Recht haben, dass die Lösung Nr. 1 auch lehrreich ist. Für die Frage, was lehrreicher ist, kommt es aber auf viele Umstände an. Lösung Nr. 1 setzt, wie ich schon sagte, Grundkenntnisse voraus, die man nur durch Anwenden von Lösung Nr. 2 in genügend vielen Fällen erlangen kann.
Grundsätzlich solltest du dir die Frage stellen, wo wir hier sind. Wir sind bei selfhtml, wir haben es uns zur Aufgabe gemacht, Lernwillige an den selbständigen Umgang mit Webtechnologien heranzuführen. Das Forum ist dazu da, mit den Fragestellern verschiedene Lösungsmöglichkeiten zu entwickeln und zu diskutieren. Das unterscheidet uns von Foren wie StackOverflow (nur ein Beispiel), in denen auf Fragen lediglich fertige Lösungen erwünscht sind. Es braucht sicherlich beide Sorten von Foren, nur sind wir hier eben die eine und nicht die andere Art. Dementsprechend ist es hier im Normalfall nicht unbedingt angebracht, lediglich fertige Lösungen zu posten.
Ich würde mir von deiner Seite einen etwas weniger dogmatischen und dafür reflektierteren Umgang mit solchen Themen in dieser Diskussion hier wünschen - immerhin bist du so gut wie überhaupt nicht auf Christians Erwiderungen eingegangen (und wo du es getan hast, siehe Mathematik-Beispiel, hatte ich nicht den Eindruck, als hättest du Christian wirklich verstanden oder verstehen wollen).
Grüße,
RIDER
--
Camping_RIDER a.k.a. Riders Flame a.k.a. Janosch Zoller Erreichbar manchmal im Self-TS (ts.selfhtml.org) oder sonst - wenn online - auf dem eigenen TeamSpeak-Server (fritz.campingrider.de) oder unter: # Facebook # Twitter # Steam # YouTube # Self-Wiki # ch:? rl:| br:> n4:? ie:% mo:| va:) js:) de:> zu:) fl:( ss:| ls:[-
in ordnung, nur bedenkt auch, dass sich die welt weiterentwickelt. auch das handwerk der softwareentwicklung ist nicht mehr das gleiche.
früher hat man nah am binär code gearbeitet, dann kamen objektorientierte sprachen etc. und jetzt kommt es des öfteren dazu, dass es code generatoren für datenbank dinge und frontendsachen gibt.... ich glaube in 10-20 jahren wird man keine einzige for-schleife mehr selbst implementieren und da man heutzutage auch keine binärprogrammierung mehr verstehen muss, wird man dann auch keine rein codestücke mehr bearbeiten müssen. der schwerpunkt in der software entwicklung verändert sich und ich rate allen experten im verstehen von experten lösungen zu werden, den so leicht ist das nicht (evaluieren und verstehen von experten lösungen gehört natürlich dazu).
-
früher hat man sich erst dinge wie zb assembly in der lehre angeschaut und erst im anschluss sachen wie java etc.
dann hat sich die menschheit weiterentwickelt und es wurde sinnvoll sich in der lehre erst java anzuschauen und erst im anschluss assembly etc., inzwischen reicht es sich nur noch java etc. anzugucken
in 10-20 jahren wird man sich in der lehre erst expertenlösungen anschauen, schnittstellen, inputdaten usw und sich überlegen wie man diese zusammenbauen kann und sich erst im anschluss die entsprechenden implementierungen anschauen
-> weg vom code und hin zur software, die werkzeuge die man dafür braucht werden sich nach und nach weiterentwickeln.
-
Hallo,
früher hat man sich erst dinge wie zb assembly in der lehre angeschaut und erst im anschluss sachen wie java etc.
ach, hat man? Okay, als ich studiert habe (Anfang der 90er), hat von Java noch niemand gesprochen. Aber wir haben erst Pascal gelernt, dann C, und dann schließlich einen Einstieg in Assembler.
Also erst eine sehr formale, streng reglementierte Sprache, die vor allem der Erziehung dient, dann eine universelle und flexible Sprache mit schier unbegrenzten Möglichkeiten, und dann eben mit Assembler der spezialisierte Blick bis tief in die Hardware.inzwischen reicht es sich nur noch java etc. anzugucken
Das halte ich für extrem kurzsichtig. Wer sich auch nur im Entferntesten mit Programmierung und Softwareentwicklung beschäftigen will, sollte auf jeden Fall mehrere Programmiersprachen und Philosophien kennen. Nicht alle im Detail, aber zumindest in etwa kennen.
-> weg vom code und hin zur software, die werkzeuge die man dafür braucht werden sich nach und nach weiterentwickeln.
Ja. Und für die Entwicklung der Werkzeuge braucht's immer noch die Experten, wie ich auch im anderen Posting schon erwähnte.
So long,
Martin
-
-
Hi,
in ordnung, nur bedenkt auch, dass sich die welt weiterentwickelt. auch das handwerk der softwareentwicklung ist nicht mehr das gleiche.
früher hat man nah am binär code gearbeitet, dann kamen objektorientierte sprachen etc. und jetzt kommt es des öfteren dazu, dass es code generatoren für datenbank dinge und frontendsachen gibt.... ich glaube in 10-20 jahren wird man keine einzige for-schleife mehr selbst implementieren und da man heutzutage auch keine binärprogrammierung mehr verstehen muss, wird man dann auch keine rein codestücke mehr bearbeiten müssen.
der These muss ich teilweise(!) widersprechen. Sie mag für den großen Teil der Nutzer oder auch der Gelegenheits-Programmierer zutreffen; vielleicht sogar auf einen nennenswerten Anteil der Softwareentwickler.
Aber damit das alles so möglich ist, braucht es immer noch eine Software-Schicht, die sehr nah an der Hardware arbeitet. Und deshalb wird man im Bereich der Betriebssystem- und Treiberprogrammierung auch in etlichen Jahren noch Entwickler und Programmierer brauchen, die sehr hardwarenah denken. Das mag eine kleine Minderheit sein, aber ganz ohne die geht's nicht.
Schließlich weiß heute auch kaum noch jemand, wie Butter hergestellt wird, man kann sie ja einfach im Supermarkt kaufen. Trotzdem sind noch ein paar Leute nötig, die dieses Wissen und diese Fertigkeiten haben.
Ciao,
Martin-
naja, ich meinte das allgemeine entwicklerwissen auf das man dann wiederum seinen schwerpunkt aufbaut. natürlich wird es weiterhin experten in sachen hardware nähe etc. geben. das sich die arbeitsteilung in der software weiter ausdehnen wird, ist der hauptgrund warum ich schreibe, dass sinnvoll wäre beizeiten weg von der "vom code zur software"-sichtweise zu kommen und anstelle dessen eine "von der software zum code"-sichtweise zu entwickeln. das ziel immer im auge haben!
wenn ich eine software bauen möchte, suche ich mir erst alle software teile aus die mir gefallen und die zum ziel passen. dann bastle ich alles zusammen und optimiere das ganze dann so, dass meine software step by step die gewollte gestallt annimmt. natürlich pople ich dabei auch manchmal fertige software komponenten auf und drehe paar code sachen um, aber das tue ich erst nachdem der kern meiner software funktioniert. der unterschied zur "vom code zur software"-herangehensweise ist, dass ich junittests, debugger, etc. auf ganz andere weise verwenden muss
-
-
-
-
- sowenig wie möglich selbst über mathematische logik nachdenken
Doch, aber die Denkarbeit muss im Voraus stattfinden. Du hast über den Tellerand gespäht und mit der Polynominterpolation eine sinnvolle Lösungsalternative vorgeschlagen. Ungeklärt ist noch, ob die Aufgabenstellung damit eigentlich erfüllt wird, und ob es vielleicht sogar bessere Alternativen gibt: Ich sehe zwei potenzielle Probleme mit der Polynominterpolation:
-
Man hat keine Wahl bei den Stützstellen, diese werden den Messdaten entnommen. Es könnte also sein, dass die Polynominterpolation für diese Messdaten schlecht konditioniert ist.
-
Da die Messwerte zeitdiskret aufgenommen werden, ist damit zu rechnen, dass im Laufe des Programms auch neue Messwerte hinzukommen. In dem Fall müsstest du das Interpolations-Polynom neu aufstellen und erneut an den Zwischenstellen auswerten. Bei der Splinenterpolation z.B. würde sich dieses Problem nicht stellen.
Bei der Auswahl eines Lösungsverfahren muss man die Mathematik sehr wohl bemühen, die Implementations-Arbeit die dann folgt, ist stumpfsinniges Zusammenschustern, dafür würde ich dann auch zu einer fertigen und erprobten Lösung greifen. Du bist auf einem guten Weg, lass deinen Tellerand jetzt nicht enden.
-
die spliens die ich im ersten posting vorgeschlagen hab, habe ich wieder verworfen, weil die teile eventuell zu abschreckend auf den fragesteller wirken, daher die lagrange polynome.
splines habe ich mir immer über das statistik tool R in meine programme eingebunden (eine selbst implementierung von splins würde ich nicht vornehmen, da baut man zuviele schlecht debugbare fehler rein):
https://stat.ethz.ch/R-manual/R-patched/library/stats/html/splinefun.html
-
splines habe ich mir immer über das statistik tool R in meine programme eingebunden (eine selbst implementierung von splins würde ich nicht vornehmen, da baut man zuviele schlecht debugbare fehler rein):
Wenn das dein "verwenden von experten lösungen" ist, solltest du nochmal darüber nachdenken. Das hört sich für mich sehr nach zusammengeschustertem Murks an. Prinzipiell spricht ja nichts gegen die Verwendendung fertiger und getesteter Bibliotheken, wobei man da schon wieder aufpassen muss, ob die Lizenz es dir erlaubt diese auch in einem kommerziellem closed source Projekt zu nutzen.
Aber soweit ich dich verstehe, plädierst du hier dafür, Splins immer über R berechnen zu lassen und in deiner eigentlichen Anwendung über die abenteuerlichsten Wege auf die Ergebnisse zuzugreifen.
Dann verstehe ich auch die Aussage, dass es viel schwerer ist Expertenlösungen zu verwenden als eigene Lösungen zu implementieren. -
(eine selbst implementierung von splins würde ich nicht vornehmen, da baut man zuviele schlecht debugbare fehler rein):
Naja, ob dein Programmcode schlecht oder gut zu debuggen ist, ist keine Frage, die sich ausschließlich aus der Problemstellung ergibt. Man kann mit methodischen Vorgehen dafür sorgen, dass Programmcode immer eine Codequalität erfüllt, auf deren Basis das Debuggen leicht fällt. Testdriven-Development und continious Refacotoring sind zwei sehr bekannte und weit verbreitete Methoden.
Und mal ehrlich, mathematische Funktionen sind wirklich gutmütig und extrem einfach zu testen. Sie sind von Natur aus idempotent, haben also keine Nebenwirkungen, sie sind von Natur aus referenziell transparent, ergeben also für die selben Eingangsdaten immer die selben Ausgangsdaten. Das ist der Traum eines jeden Unittest-Designers, man muss keine komplizierten Umgebugnen mocken und kann sehr einfache Testfälle konstruieren.
Ich möchte dir gar nicht widersprechen und sagen, man solle auf seine eigene Implementation bauen, es gibt viele gute Gründe dafür, bestehende und erporbte Softwaremodule wiederzuverwenden, aber das Argument, das du hier in die Diskussion einbringst, ist so nicht haltbar.
-
-
Moin!
-> ich hab zum auffinden meiner lösung 30 sekunden gebracht, wielange wart ihr mit eurem php code beschäftigt?
Gewiss nicht lange. Ich habe ja auch zuerst veröffentlicht.
Jörg Reinholz
-
Du solltest beim Benchmarking unbedingt den zu messenden Code in Isolation testen, und ganz besonders solltest du teure I/O-Operationen wie echo vermeiden.
Warum? Ich wollte wissen wie schnell es MIT den Ausgaben auf die Konsole geht.
Wenn das dein gestecktes Ziel war, hab ich keine Einwände, dann hast du alles richtig gemacht. Ich gebe allerdings zu Bedenken, dass du dadurch sehr wenige Rückschlüsse auf die Effizienz der Implementierung deiner Interpolations-Funktion ziehen kannst. Fundamentale arithmetische Operationen sind im Verhältnis zu I/O-Operationen sehr kostengünstig, in diesem Fall würde ich sogar fast schon sagen vernachlässigbar. Was du gemssen hast, ist im Grunde die Geschwindigkeit, mit der PHP Ausgaben auf die Commandprompt schreiben kann. Aus reiner Neugier: Würdest du den Test nochmal laufen lassen, allerdings diesmal zuvor Ausgabepufferung aktivieren?
-
Hallo 1unitedpower,
Aus reiner Neugier: Würdest du den Test nochmal laufen lassen, allerdings diesmal zuvor Ausgabepufferung aktivieren?
Die ist by default für stdin, stdout und stderr auf line-wise buffered eingestellt.
LG,
CK -
Moin!
Aus reiner Neugier: Würdest du den Test nochmal laufen lassen, allerdings diesmal zuvor Ausgabepufferung aktivieren?
Für die 2700 Durchläufe, nur die For-Schleife:
Ganz ohne Ausgaben|0.001926 Gepuffert (ob_start/ob_flush)|0.004638 Sekunden sofort auf Konsole|0.034456 Sekunden
Du hast offensichtlich recht damit, dass die Ausgabe auf die Konsole teuer ist. Aber halt. Ich teste mal mit Ausgabe in eine Datei und einen Pipe (ohne den mit zu messen!)
php test.php > out.txt|0.023997 Sekunden php test5.php | cat > out.txt|0.011151 Sekunden php test5.php | grep -v 'ß'| 0.009514 Sekunden
Fazit: Du hast Recht! Der Ausgabepuffer von PHP macht es sehr viel schneller - vor allem, wenn zahlreiche Ausgabeoperationen zu bewerkstelligen sind. Sollte man wohl nutzen - und zwar stets dann, wenn es keine Bedenken hinsichtlich des Speicherverbrauchs gibt.
Jetzt würde ich das doch glatt gerne mal auf der selben Maschine unter Windows sehen :)
Jörg Reinholz
-
-
-
-
-
-
-
-
-
-
-