Roulette mit System? Der PHP Martingale Simulator

Ein bevorstehender USA-Urlaub inkl. Abstecher nach Las Vegas und eine dubiose Werbeanzeige im Internet, die schnellen Reichtum durch Glücksspiel verspricht sorgen dafür, dass ich mich heute mit Martingale-Roulette beschäftige…

Ein kurzer Disclaimer vorweg: Es gibt kein System mit dem man beim Roulette risikolos gewinnt. Es besteht immer die Gefahr des Verlusts des Einsatzes!

Beim sogenannten Martingale-Roulette platziert man seinen Einsatz am Tisch nach folgendem System:

Man beginnt mit dem Mindesteinsatz (z.B. 5 EUR) und platziert diesen z.B. auf rot. Gewinnt man, erhält man 10 EUR und platziert den Mindesteinsatz (erneut 5 EUR) auf der anderen Farbe (im Beispiel also schwarz). Verliert man aber, verdoppelt man im nächsten Spiel den Einsatz und setzt erneut auf die “Verliererfarbe”. Im Beispiel würden wir also dann 10 EUR auf rot setzen. Verliert man erneut, verdoppelt man wieder (20 EUR) und bleibt der Farbe treu.

Wenn es die Null nicht gäbe, hatte man beim Roulette nach diesem System eine Gewinnchance von 50% (rot oder schwarz). Man müsste bei einem verlorenen Spiel oder einer “Pechsträhne” seinen Einsatz lediglich immer weiter verdoppeln und nach dem Gewinn das Spiel abbrechen.

Doch die Sache hat gleich mehrere Haken:

1.) Die Wahrscheinlichkeit – Freund des Casinobetreibers

Will man die Gewinnwahrscheinlichkeit beim Roulette näher betrachten, so muss man zunächst zwischen französischem und amerikanischem Roulette unterscheiden. Beim französischen Roulette gibt es 18 rote Felder, 18 schwarze Felder und die Null (Bank), insgesamt also 37 Felder/Zahlen. Beim amerikanischen Roulette kommt noch die “Doppel-Null” hinzu, hier spielt man also mit insgesamt 38 Feldern/Zahlen und die Wahrscheinlichkeit, dass weder schwarz noch rot erscheinen verdoppelt sich.

Die Wahrscheinlichkeit für rot (oder schwarz) liegt beim französischen Roulette bei 18/37 (48.6%), beim amerikanischen Roulette bei 18/38 (47.4%). Die Tatsache, dass diese Wahrscheinlichkeiten unter 50% liegen zeigt bereits, dass im Mittel nicht der Spieler sondern der Casinobetreiber gewinnt.

2.) Das Tischlimit

Natürlich weiss auch das Casino, dass ein disziplinierter Spieler mit diesem Spielsystem einfach bei Verlusten seinen Einsatz immer verdoppeln müsste um irgendwann einen Gewinn einzufahren (was je nach Spielrunde und Einsatzhöhe jeden Casinobetreiber in den Ruin treiben würde). Man hat daher ein so genanntes Tischlimit eingeführt. D.h. die Obergrenze des Einsatzes pro Spiel ist begrenzt (oft z.B. auf 12.000 EUR).

Das das Ganze trotzdem durchaus funktionieren kann, wurde im Privatfernsehen demonstriert:

https://www.youtube.com/watch?v=5cLabMRVUPw

Das man auch mit diesem System früher oder später einen Totalverlust erleidet kann man durch einen Reload dieser sehen, denn dass nachfolgend gezeigte Skript ist ein PHP Martingale Simulator:

//rot: 1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36
//schwarz: 2,4,6,8,10,11,13,15,17,20,22,24,26,28,29,31,33,35
 
$french = array("bank", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz");
 
$american = array("bank", "bank", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "rot", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz", "schwarz");
 
 
//setze Mindesteinsatz (hier 5€) auf rot
$spiel_nr=1;
$kontostand=50;
$start_einsatz=5;
$start_farbe="rot";
//Man kann natürlich nur dann weiterspielen, wenn man über ein Restguthaben verfügt
while($kontostand>0)
{
//Wenn an dieser Stelle noch kein Einsatz platziert wurde, muss es sich um das erste Spiel handeln und Startfarbe und Starteinsatz werden gesetzt
if(!isset($farbtipp)) {$farbtipp=$start_farbe;}
if(!isset($einsatz)) {$einsatz=$start_einsatz;}
 
//array_rand liefert ein Zufallsfeld aus dem Array $french (alternativ $american) zurück
$zufallsfarbe=$french[array_rand($french)];
 
//Liegen wir mit unser Tipp richtig oder falsch?
if($zufallsfarbe==$farbtipp) 
{
$ergebnis="gewonnen"; 
echo "Ziehung: ".$spiel_nr." | Einsatz: ".$einsatz." | Tipp: ".$farbtipp." | Ziehungsfarbe: ".$zufallsfarbe." | Ergebnis: ".$ergebnis." | Kontostand: ";
$kontostand=$einsatz+$kontostand; 
echo $kontostand."
";
//Farbe des Gewinnertipps ändern
if($farbtipp=="rot") {$farbtipp="schwarz";}
else {$farbtipp="rot";};
//Einsatz auf Anfangsniveau zurücksetzen
$einsatz=$start_einsatz; 
//Angenommen der Spieler ist diszipliniert und hört nach Verdopplung seines Geldes in jedem Fall auf.
if($kontostand>=100) {echo $kontostand." nach ".$spiel_nr." Spielen"; exit;}
}
 
else 
{
$ergebnis="verloren"; 
echo "Ziehung: ".$spiel_nr." | Einsatz: ".$einsatz." | Tipp: ".$farbtipp." | Ziehungsfarbe: ".$zufallsfarbe." | Ergebnis: ".$ergebnis." | Kontostand: ";
$kontostand=$kontostand-$einsatz;
echo $kontostand."
";
$einsatz=$einsatz*2;
if($einsatz>$kontostand) {$einsatz=$kontostand;}
}
 
$spiel_nr++;
}

Und so sieht unser Simulator dann aus… (leider liess sich das Ganze nicht direkt hier einbinden, deshalb im neuen Fenster)

Ein weiterer netter Artikel zum Thema aus der FAZ: Denkfehler die uns Geld kosten

Wissen Sie, womit Ihre Mitarbeiter Ihre Zeit verbringen?

Mit genau dieser interessanten Frage beschäftigt sich das neue B2B Projekt von zoerb.net, das Prozessoptimierung kinderleicht macht:

moment.info bietet ein innovatives System für Multimomentanalysen

Das neue System moment.info gibt Unternehmen eine unkomplizierte und kostengünstige Lösung für Prozessoptimierung an die Hand. Die Basis des Systems bildet dabei die Durchführung von Multimomentanalysen. Erfinder des Systems ist Dr. Andreas Zörb, der dem Nutzer einen einfachen Zutritt über die Einrichtung eines Accounts auf der Website moment.info gewährt.

Unternehmen brauchen Informationen über die internen Prozesse, um den Erfolg zu steigern und wettbewerbsfähig zu werden oder zu bleiben. Multimomentanalysen stellen dafür ein geeignetes Werkzeug dar. Sie erfassen unregelmäßig auftretende Vorkommnisse von Mitarbeitern in einer so genannten Multimomentaufnahme in ihren prozentualen Anteilen, um sie in einem nächsten Schritt auszuwerten. moment.info führt diese Analysen durch, indem die Mitarbeiter zu unregelmäßigen Zeitpunkten per SMS nach ihrer momentanen Tätigkeit befragt werden. Die Rückmeldungen werden vom System gespeichert und verarbeitet. Aus den gewonnenen Daten erstellt das System nach statistischen Regeln eine Übersicht über die Aufwands- und Arbeitszeitverteilung.

Erstmalig wurden Multimomentanalysen Anfang des 20. Jahrhunderts als bedeutendes Instrument zur Analyse von Arbeitsabläufen eingesetzt. L. H. C. Tippet, ein britischer Statistiker, gilt als geistiger Vater der Multimomentanalyse. Seit 1927 beschäftigte er sich mit der so genannten “Snap-reading-method of making time-studies”. Dabei erkannte er, dass schon eine relativ kleine Anzahl an Stichproben ausreicht, um die tatsächlichen Stillstandzeiten innerhalb eines Unternehmens mit erstaunlicher Genauigkeit zu erfassen.

Zörb erklärt: “Im Internetzeitalter sind Multimomentaufnahmen oder auch Worksamplings nicht weniger aussagekräftig als damals, dank moderner Technik aber sehr viel einfacher durchführbar.”

Helligkeit von Farben, Kontrast, Farbunterschiede per PHP berechnen

PHP und Farbe – Helligkeit, Kontrast und Farbunterschied berechnen

Beim Sinieren über SEO und On-Page Optimierung kreisten meine Gedanken kürzlich um Folgendes:

Um eine Webseite „oben“ in den Google Suchergebnissen zu positionieren braucht es Content. Eine Überschrift „Keyword1 Keyword2“ hilft bereits weiter.

Erst recht, wenn diese über einem themenrelevanten Text mit einer bestimmten Keyword Dichte steht. Nun könnte es erstrebenswert sein, eine Seite unter einer Keyword Kombination finden zu lassen, die man seinen Besuchern nicht als prominente Überschrift oder Textblock präsentieren möchte. CSS bietet natürlich die Möglichkeit < h1 > Tags oder andere Elemente weniger dominant zu formatieren, doch darum soll es hier nicht gehen.

In den 90er Jahren soll es tatsächlich funktioniert haben, Überschriften oder gar Texte mit weisser Schrift auf weissem Hintergrund einzubinden und die Suchmaschinen so zu täuschen und sich eine bessere Position in den Trefferlisten zu erschleichen.

SCHON SEIT LÄNGERER ZEIT FUNKTIONIERT DIES NICHT MEHR! (vgl. hierzu http://www.seo-united.de/onpage-optimierung/content-texte.html und https://support.google.com/webmasters/answer/66353?hl=en) doch auch darum soll es hier nicht gehen.

Mich beschäftigt viel eher die Frage: „Wie schafft es Google oder generell eine Maschine dies zu erkennen (und zu bestrafen)?“. Denkt man darüber nach, kommt man zur Frage: Wie kann man z.B. einem PHP Skript beibringen den Helligkeitsunterschied zwischen 2 Farben zu bestimmen? Der Unterschied zwischen Hellgelb (#FFFFE0) und weissem Hintergrund müsste ja deutlich kleiner sein, als der Unterschied zwischen Dunkelbraun (#654321) und dem selben Hintergrund. Aber wie kann man dies berechnen?

Fangen wir mit den Grundlagen der Farbentheorie an: Im HTML Code einer Internetseite werden Farben als sog. HEX Code definiert (z.B #FFFFFF für weiss). http://de.wikipedia.org/wiki/Hexadezimale_Farbdefinition

Dieser Code entspricht einfach der hexadezimalen Schreibweise des entsprechenden RGB Codes, der jede Farbe in einen Rot, Grün und Blau Anteil zwischen 0 und 255 aufspaltet. Weiss hat die Anteile R=255, G=255 und B=255. Schwarz hat die Anteile R=0, G=0, B=0.

Nun gibt es das interessante Konzept des RGB Farbwürfels. Die x, y und z Achse dieses Würfels repräsentieren die Farben Rot, Grün und Blau und gehen jeweils von 0 bis 255. Jede Farbe kann nun durch 3 Koordinaten beschrieben werden und entspricht einem Punkt innerhalb dieses Würfels.

rgb_farbraum

Soweit so gut. Noch interessanter wird es, wenn man sich mit der Helligkeit dieser Farben beschäftigt. Je näher der beschriebene „Farbpunkt“ an der weissen Ecke dieses Würfels zu liegen kommt, desto heller ist die entsprechende Farbe. Das bedeutet aber auch, dass es einen Grünton gibt, dessen Helligkeit exakt der eines (z. B.) Rottones in der selben Entfernung der weissen Ecke entspricht. Eine bestimmte Helligkeit kann man sich also als Ansammlung/Fläche von Punkten innerhalb des Farbwürfels vorstellen, die denselben Abstand zur „weissen Ecke“ haben. Diese Fläche hat die Form eines Kugelsegments.

Diesen Abstand könnte man nun berechnen und daraus auf die Helligkeit einer beliebigen Farbe schliessen:

248_155_253

RGB-Farbe 248,155,253 (http://www.colorhexa.com/f89bfd)

255-248 = 7
255-155 = 100
255-253 = 2

Summe Δ 109

204_204_204

RGB-Farbe 204,204,204 (http://www.colorhexa.com/cccccc)

255-204 = 51
255-204 = 51
255-204 = 51

Summe Δ 153

Je kleiner diese Zahl, desto näher ist die betrachtete Farbe an der weissen Ecke, sprich umso heller. Und je gösser diese Zahl desta dunkler die entsprechende Farbe:

farben

Nun ist es natürlich ein Leichtes diese Zahlen per PHP miteinander zu vergleichen um herauszufinden, wie gross der Helligkeitsunterschied zwischen den beiden (z.B. Hintergrundfarbe und Textfarbe) ist. In unserem Fall 153-109=44. Nun könnten man einen Schwellenwert definieren (z.B. 50), ab dem eine Seite wegen schlechter Lesbarkeit oder vermeintlicher Betrugsversuche abgestraft wird.

//PHP Hex in RGB umrechnen
$hex_code_text="#000000";
//Nachdem der Hexcode mittels substr in Zweierpäckchen zerteilt wurde, wandelt die Funktion hexdec die Hexadezimalzahlen in Dezimalwerte um
$red = hexdec(substr($hex_code_text, 1, 2));
$green = hexdec(substr($hex_code_text, 3, 2));
$blue = hexdec(substr($hex_code_text, 5, 2));
 
echo "RGB-Code: (".$red."/".$green."/".$blue.")<br>";
 
//Differenz der einzelnen Werte von 255 ermitteln
$dif_white_red=255-$red;
$dif_white_green=255-$green;
$dif_white_blue=255-$blue;
 
$dif_white_sum=$dif_white_red+$dif_white_green+$dif_white_blue;
 
echo "Differenz zu weiss: ".$dif_white_sum."<br>";
 
//Differenz zu beliebiger Hintergrundfarbe
$hex_code_bg="#CCCCCC";
$bg_red = hexdec(substr($hex_code_bg, 1, 2));
$bg_green = hexdec(substr($hex_code_bg, 3, 2));
$bg_blue = hexdec(substr($hex_code_bg, 5, 2));
 
//durch abs wird sichergestellt, dass die Werte nicht negativ werden.
$dif_bg_red=abs($bg_red-$red);
$dif_bg_green=abs($bg_red-$green);
$dif_bg_blue=abs($bg_red-$blue);
 
$dif_bg_sum=$dif_bg_red+$dif_bg_green+$dif_bg_blue;
 
echo "Differenz zur Hintergrundfarbe: ".$dif_bg_sum;

P.S.: Natürlich gibt es andere Farbräume um Farben zu beschreiben, die ggf. zu einem anderen Ergebniss führen würden. Auch sind Farbeindrücke immer subjektiv. Was für den Einen noch gut lesbar erscheint, lässt den Anderen bereits die Augen zusammenkneifen. Es ist ausserdem bekannt, dass Farben umso heller erscheinen, je gesättigter sie sind (Helmholtz Kohlrausch Effekt: http://en.wikipedia.org/wiki/Helmholtz%E2%80%93Kohlrausch_effect). Als erste Näherung und um das Konzept zu verstehen, soll die hier vorgestellte Lösung jedoch genügen.

Das Sommerloch in der Medienlandschaft und wie Sie es für sich nutzen können

Arbeiten Sie in einem Büro? Dann ist Ihnen sicherlich aufgefallen, wie viele Ihrer Arbeitskollegen derzeit im Urlaub sind. Sommerzeit ist Urlaubszeit. Für die Daheimgebliebenen oft eine recht ereignisarme Zeit.

Betreibt man professionalle Pressearbeit, kann man versuchen, dieses so genannte Sommerloch für sich auszunutzen. Da auch in den Monaten Juli und August Tageszeitungen erscheinen und Radio- und Fernsehsendungen produziert werden, ist es in dieser Zeit leichter mit einem Thema in die Medien zu gelangen, dass sonst eher unberücksichtigt bliebe. Das einfache Prinzip von Angebot und Nachfrage spielt einem in der „Saure-Gurken-Zeit“ in die Karten.

Um es mit einer Meldung in die Presse zu schaffen gilt es jedoch einge grundlegende Regeln zu beachten:

1.) Auch im Sommerloch gilt: Professionelle Mitteilungen verbreiten

Lassen Sie Ihre Meldungen von Profis verfassen, Redaktionsbüros erwarten einen ganz bestimmten Aufbau einer Pressemitteilung. Erfüllt eine Meldung diese Erwartungen nicht, wird sie aussortiert.

2.) Verbreitung über seriöse Kanäle

Verzichten Sie auf eine manuelle Verbreitung an das Ihrer Meinung nach zuständige Resort des Zielmediums per eMail. Selbst wenn es Ihre Meldung durch etwaige Filter zum zustängigen Mitarbeiter schafft, wird er Ihre Nachricht höchstwahrscheinlich gelangweilt wegklicken. Er erhält täglich sicherlich dutzende oder gar hunderte derartige Meldungen. Erhält er dieselbe Meldung jedoch über eine seriöse Presseagentur, mit der er bereits in der Vergangenheit gute Erfahrungen gemacht hat (z.B. über die Kanäle der dpa), wird er der Mitteilung sehr viel mehr Aufmerksamkeit schenken.

3.) Verbreitungszeitpunkt geschickt wählen

Verschicken Sie Ihre Meldung keinesfalls an einem Freitag kurz vor Feierabend. Auch Redakteure machen (gerade zu Zeiten des Sommerloch) gegebenenfalls Freitags früher Schluss und Meldungen aus der Vorwoche fallen in der Folgewoche gerne unter den Redaktionstisch. Selbst wenn der Redakteur Ihre Nachricht kurz vor dem Wochenende noch lesen sollte und von Ihrem Produkt angetan ist, besteht die Möglichkeit, dass er Montags zahlreiche andere Dinge im Kopf hat und Ihre Meldung schlicht „vergessen“ wird.

Verschicken Sie Ihre Meldung auch nicht Mo-Do vor 9 Uhr oder nach 17 Uhr. Vielleicht ist Ihre „Zielperson“ ein Langschläfer und beginnt seinen Arbeitstag erst um 09:30 Uhr. Oder er ist Frühaufsteher und bereits ab 15:30 Uhr nicht mehr im Büro.

Der meiner Meinung nach ideale Verbreitungszeitpunkt für eine Pressemitteilung ist an einem Dienstag oder Donnerstag gegen 10:30 Uhr.

Probieren Sie es aus, Sie werden erstaunt sein, welchen Erfolg Sie haben, wenn Sie sich an die oben genannten einfachen Regeln halten. Sollten Sie bei einem oder allen der oben genannten Punkte Hilfe benötigen, stehen wir Ihnen mit unserer Marke Sommerloch PR gerne zur Verfügung…

Eine Einschränkung zum oben genannten gibt es: Sollte die deutsche Nationalmannschaft Fussball-Weltmeister werden, über der Ukraine ein Passagierflugzeug abgeschossen werden oder andere dramatische Ereignisse von bundes- oder weltweitem Interesse stattfinden, wird es schwierig für die eigene Pressemitteilung mit den Meldungen über diese Ereignisse zu konkurrieren. In einem solchen Fall empfiehlt es sich, sich in Geduld zu üben bis das Interesse der Medienlandschaft an diesen Ereignissen abgeflaut ist und es danach zu versuchen…

PHP Gezeiten berechnen | Gezeiten PHP Skript | Ebbe und Flut berechnen | Teil 5

Qualitätskontrolle und weitere Verbesserungen

Im fünften und letzten Teil unseres kleinen Tutorials “PHP Gezeiten berechnen” geht es um den Vergleich der von unserem Ebbe und Flut PHP Script gelieferten Daten mit der Realität.

Dieser fällt zunächst ernüchternd aus:

Ebbe_und_Flut_PHP_Gezeiten_qc1

Problem 1: Unser Skript kann Ebbe und Flut berechnen (Zeitpunkte und Wasserstände). Aber: während zumindest die Zeitpunkte für die Hochwasserevents relativ gut mit der Realität übereinstimmen, trifft unsere Annahme, die Niedrigwasserzeitpunkte würden exakt in der Mitte zwischen zwei Hochwassern liegen offensichtlich nicht zu. Lösung: Statt vom Benutzer lediglich einen Hochwasserevent abzufragen und davon ausgehend künftige Hoch- und Niedrigwasser-Zeiten zu berechnen, fügen wir mit $LW_event_user_timestamp eine weitere Benutzereingabe ein, nämlich ein reales, beobachtetes Niedrigwasser, das uns als Berechnungsgrundlage für künftige Niedrigwasserzeitpunkte dient. Auch hier sollte ein Zeitabstand von 44700 s gelten.

Damit stimmen nun beide Zeitpunkte gut überein:

Ebbe_und_Flut_PHP_Gezeiten_qc2

Problem 2: Unsere zwischen 1.44 und 0.56 schwankende Extremfaktorfunktion fällt im Vergleich zur Realität viel zu schnell ab. Lösung: Das Hochwasser schwankt in Dover zwischen 7.27 m (100%, entspricht 1.44) und 5.54 m (76.2%). Unser Skript geht derzeit jedoch von einer Schwankung zwischen 100% und 56% aus, was zum beobachteten zu schnellen Abfall führt. Verwenden wir für die Schwankungen von Hochwasser und Niedrigwasser nicht unsere Extremfaktorfunktion sondern Funktion Nr. 2 aus Teil 2 sollte dieses Problem behoben sein.

Problem 3: Dem aufmerksamen Beobachter fällt noch eine weitere Ungenauigkeit auf: In der Realität (zumindest an unserem Beispielort Dover) beobachtet man den höchsten Wasserstand (7.27 m) eben nicht wie erwartet bei Voll- oder Neumond sondern erst 2.558 Tage später. Das niedrigste Niedrigwasser fällt jedoch ziemlich exakt mit den Mondextremereignissen zusammen. Lösung: Ich habe für Ebbe und Flut eine “offset” Variable eingefügt, die dies berücksichtigt.

Schlussendlich sieht unser fertiges PHP Ebbe und Flut Skript also so aus:

//Benutzerangaben z. B. via Formular
$MaxHW=7.27;
$MinHW=5.54;
$MaxLW=1.96;
$MinLW=0.2;
$HW_offset=2.558;
$LW_offset=0;
//$HW_event_user=01.01.2014 10:42
$HW_event_user_timestamp=gmmktime(23,07,00,01,01,14);
//$LW_event_user=02.01.2014 06:31
$LW_event_user_timestamp=gmmktime(06,31,00,01,02,14);
//andere Konstanten
$pi=3.1415927;
$two_pi=2*$pi;
//Aus der Monddatenbank entsprechend des eingegebenen Hochwasserdatums die Periodizität berechnen im Bsp 14.73472 Tage = 1273080 s
$extreme_period_sec=1273080;
$extreme_period_days=$extreme_period_sec/(60*60*24);
//letztes Extremereignis aus der Datenbank auslesen
$last_extreme_event_timestamp=gmmktime(11,14,00,01,01,14);
$delta_seconds=$HW_event_user_timestamp-$last_extreme_event_timestamp;
$delta_days=$delta_seconds/(60*60*24);
$HW_event[]=$HW_event_user_timestamp;
$LW_event[]=$LW_event_user_timestamp;
$HW_delta_days[]=0;
 
$i=0;
//HW_events und Wasserhöhen berechnen
while($i<7)
{
$HW_event[]=$HW_event[$i]+44700;
$HW_delta_days[]=$HW_delta_value=($HW_event[$i]-$last_extreme_event_timestamp-$HW_offset)/(60*60*24);
$HW_value[]=($MaxHW-$MinHW)/2*COS($two_pi/$extreme_period_days*$HW_delta_days[$i])+($MinHW)+($MaxHW-$MinHW)/2;
$i++;
}
 
//LW_events und Wasserhöhen berechnen
$i=0;
while($i<7)
{
$LW_event[]=$LW_event[$i]+44700;
$LW_delta_days[]=$LW_delta_value=($LW_event[$i]-$last_extreme_event_timestamp-$LW_offset)/(60*60*24);
$LW_value[]=($MaxLW-$MinLW)/2*COS($two_pi/$extreme_period_days*$LW_delta_days[$i]+$extreme_period_days)+($MinLW)+($MaxLW-$MinLW)/2;
$i++;
}
 
echo "<table border=\"1\"><tr><td>HW</td><td>Wasserstand</td><td>NW</td><td>Wasserstand</td></tr>";
$i=0;
while($i<7)
{
echo "<tr><td>".$HW_event_formated = gmdate("d.m.Y H:i",$HW_event[$i])."</td><td>".number_format($HW_value[$i], 2)."</td><td>".$LW_event_formated = gmdate("d.m.Y H:i",$LW_event[$i])."</td><td>".number_format($LW_value[$i], 2)."</td></tr>";
$i++;
}
echo "</table>";
HW Wasserstand NW Wasserstand
01.01.2014 23:07 7.27 02.01.2014 06:31 0.37
02.01.2014 11:32 7.25 02.01.2014 18:56 0.27
02.01.2014 23:57 7.19 03.01.2014 07:21 0.22
03.01.2014 12:22 7.09 03.01.2014 19:46 0.20
04.01.2014 00:47 6.96 04.01.2014 08:11 0.23
04.01.2014 13:12 6.80 04.01.2014 20:36 0.30
05.01.2014 01:37 6.62 05.01.2014 09:01 0.40

Und liefert mit weniger als 50 Zeilen Code folgende Daten, die im grafischen Vergleich doch relativ gut mit der Realität übereinstimmen:

Ebbe_und_Flut_PHP_Gezeiten_qc3

Das in diesem Tutorial entwickelte Script oder Teile davon können gerne unter Angabe der Quelle verwendet werden. Bitte jedoch immer mit dem Hinweis, dass die berechneten Daten keinesfalls zur Navigation verwendete werden sollten.

Viel Spaß und hoffentlich: Immer eine handbreit Wasser unterm Kiel…

PHP Gezeiten berechnen | PHP Ebbe und Flut berechnen | Teil 4

Weiter geht´s mit der Herausforderung mit “PHP Ebbe und Flut berechnen

Angenommen an unserem Beispielort Dover liegt das höchste mögliche Hochwasser (extreme Wetterverhältnisse, Tornados, Sturmfluten, Tsunamis etc. lassen sich nicht vorhersagen und bleiben ausgeklammert) bei 7.27 m und das niedrigste möglich Niedrigwasser bei 0.20 m. Der maximale Tidenhub (der ja bei Springzeit auftreten sollte) liegt dann bei 7.07 m.

Wir erinnern uns an unsere Extremfaktor-Funktion aus Teil 2:

y=0.44*cos(2pi/14.8961805555x)+1 

X war hierbei der Abstand in Tagen vom beobachteten Extremereignis.

Einige Zeilen PHP Code später, liefert uns unser Gezeiten-Skript eine Tabelle der nächsten 7 Ebbe und Flut (oder Hoch- und Niedrigwasser-) Ereignisse und der zugehörenden Wasserstände:

//Benutzerangaben z. B. via Formular
$max_HW=7.27;
$min_LW=0.2;
//$HW_event_user=01.01.2014 10:42
$HW_event_user_timestamp=gmmktime(23,07,00,01,01,14);
//Aus der Monddatenbank entsprechend des eingegebenen Hochwasserdatums die Periodizität berechnen im Bsp 14.73472 Tage = 1273080 s
$extreme_period_sec=1273080;
$extreme_period_days=$extreme_period_sec/(60*60*24);
//letztes Extremereignis aus der Datenbank auslesen
$last_extreme_event_timestamp=gmmktime(11,14,00,01,01,14);
$pi=3.1415927;
$two_pi=2*$pi;
$delta_seconds=$HW_event_user_timestamp-$last_extreme_event_timestamp;
$delta_days=$delta_seconds/(60*60*24);
$HW_event[]=$HW_event_user_timestamp;
$LW_event[]=$HW_event_user_timestamp+22350;
$HW_delta_days[]=0;
$i=0;
//HW_events, Extremheitsfaktor und Wasserhöhen berechnen
while($i&lt;7)
{
$HW_event[]=$HW_event[$i]+44700;
$HW_delta_days[]=$HW_delta_value=($HW_event[$i]-$last_extreme_event_timestamp)/(60*60*24);
$Extreme_factor_HW[]=$Extreme_value_HW=0.44*COS($two_pi/$extreme_period_days*$HW_delta_value)+1;
$HW_value[]=$max_HW*$Extreme_value_HW/1.44;
$i++;
}
 
$i=0;
while($i&lt;7)
{
$LW_event[]=$LW_event[$i]+44700;
$LW_delta_days[]=$LW_delta_value=($LW_event[$i]-$last_extreme_event_timestamp)/(60*60*24);
$Extreme_factor_LW[]=$Extreme_value_LW=0.44*COS($two_pi/$extreme_period_days*$LW_delta_value)+1;
$LW_value[]=$min_LW*1.44/$Extreme_value_LW;
$i++;
}
 
$i=0; while($i&lt;7) { echo "
"; $i++; } echo "<table border="\&quot;1\&quot;">
<tbody>
<tr>
<td>HW</td>
<td>Wasserstand</td>
<td>NW</td>
<td>Wasserstand</td>
</tr>
<tr>
<td>".$HW_event_formated = gmdate("d.m.Y H:i",$HW_event[$i])."</td>
<td>".number_format($HW_value[$i], 2)."</td>
<td>".$LW_event_formated = gmdate("d.m.Y H:i",$LW_event[$i])."</td>
<td>".number_format($LW_value[$i], 2)."</td>
</tr>
</tbody>
</table>
HW Wasserstand NW Wasserstand
01.01.2014 23:07 7.22 02.01.2014 05:19 0.20
02.01.2014 11:32 7.07 02.01.2014 17:44 0.21
02.01.2014 23:57 6.81 03.01.2014 06:09 0.22
03.01.2014 12:22 6.48 03.01.2014 18:34 0.23
04.01.2014 00:47 6.07 04.01.2014 06:59 0.25
04.01.2014 13:12 5.61 04.01.2014 19:24 0.27
05.01.2014 01:37 5.13 05.01.2014 07:49 0.30

So weit so gut, wir haben ein PHP-Script geschrieben, dass uns Ebbe und Flut Zeiten und zugehörige Wasserstände vorhersagt. Im nächsten Schritt testen wir durch Vergleich mit “echten” Daten, was das Skript bereits taugt und wie wir es weiter verbessern können…

PHP Gezeiten berechnen | Ebbe und Flut per PHP Script | Teil 3

Nachdem wir uns bisher notwendigerweise mit Mondphasen und trigonometrischen Funktionen als Grundlagen beschäftigt haben, heute die Zeiten von Hoch- und Niedrigwasser: Wann kommt die Flut?

Geplant ist z.B. per Formular folgende Parameter an das PHP Skript zu übergeben:

  • Extrem HW
  • Extrem NW
  • Datum (unsere Datenbank ist auf 2014 beschränkt!) und Uhrzeit des letzten beobachteten Hochwassers

Das Skript soll anhand des Datums berechnen, welches Mondextremereignis am nächsten vor diesem Datum liegt (Vollmond oder Neumond) und wie lange der aktuelle Mond-Monat (von diesem Extremereignis zum nächsten) dauert. Von dieser Springzeit aus, berechnen wir einen Vorfaktor der angibt wie gross der Einfluss der Sonne auf die Gezeiten aktuell ist.

Bsp.: Aufgrund der Tatsache, dass es an unserem bisher verwendeten Beispielort (Hamburg) einen Wechsel zwischen Sommer und Winterzeit gibt und Hamburg sich nicht in der GMT Zeitzone befindet, habe ich für die folgenden Berechnungen Dover als Beispielort gewählt, da die dann verfügbaren Vergleichsdaten direkt in GMT vorliegen und keine Umrechnung vorgenommen werden muss.

Die Uhrzeit der vorhergesagten Hochwassers/Niedrigwasser Ereignisse berechnen wir näherungsweise mit unserer Funktion Nr 3:

Angenommen des vom Benutzer eingegebene Hochwasser war 01.01.2014 10:42:00. In Form eines Unix-GMT timestamps also

$timestamp=gmmktime(10, 42, 00, 1, 1, 2014)

Von einem Hochwasser zum nächsten dauert es 0.51736 Tage oder 0.51735d*24h*60min*60s= 44699,904 Sekunden (wir rechnen mit 44700).

Das vom Benutzerzeitpunkt aus gesehene Hochwasser findet also zu folgender Zeit statt:

echo $timestamp=gmmktime(10, 42, 00, 1, 1, 2014)." + 44700 statt:";
$next_HW=$timestamp+44700;
echo $next_HW."
 Also am: ";
echo gmdate("d. M. Y - H:i:s", $next_HW);

1388572920 + 44700 statt:1388617620
Also am: 01. Jan. 2014 – 23:07:00

Wollen wir nun die nächsten 7 Hochwasserereignisse ausgeben geht das mit folgender Schleife:

$timestamp=gmmktime(10, 42, 00, 1, 1, 2014);
$i=1;
$next_HW=$timestamp;
while($i&lt;=7) 
{
$next_HW=$next_HW+44700;
echo $i." | ".$next_HW." | ";
echo gmdate("d. M. Y - H:i:s", $next_HW);
echo "
";
$i++;
}

Was uns die folgende Liste liefert:

1 | 1388617620 | 01. Jan. 2014 – 23:07:00
2 | 1388662320 | 02. Jan. 2014 – 11:32:00
3 | 1388707020 | 02. Jan. 2014 – 23:57:00
4 | 1388751720 | 03. Jan. 2014 – 12:22:00
5 | 1388796420 | 04. Jan. 2014 – 00:47:00
6 | 1388841120 | 04. Jan. 2014 – 13:12:00
7 | 1388885820 | 05. Jan. 2014 – 01:37:00

Die Uhrzeiten der Hochwasserereignisse hätten wir, es folgt analog dazu die Zeit des Niedrigwassers. Näherungsweise gehen wir davon aus, dass zwischen HW und NW immer 44700/2 also 22350 Sekunden liegen.

$timestamp=gmmktime(04, 56, 00, 1, 16, 2014);
$i=1;
$next_LW=$timestamp;
while($i&lt;=7) 
{
$next_LW=$next_LW+22350;
echo $i." | ".$next_LW." | ";
echo gmdate("d. M. Y - H:i:s", $next_LW);
echo "
";
$i++;
}

1 | 1388595270 | 01. Jan. 2014 – 16:54:30
2 | 1388617620 | 01. Jan. 2014 – 23:07:00
3 | 1388639970 | 02. Jan. 2014 – 05:19:30
4 | 1388662320 | 02. Jan. 2014 – 11:32:00
5 | 1388684670 | 02. Jan. 2014 – 17:44:30
6 | 1388707020 | 02. Jan. 2014 – 23:57:00
7 | 1388729370 | 03. Jan. 2014 – 06:09:30

Die Zeitpunkte hätten wir damit. Es fehlt die Berechnung des erwarteten Wasserstands aus den Extremwerten mittels Vorfaktor-Funktion.

Im nächsten Teil kommt es hoffentlich endlich zum “PHP Ebbe und Flut berechnen”.

PHP Gezeiten berechnen | Ebbe und Flut | Teil 2

In Teil 1 haben wir mittels gmmktime() timestamps sämtlicher Mondphasen für 2014 erzeugt und in einer Datenbank abgelegt. Wir nähern uns langsam dem PHP Gezeiten Rechner, auch wenn man dieses Kapitel alternativ mit “Wiederholung trigonometrischer Funktionen” hätte überschreiben können…

Wie man aus unserer Monddatenbank leicht errechnen kann, lagen zwischen dem 1. und 2. Vollmond 2014 genau (!) 2574060 Sekunden (oder 29.7923611111 Tage) also rund 6.28 Stunden mehr als der Mittelwert unserer ersten Näherung.

Dies kann man als trigonometrische Funktion darstellen. Ich habe mich für den Cosinus entschieden.

Man erinnert sich an die Schulzeit y=cos(x). Mit einigen Modifikationen was Amplitude und Frequenz angeht landen wir bei:

1) y=0.5*cos(2pi/29.7923611111x)+0.5

cos_mondphasen

x ist hierbei die Anzahl der Tage seit dem letzen Vollmond, wenn x=14 ist, ist gerade Neumond, bei x=7 befinden wir uns im „letzten Viertel“ etc.

Wir brauchen noch weitere periodische Funktionen, mit deren Hilfe unser PHP-Script dann später die Berechnung von Ebbe und Flut vornehmen kann. Beim BSH erfährt man, dass zwischen 2 Hochwassern im Durchschnitt (Achtung Näherung!) 12h und 25 min liegen. Das entspricht 0.51736 Tagen. Wir brauchen also eine Funktion die mit einer Periodizität von eben diesen 0.51736 Tagen oszilliert (von einem (Funktions-)Wellenberg zum nächsten soll es also nicht 2pi sondern 0.51736 dauern).

y=cos(2pi/0.51736x)

Diese Funktion hat die gewünschte Periodizität, die Amplitude beträgt jedoch 1. Angenommen das letzte Hochwasser lag bei 5 Metern und das letzte Niedrigwasser bei 1 Meter, dann bräuchten wir eine Funktion, die um den Mittelwert 3 Meter oszilliert und im oberen Extremfall den Wert 5, im unteren Extremfall den Wert 1 zurück liefert:

y=2*cos(2pi/0.51736x)+1+2

Diese Funktion schwankt mit der gewünschten Periodizität und Amplitude:

cos_tidenhub

Verallgemeinert kann man schreiben:

2) y=(HW-NW)/2*cos(2pi/0.51736x)+1+(HW-NW)/2

Hier ist x Anzahl Tage seit dem letzten Hochwasser, wenn seither 0.51736 Tage vergangen sind, gibt es wieder einen neuen Wellenberg (nächstes Hochwasser). Wenn seither nur 0.25868 Tage vergangen sind haben wir gerade Niedrigwasser…

Die letzte periodische Funktion die wir brauchen, berücksichtigt den Einfluss der Sonne. Stehen Sonne, Erde und Mond in einer Linie (also immer bei Vollmond und Neumond) sind die Gezeiten besonders stark ausgeprägt (der Seemann spricht von Springzeit). Stehen Sonne und Mond von der Erde aus betrachtet im rechten Winkel zueinander, sind die Gezeiten relativ schwach (der Wassersportler spricht von Nippzeit), da der Einfluss der Sonne dem (stärkeren) Einfluss des Mondes entgegen wirkt.

Angenommen wir werten den Einfluss des Mondes auf die Gezeiten mit 100 Punkten. Der Einfluss der Sonne beträgt (Achtung Näherung!) 44% des Einflusses des Mondes, wird also mit 44 Punkten bewertet. Ziehen Sonne und Mond nun also am gleichen Strang (verstärken sich also) erhalten wir einen Gesamteffekt von 144 Punkten. Stehen Sonne und Mond im rechten Winkel zueinander muss die Wirkung der Sonne von der Wirkung des Mondes abgezogen werden. Der Gesamteffekt beträgt dann 100-44=56 Punkte. Wir brauchen also eine Funktion. die zwischen 1.44 und 0.56 oszilliert:

y=(1.44-0.56)/2*cos(2pi/x)+0.56+(1.44-0.56)/2

Wir brauchen eine Periodizität von 29.7923611111/2 also 14.8961805555 Tagen

y=(1.44-0.56)/2*cos(2pi/14.8961805555x)+0.56+(1.44-0.56)/2

Da sich die Werte 1.44 und 0.56 als genäherte Naturkonstanten nicht ändern, können wir vereinfachen:

3) y=0.44*cos(2pi/14.8961805555x)+1 

cos_zusammenspiel_sonne_und_mond

Hier ist x der Tag nach dem letzten extremen Mondereignis, also 3 wenn gerade 3 Tage nach Neumond ist oder 6 wenn 6 Tage nach Vollmond ist.

Wir haben also nun 3 trigonometrische Funktionen die die Gezeitenphänomene näherungsweise beschreiben.

Im nächsten Kapitel basteln wir aus diesen Funktionen ein PHP Skript, dass uns die Rechenarbeit abnimmt. Mein Plan ist dem Skript als Benutzereingabe folgende Daten zu liefern (z.B. über ein Formular):

  • Datum, Uhrzeit des letzten Hoch- und Niedrigwassers
  • Extrem Hoch und Niedrigwasserdaten

Anhand dieser Angaben soll das Skript zunächst (durch Vergleich mit unserer „Vollmond-Datenbank“) ermitteln, in welcher Mondphase diese Daten zustande kamen und anschliessend Wasserstände und Uhrzeiten der nächsten Ebbe und Flut berechnen.