Casalblanca: Lineare Interpolation

0 45

Lineare Interpolation

Casalblanca
  • c#
  1. 0
    Student07.05.2015
    1. 0
      Casalblanca
      1. 0
        Tabellenkalk
        • c#
        • programmiertechnik
        • statistik
  2. 1
    Jörg Reinholz
    1. 0
      Casalblanca
      1. 0
        Jörg Reinholz
        1. 0
          Casalblanca
          1. 0
            Jörg Reinholz
            1. 0
              Casalblanca
              1. 0
                Jörg Reinholz
                • c#
                • programmiertechnik
        2. 0
          dedlfix
      2. 0
        bernd
  3. 0
    Student26.05.15
    1. 0
      Jörg Reinholz
      1. 0
        Student27.05
        1. 0
          Jörg Reinholz
          1. 0
            Student27.05
            1. 0

              Lineare Interpolation - Eine Lösung in PHP

              Jörg Reinholz
              • php
              • statistik
              1. 4
                1unitedpower
                1. 0

                  Lineare Interpolation mit Zacken - Eine Lösung in PHP

                  Jörg Reinholz
                  1. 0

                    Mann, sind die Rechner schnell geworden...

                    Jörg Reinholz
                    1. 0
                      1unitedpower
                      1. 0
                        Jörg Reinholz
                        1. 0

                          lösung mit lagrange...

                          Student29.05
                          1. 1
                            Christian Kruse
                            1. 0
                              Student29.05
                              1. 5
                                Christian Kruse
                                1. 0
                                  Student29.05
                                  1. 1
                                    Christian Kruse
                                    1. 1
                                      Der Martin
                                      • programmiertechnik
                                      • software
                                  2. 3
                                    Camping_RIDER
                                    1. 0
                                      Student29.05
                                      1. 0
                                        Student29.05
                                        1. 0
                                          Der Martin
                                      2. 0
                                        Der Martin
                                        • software
                                        1. 0
                                          Student29.05
                          2. 0
                            1unitedpower
                            1. 0
                              Student29.05
                              1. 1
                                unkown
                              2. 0
                                1unitedpower
                          3. 0
                            Jörg Reinholz
                        2. 0
                          1unitedpower
                          1. 0
                            Christian Kruse
                          2. 0

                            PHP, Ausgabe- Pufferung. Performance

                            Jörg Reinholz

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.

  1. 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/

    1. 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,50
      

      Gruß

      1. 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,50
        

        Wenn 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

  2. 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:

    1. Teile die Datentupel am Median in zwei Hälften mit gleicher Menge. (Bei ungerader Anzahl füge den mittleren Datenpunkt (Median) beiden hinzu).
    2. Ermittle den Durchschnitt von x (Zeitpunkt) und y (Messwert) für jeder Hälften.
    3. 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).

    1. 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ß

      1. 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

        1. Hi,

          nein, das hat seine Richtigkeit. Die Daten-Differenz wird zunächst ermittelt und das Ergbenis wird das als Sekunden zurückgegeben.

          Gruß

          1. 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      = 8
            
            fü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     = 10
            
            für X=3:
            y = 8 * (4-3) / (4-2) + 16 * (3-2) / (4-2) =  8*1/2 + 16*1/2 = 4+8      = 12
            
            fü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     = 14
            
            fü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

            1. 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.7743600485114
              

              Ich weiss es nicht, ob das so korrekt wäre-

              Gruß

              1. 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.7743600485114
                

                Ich 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

        2. 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.

      2. 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

  3. meine empfehlung als mathestudent mit 2.0 in numerik:

    1. schau in das skript das ich oben gepostet habe unter "interpolation mit lagrange basisplinomen"

    2. deine ganzen daten dienen nur dazu ein polynom p(x) zu berechnen, bzw die basispolynome

    3. du berechnest alle p(x), x=t1,t2,t3,.... die du brauchst

    4. 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)

    1. Moin!

      Was haben denn Polynome und die krummen Dinger von Lagrange mit der Interpolation auf einer Geraden zu tun?

      Jörg Reinholz

      1. 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.

        1. es ist sehr leicht zu imlementieren
        2. approximiert die fehlenden werte auf anständige weise, bzw hat eine bessere performance als diese liniare irgendwas
        3. 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
        1. 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.

          1. "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!

            1. 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.9995
              

              Die 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

              1. 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.

                1. 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.707
                  

                  Jörg Reinholz

                  1. 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.027s
                    

                    Jörg Reinholz

                    1. 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.

                      1. 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

                        1. 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:

                          1. sowenig wie möglich selbst programmieren und testen
                          2. sowenig wie möglich selbst über mathematische logik nachdenken
                          3. 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?

                          1. Hallo Student29.05,

                            das erste was ich als werkstudent im data science gelernt habe war:

                            1. sowenig wie möglich selbst programmieren und testen
                            2. sowenig wie möglich selbst über mathematische logik nachdenken
                            3. 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

                            1. 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:

                              1. heraussuchen welche fertigen algorithmen man zb im statistik tool R benutzen kann
                              2. diese R algorithmen an das java programm einbienden (anstrengender als reinen code zu schreiben und definitiv lehrreicher für software entwickler)
                              3. testen ob die software allen anforderungen entsprecht (sie läuft wie sie laufen soll), gegebenenfalls probleme fixen

                              dämlich wäre folgende vorgehens weise:

                              1. sich selber einen algorithmus ausdenken und aufgrund von fehlendem fleis eine dreisatz ähnliche lösung wählen
                              2. ihn selbst komplett in java zu implementieren
                              3. 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

                              1. 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

                                1. 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:

                                  1. 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

                                  1. 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.

                                  2. 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.

                                  1. 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)

                                  1. Hallo Student29.05,

                                    1. 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.

                                    1. 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.

                                    1. 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.

                                    1. 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

                                    1. Hallo,

                                      1. 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

                                  2. 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:

                                    1. 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.

                                    1. 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.

                                    1. 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.

                                    1. 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:[
                                    1. 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).

                                      1. 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.

                                        1. 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

                                      2. 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

                                        1. 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

                            1. 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:

                            1. 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.

                            2. 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.

                            1. 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

                              1. 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.

                              2. (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.

                          2. 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

                        2. 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?

                          1. 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

                          2. 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