Rework me on GitHub   
In memory of our beloved Pünktchen (2009-2015)

scharfsinniges vermuten

root (Edward Gerhold)

Letztes Jahr bereits habe ich die ersten Bücher über stochastische Integrale und stochastische Differentialgleichungen gelesen.

Daß ich die nicht verstanden hatte, das habe ich jetzt gelernt. Allerdings konnte ich den Büchern dennoch logisch folgen,was sich jetzt bezahlt macht.

Ich habe mit der Wahrscheinlichkeitsrechnung von ganz von vorne begonnen. 2014 bereits las ich nachdem ich mein erstes Calculus (Infinitesimalrechnung) bekam,

mein erstes Buch über Statistik, den Complete Idiots Guide. Dessen Übungsaufgaben (leicht) ich damals alle machten. Letztes Jahr über habe ich aber persönlich

für interessant befunden hauptsächlich mehrdimensionale multivariate Analysis, gewöhnliche und partielle Differentialgleichungen, Lineare Algebra und Funktionalanalysis geübt,

sowie einhundert oder mehr interessante Skripten und Bücher zu einzelnen Themen gelesen.

Die Stochastik zu wiederholen, hatte ich vor, bin aber noch nicht dazu gekommen. Diesen Monat sieht es anders aus, während ich mein gerade intensiviertes von vorne begonnenes Physikstudium (relativistisch und nichtrelativistisch und querschnittlich durch die theoretische Physik) unterbrochen habe, und die eine oder andere Herleitung wieder vergesse, ich mache Stochastik mit Vorliebe für das Mitrechnen, da ich das für nochmal dreissig Jahre Arbeit gebrauchen kann.

Lange Rede, kurzer Sinn. Ich verstehe nun Omega, w das Ergebnis, A das Ereignis, a_k den k-ten Treffer, kann aus der Statistik die wichtigens Lagemaße, wodurch ich allerhand Berechnungen anstellen kann, die mich zur Konvergenz in der Stochastik sowie den Gesetzen der Großen Zahlen sowie dem Zentralen Grenzwertsatz geführt haben, ich pauke die zur Zeit ein. Ich habe nicht nur auf einmal die Binomialverteilung und die Bernoulli-Kette verstanden, nein, auch die Bionomial- und Multinomialkoeffizienten im Einsatz als Koeffizient in der Verteilungsfunktion zur Zufallsvariable X. Ich glaube, alles zu wiederholen sprengt einfach den Umfang meines Posts.

Ich habe Riesenspass mit der richtigen Stochastik, nicht nur daß ich allerhand Spiele, wie Würfeln, Karten, Tür öffnen, mitgemacht habe, oder mir die Urnen- und Fächermodelle neu beigebracht habe, sondern auch ihre Wahrscheinichkeiten und ihre Verteilungen neu gelernt. So kenne ich nicht mehr nur die Dichtefunktion der Normalverteilung, die ich in Polarkoordinaten leichert ausrechnen  kann. Ich habe auch die charakteristischen Funktionen (zum Beispiel Potzenzreihen, Exponentialfunktionen), welche die Verteilungen erzeugen kennen gelernt. So könnte ich nun also selbst Verteilungsfunktionen schreiben. Das was ich natürlich noch richtig üben muss, denn mitrechnen und verstehen und praktisch anwenden ist noch nicht eingeübt sein. So kenne ich natürlich nun die bedingte Wahrscheinlichkeit, aber auch den bedingten Erwartungswert (von dem ich schon im Vorjahr las, als ich versuchte Ito´s Analysis zu verstehen), aber auch verschiedene Verteilungen und ihre Dichten, aber auch die Quantilfunktion. Interssanter ist mein wieder mal verbesserter Umgang mit Mengen. So habe ich schon zu Beginn mit aufsteigenden oder absteigenden Folgen gearbeiten. Nun sind mir ausser der korrekten Überdeckung und dem Vorrechnen mit Epsilon und Delta, auch die Produktformeln bei stochastischer Unabhängigkeit bekannt, wie auch die Umformung des Mü-Integrals, mit dem die Erwartungswerte (statistische Mittel) leicht berechnet werden, oder das verwenden des Dirac-Maßes, was natürlich wie die Dirac-Funktion nur auf die angegebene Variabel reagiert. Dabei konnte ich auch beweisen, Integrale nach Lambda (Lebesgue Maße) zu integrieren. Aber auch mit anderen Maßen, als dem alten Differential wie ich es mir zuerst beibrachte durch die Schulanalysis-Bücher. Auch in der Stochastik ist die charakteristische Indikatorfunktion sehr nützlich und leicht zu integrieren. Zum Beispiel ist das Integral über eine Teilmenge von Omega mit f=Indikator der Teilmenge nichts anderes als das Maß der Teilmenge und der Erwartungswert vom Indikator ist die Wahrscheinlicheit P(der Teilmenge). Man setze Mü=P (ist erlaubt) und spiele. Übrigens kann ich jetzt Sigma-Algebren, Erzeuger und Erzeugendensysteme, Borelmengen, Schnitte und Vereinigungen und viele andere Einzelheiten anwenden. Und das beste ist, ich werde noch besser darin. Ich bin jetzt bereits oder erst dabei, die Themen zu vertiefen, wie auch die Grenzwertsätze und deren Anwendungen. Alles in allem ein paar tolle Tage mit der Stochastik und ich habe meine ersten Schätzer im Konfidenzintervall geübt und die Lösung der kleinsten Quadrate über den Korrelationskoeffizienten gebildet. Und das ist noch nicht alles. Ich bin gerade erst am Anfang der Sache, auch wenn die fast ein Jahr auf dem Plan stand und nicht abgearbeitet werden konnte. Darum lasse ich die partiellen Differentialgleichungen und meine neue Liebe zur Physik ebenso eine Weile an der Seite, auf daß ich auch andererseits danach was mit statistischer Physik anfangen kann, und nicht nur die Wahrscheinlichkeitsdichte (Dichtefunktion) der Quantenmechanik integrieren kann (wie vorher). Ich weiss wie man Zufallszahlen standardisiert (X-EX)*(V(X)^-1/2) =: X~ oder daß die Gesetze großer Zahlen mit den relativen Häufigkeiten und partiellen Summen zu tun haben. Und noch mehr und genauer.

Es gibt noch viel zu lernen für mich. Was eine Stoppzeit ist, eine Filtration, oder was adaptiert heisst, habe ich auch bereits begriffen und gelernt. Und ich denke mal, auch wenn ich jetzt nicht mehr aufzähle, was ich alles interessantes gefunden habe, welche Verteilungen es gibt und welche Eigenschaften die oder Maße haben mussen, und wie die Prozesse wie die Markovkette (statt Würfeln in n maliger unabhängiger Wiederholung unter gleichen Bedingungen) funktionieren

Es reicht erstmal. Achja, es gibt auch viel zu programmieren darunter, abgesehen von der Monte Carlo Integration oder allen diskreten Modellen.

Bis demnächst...

Defekter Computer

root (Edward Gerhold)

linux-dww5:~ # date
Sun Mar 13 18:12:18 CET 2016
linux-dww5:~ # uptime
 18:12pm  up 30 days 20:43,  23 users,  load average: 0.15, 0.07, 0.06
linux-dww5:~ #


Weil der Computer kaputt ist, und nicht mehr angeht, wenn er ausgemacht wird, habe ich ihn laufen lassen. So konnte ich an meiner Mathearbeit arbeiten und an einem Dutzend nützlicher Klassen, sowie noch einem Dutzend didaktisch notwendigem Experimentiercode. Irgendwas ist mit der Temparatursteuerung nicht mehr in Ordnung und ich habe es bislang nicht geschafft, ihn in die Reparatur zu geben.

Determinante rekursiv

root (Edward Gerhold)

Das Summieren einer Determinante einer nxn Matrize erfordert n! Determinanten aus n! Matrizen auszurechnen. Man streicht eine Reihe und eine Spalte, nimmt die Zahl im Kreuz der beiden Abgestrichenen, und aus den verbleibenden Zahlen formt man eine Minor-Matrix. Eine 4x4 Matrize zerfällt in vier 3x3 Matrizen, die in je drei 2x2 Matrizen zerfallen, deren einzahlige Unterdeterminanten nur mit ihrem Koeffizenten multipliziert werden und mit (-1)^i+j eben addiert oder subtrahiert. Wenn der Algorithmus zurückkehrt, wird alles summiert. Das kann man durch entlanglaufen einer Spalte, oder einer Zeile machen. Aufgrund der Matrixordnung im WebGL habe ich die column major Ordnung verwendet, wo die Spalten nebeneinander liegen. Mehr zum Code, dem Algorithmus für den Index, und die Tatsache, daß es keine Bildschirmseite, sondern eine Hand voll Zeilen sind, später, denn ich arbeite gerade (oder nachher, oder morgen) an den Funktionen. Ich denke mal, daß ich so mein Exteriorprodukt dann auch generell auf dem Computer rechnen kann. Und bin froh, die Formel so noch lebendiger im Kopf zu halten, wie ich sie vorher nicht hielt. Ich habs mit handgerechneten Determinanten und Minoren verglichen, es stimmt alles.

2-D -> 3-D Rekonstruktion

root (Edward Gerhold)

Im Spezialfall für den f(x,y,z)=(x,y,z) oder f(x,y)=z Plotter kann man die 3-D rekonstruieren. Wenn man die x oder y Achse zum Beispiel in gleichen Abständen durchläuft, und die delta-Breite kennt, kann man sicher wissen, welche Zahl da dran kommt, dann kann man den Anteil vom 2-D (x,y) abziehen und die neue Gleichung mit zwei Unbekannten korrekt auflösen. So ist es möglich im Fall, daß man wenigstens eine Variable kennt, das ansonsten unlösbare unterbestimmte 2x3 Gleichungssystem als 2x2 System aufzulösen. Bei Plottern, die Punkte in gleichen Abständen nehmen, ist es zum Beispiel möglich, einen gezeichneten Graphen wieder in die Originalpunkte zu verwandeln. Richtige 3-D Rekonstruktion hat natürlich richtige Anwendungen in der realen Welt. Was meinen 2x3 Abbildungssatz betrifft, finde ich, jede Investigation ist es Wert, die Eigenschaften und Möglichkeiten der Abbildungsmatrix (ein kompakter, linearer, surjektiver mxn Operator mit m<n, ohne Inverse, desen Produkt mit der adjungierten, reell transponierten, symmetrisch und da reell sogar selbstadjungiert ist, der mit 2x2 und 3x3 multipliziert die Abbildung oder die Eingabe anpassen kann) zu vervollständigen.

Zerlegung der Eins

root (Edward Gerhold)

Heute habe ich mir Gedanken über die Zerlegung der 1 gemacht. Meine Idee war, sie in eine Reihe von Brüchen zu zerlegen, die monoton wachsen. Ich habe eine Form gefunden, sie in beliebig viele Brüche zu zerlegen. Also in n=3 zerlegt ist das 1/6 + 2/6 + 3/6. Zum Beispiel. Der Trick geht so: Ich nehme die Anzahl der gewünschten Brüche, n, und summiere k von 1 bis n. Wie man weiss, ist die Summe aller k von k=1 bis k=n das selbe wie (n*(n+1))/2. Diese Summe ist somit unser Nenner für unsere zweite Reihe. Die Erste ist die Summe aller k von 1 bis n oder n(n+1)/2, im folgenden N (für Nenner) genannt. Die zweite Reihe lautet einfach Summe k/N von k=1 bis k=n und ist die Zerlegung der Eins.

Danach habe ich überlegt, wie ich eine beliebige Zahl zerlege. Und mit stolpern über die richtige Lösung und, da ich ja nicht mit Zahlen sondern nur geistig und mit mir redend probierte, mehreren Versuchen, eine Form zu finden, bin ich dann drauf gekommen. Nehmen wir an, wir zerlegen die Zahl 17. Dann ist die Summe des Nenners für die zerlegte 1 ja 17(18)/2 = 153. Um den Nenner zu korrigieren, teile ich N=153 nun durch die gewünschte Zahl 17. Heraus kommt 9. Somit ist unsere Reihe 1/9 + 2/9 + 3/9 + ... + 17/9 = 17. Ich kann sie aber auch durch mehr Brüche zerlegen. Vervierfachendes Beispiel. Wir summieren 4*17 = 68 (um die 17 zu zerlegen), die Summe ist 68(69)/2 = N = 2346, N/17 = 138 = Q und unsere Folge (k/Q)k=1...17 ist 1/138, 2/138, ... 68/138 und unsere Summe ist 17. Anstelle wie bei der zerlegten Eins ist noch der Nenner durch die zu zerlegende Zahl zu teilen. Dadurch das wir sie oder ihr vielfaches für den Nenner summiert haben, scheint/ist die Teilung des Nenners durch unsere Zahl immer möglich, da sie immer ein Faktor in n(n+1)/2 ist, da n=x*Z (Anzahl der Brüche pro Einheit unserer Zahl mal unserer Zahl). Beim Überlegen wusste ich noch nicht, daß diese Anpassung des Nenners sicher ist.

So habe ich dann heute noch die Zerlegung der 1 in eine Folge mit aufsteigenden ganzzahligen Zählern mit ganzzahligem Nenner, der die gesamte Summe der Zähler ist, um summiert 1 zu ergeben. Sowie den Fall für die Zerlegung einer beliebigen positiven ganzen Zahl auf eine allgemeine Form gebracht. Das setze ich mir noch als eine oder zwei Din-A4 Seiten mit LaTeX für meine Sammlung.

Hat Spass gemacht, die Lösung zu suchen.

 

--- Samstag, 21.11.15

Update: Das war natürlich nicht korrekt oder komplett. Es funktioniert mit der 1 und mit ungeraden (!) Zahlen wie gesagt. Bei geraden Zahlen hat man eine x,5 Zahl im Nenner. Wenn man mit 2/2 erweitert hat man die Reihe 2/2N + 4/2N, was dann zwar Integer ist, aber nicht die Zählerreihe 1,2,3,4,5,...,n die gesucht war. Intuitiv habe ich dann n+(n-1) eingesetzt. Mit 2n-1 geht jede gerade Zahl dann zu zerlegen. Ich zeig´s mal algebraisch.

Also wenn wir k von 1..2n-1 summieren, haben wir (2n-1)(2n-1+1)/2 = 2n(2n-1)/2 = n(2n-1). Das ist die Summe der monoton wachsenden Zähler von 1..2n-1. Wir müssen noch durch n (gesuchte Zahl) teilen, so bleibt N=2n-1. Das ist möglicherweise der kleinste sinnvolle Nenner um beliebige gerade Zahlen in monoton wachsende Brüche (1/N + 2/N + 3/N + ... + n/N, hier ...+2n-1/N) zu zerlegen. Summieren wir jetzt ((2n-1)(2n)/2) / (2n-1) kommt raus 2n/2 = n. Unsere gesuchte Zahl, die zu zerlegen war.

Also es gibt jetzt drei Fälle für mich, wobei der erste Fall die zerlegte 1 ist. Der zweite Fall ist ungerade Zahlen zu zerlegen, wie zuerst beschrieben. Der dritte Fall, gerade Zahlen brauchen spezielle Behandlung, kam heute hinzu, beim nachprüfen, als ich das setzen wollte. Dabei kam raus, nochmal für gerade Zahlen zu überdenken. Das habe ich gemacht. Intuitiv war anstatt bis n (gesuchte Zahl) zu summieren bis n+(n-1) = 2n-1. Und die Summe durch n zu teilen. Der N = 2n-1 ist allgemein für gerade Zahlen. Und die Summe aller k von 1..2n-1 geteilt durch 2n-1 ist = n, was unsere zu zerlegende Zahl ist.  QED. #

Ein vierter Fall ist oben auch angesprochen. Beliebige (skalierbare) Anzahl monoton wachsender Brüche 1/N,...,n/N,n+1/N,n+2/N,...,n+m/N um die Zahl zu zerlegen. Eine 1 kann man ohne Sorge in n(n+1)/2 Brüche zerlegen mit dem Nenner n(n+1)/2.Die Folge ist (k/[n(n+1)/2])k=1...n. Die Reihe ihre Summe und gleich der zu zerlegenden Zahl.  Bei ungeraden Zahlen, da hat man den Nenner N=(n+1)/2, da man noch durch n (die zu zerlegende Zahl) teilen muss, damit die Summanden ein n-faches des vollen Zählers zum Nenner ergeben. Also der skalierbare Fall 4, vergroesserbare Anzahl der Summanden (also der Brüche), wie bei der Zerlegung der 1 ganz direkt möglich (indem man einfach ein n wählt), kommt morgen nochmal dran.

Mein erstes Papier dazu berücksichtigt die geraden Zahlen noch nicht, das kam erst durch das Setzen. Jetzt muss ich das nochmal formulieren, hehe.

Was übrigens auffällt. Der letzte Summand ist 2n-1/2n-1  = 1. Die letzte Zahl in der Reihe, das schwerste Gewicht, ist gleich 1/1.

 

Update 2: Zusammenfassend ist die Zerlegung der Eins das sinnvollste, der Einsatz als Gewicht (z.B. Masse) einzelner Glieder ist auf die genaue Anzahl der Glieder abstimmbar. Man kann auch zehn Zehntel nehmen und die individuell auf n <= 10 Zahlen verteilen. Die nicht mehr einwandfreie Skalierbarkeit bei einer geraden Zahl, macht den Erfolg bei ungeraden Zahlen ganzzahlige Nenner wie (n+1)/2 zu erhalten, der übrigens noch kleiner Z ist (d.h. mehr als ein Bruch ist unecht/gemischt und groesser als 1/1), beinah kaputt, da die Zerlegung unbrauchbar wäre, wäre da nicht der Kompromiss 2k/2N zu summieren, ist die Zahl gerade. Darum ist meine Empfehlung die Eins, in n Brüche zerlegt, als Faktor zu nehmen, vielleicht diese noch zu skalieren.

Eine Anwendung auf die 'GM-AM Ungleichung mit gebrochenen Gewichten' mit [(Summe k=1,n p_k)  = 1] bringt übrigens Erfolg. Sie wird von [(Produkt k=1,n a_k^p_k) <= (Summe k=1,n p_k*a_k)] zu [(Produkt k=1,n a_k^k)^1/N <= 1/N(Summe k=1,n k*a_k)].

Eine Fortsetzung der Idee ist, zum Beispiel nichtlineare Zaehler k^2, k^3 und ihre Summen (2n+1)(n+1)n/6 und (n(n+1)/2)^2 einzusetzen. Und weitere Formeln mit Gewichten auszuprobieren. Ebenso Ungleichungen mit konjugierten Exponenten. Und verwandtes.

 

Limespaper

root (Edward Gerhold)

Ich hab noch was besseres, worauf sich viele freuen werden, das mal durch zu nehmen. "How to calculate limits". In dem Paper berechne ich Differentialquotienten, Integrale, Folgen, Reihen in Grenzwertform. Gestern habe ich damit begonnen und bislang Potenzregel, Produktregel, Quotientenregel und Kettenregel ausgerechnet und gesetzt, aber das geht natürlich weiter. Und wenn ich genug Beispiele gerechnet und Tricks vorgestellt habe, dann poste ich es auch. Und wie ich gesehen habe, kann man diese Dinge im Internet sogar sharen. Mein Koordinatensystem wird auch irgendwann neu verfasst sein, wie angekündigt. Bis dahin, viel Spass beim selbst rechnen, weil´s Spass macht :-)

Update:

Limes von Funktionen. Algebraisch umformen, wie in der Schule, daß man z.B. bei x->0 (x gegen 0) dafür sorgt, daß die 0 nicht im Nenner allein steht. Bei 0/0 oder infty/infty mit L´Hopital und dem Limes der Ableitungen probieren.

Limes von Ableitungen per Differentialquotient. Dafür sorgen, daß man h/h erhält und kürzen kann, oder Summanden auf dem gleichen Hauptnenner trennen, um einzelne Brüche gegen 0 im Zähler laufen zu lassen. Alles ist erlaubt, Ausklammern, Vereinfachen, Erweitern, neu Zusammenfassen, wieder ausmultiplizieren. Bis man die günstigste Form erhält, um den DQ gegen 0 gehen zu lassen. Die Terme die bleiben sind die Ableitung. Kann sein, daß sich das von der generalisierten Ableitung unterscheidet, daß man die einzelnen Teile wie f'(g(x))*g'(x) nicht mehr erkennt, und alles eine Form ergibt wie 2a^2x statt 2ax * a für f(x)=x^2 und g(x)=a.

Limes von Integralen. n-> unendlich. Man schreibt die endliche Summe hinter den Limes von i=1 bis n und rechnet f(x_j)*delta_X_j mit x_j = a+(j-1)delta_X_j und delta_X_j = delta_X = (b-a)/n. Dann rechnet man die Summe nach und nach aus. Durch ausmultiplizieren und aufteilen in einzelne Teile, kann man die einzelnen Summen durch bekannte und geschlossene Formen ersetzen. Zum Beispiel ist die Summe von allen i auch als Gaussformel bekannt und ergibt n(n+1)/2. Die Summe von (i-1) ergibt n(n-1)/2, was man rauskriegt, wenn man in n(n+1)/2 dann (n-1)((n-1)+1)/2 einsetzt und vereinfacht.

Limes von Folgen. Man schreibt die Folge hinter das limes gegen unendlich und vereinfacht die Formel algebraisch solange, bis man sie sicher gegen unendlich schicken kann. Wenn die divergiert kommt eh unendlich raus, ist klar. Und für konvergente Folgen, oder lim = 0 (Nullfolge) sollte man Brüche auf Brüchen finden, z.B. (1+1/n)/2 ist wenn n->unendlich dann 1+0/2 = 1/2.

-Geht n gegen 0, sollte man die 0 im Nenner vermeiden, da null kein Teiler ist.

-Geht n gegen unendlich, sollte man die unendlich in den Nenner bringen, weil der Bruch dann 0 wird (1/infty = 0, aber auch (1/infty)/10 = 0). Man sollte versuchen alles voneinander zu isolieren, um Zahlen zu behalten.

Grenzwert von Reihen. Wie bei den Integralen schreibt man die Summe hin und zieht alle Konstanten aus der Sigma-Form und versucht die verbleibenden Glieder durch einfache Summen zu ersetzen. Viele Reihen kann man nicht richtig ausrechnen und nur abschätzen, wofür es die bekannten Konvergenzkriterien gibt. Damit kann man die Glieder vergleichen, oder auch schauen, ob man unter bekannten konvergenten Reihen liegt, oder über divergenten Reihen. Reihen sind schwierig in geschlossene Form zu bringen.

Limes von Integralen. Integrale bringen dann lange Polynome, die man ausmultiplizieren und zusammenfassen muss. Bei Integralen, die man aufleiten kann, sollte nach Zusammenfassen der Terme die bekannte Formel stehen bleiben. Für delta X (b-a)/n ist der Binomialkoeffizient wichtig, da man bereits beim Integral von alpha*x = alpha*Integral von x ((b-a)n)^2 findet und sich das natürlich vermehrt. Die werden richtig haarig, was man der generalisierten Form des Aufleitens nicht ansieht.

Limes von Riemann-Stieltjes (t)dg(t), man multipliziert f(t) nicht mit (b-a)/n (delta t), sondern mit (g(t_i)-g(t_i-1)) und nimmt der Grenzwert der gesamten Formel. Natürlich wird das noch haariger, als nach dx, nach dg(x), weil noch mehr Formel einfliesst.  Limes von Funktionenfolgen ist mit Folgenlimes bereits klar. Die korrekte Neuformulierung meines Wissens über L^p Konvergenz und das Lebesguesche Integral ist ein der nächsten Aufgaben für mich. t_i ist jetzt natürlich auch a+(t-1)(b-a)/n sofern [a,b] der Integrationsbereich ist.

Ich habe da also zwei Hauptmethoden ausgemacht, beim Integral das Herausziehen von allen Konstanten ausser dem Zähler der Summe. Der wird z.B. bei Summe (i-1) mit n(n-1) ersetzt, usw. Wenn alle Glieder sicher gegen unendlich gehen können, also am besten das n im Nenner ist, da x/unendlich = null ist, und wir damit nur ein n und dessen Term streichen können. Und die andere ist, beim Differentialquotienten muss man die 0 aus dem Nenner rauskriegen, also das n oder h in denn Zähler bringen oder die Terme so spalten, daß nicht gleich alles gegen null geht.

Fakt ist, alles, Ausmultiplizieren, Erweitern, Kürzen, Vereinfachen, Zusammenfassen, mit Identischen Formen anderer Art ersetzen (1 mit sin^2 x+cos^2 x z.B.), all das hilft, die Polstellen und Undefinierte zu eliminieren. Ist aber keine Garantie, daß das geht. Denn es gibt genug divergente Reihen, deren Limes unendlich ist, genug Funktionen und Folgen, die hier und da nicht differenziert werden, oder keine Nullfolge sind. Es ist halt wichtig, zu wissen, wann das der Fall ist.

All das steht so nicht im Paper. Aber ich hatte hier diesen Artikel kommentiert, und das ist eine schnelle Neufassung meines Kommentars. Viel Vergnügen beim selbst lösen.

Deutsche Version

root (Edward Gerhold)

Deutsche Version kurz mit ein paar Passagen upgedatet.

Vektorwertiges Skalarprodukt

root (Edward Gerhold)

Aufgrund meiner Formel für eine lineare Abbildung auf eine Fläche mit drei Koordinaten, lag es nahe, zu versuchen, ein vektorwertiges Skalarprodukt zu definieren, was den R^3 Vektor mit einem (R^2)^3 (=R^2x3) zu multiplizieren und die Komponentenprodukte zu summieren. Das Problem ist, man muss einen Vektor aus den ersten Komponenten der mehreren Vektoren, die man gleichzeitig dotten will, machen, einen aus den zweiten, einen aus den dritten, usw. Die 2x3 Matrix erledigt das auf natürliche Weise, indem die Vektoren zu Zeilenvektoren werden. Damit war die Definition dann an der Unbequemlichkeit, die Vektoren aufzuspalten und per Komponentenindex zu gruppieren, gescheitert, mit Vermerk, dass auf natürliche Weise das Matrixprodukt exakt die Aufgabe erledigt. Eine vollständige Beschreibung des Vorgangs im neuen Dokument, für das ich das definieren wollte. So habe ich allerdings auch eine vernünftige Erklärung zu meinem Fund.

SVD bei Wolfram

root (Edward Gerhold)

Ich hatte bereits geahnt, daß die trigonometrische Version mit drei Achsen aufwändig zu berechnen ist. Wolfram Alpha zeigt, die SVD passt nicht mehr auf eine Seite.

https://www.wolframalpha.com/input/?i=SVD+{{cos%28a%29%2Ccos%28b%29%2Ccos%28c%29}%2C{sin%28a%29%2Csin%28b%29%2Csin%28c%29}}

Etwas einfacher sind die links- und rechtshändigen Koordinatensysteme mit 45 bzw. 225 Grad Achse eingebettet in der orthonormalen R^2 Basis.

https://www.wolframalpha.com/input/?i=SVD+{{1%2C0%2Csqrt%280.5%29}%2C{0%2C1%2Csqrt%280.5%29}} ist die LHS Basis mit z auf 45 Grad, x auf 0 und y auf 90 Grad.

https://www.wolframalpha.com/input/?i=SVD+{{-sqrt%280.5%29%2C1%2C0}%2C{-sqrt%280.5%29%2C0%2C1}} ist die RHS Basis mit x auf 225 Grad und y 0 und z 90 Grad.

Sphäre zeichnen

root (Edward Gerhold)

Abb 1. Eine Sphäre mit createSphere erzeugt und nach transform2dAll von Punkt zu Punkt, Ring für Ring verbunden. Das sind jeweils Ringe aus einfachen Kreisen entlang jeder Achse, den Radius erhält man mit Sinus auf der Achskoordinate welche ein Kosinus wäre.

Ich hatte noch nicht ausprobiert, eine Kugel aus Ringen zu zeichnen. Um die Abbildung auf 2-D Koordinaten vorzunehmen, habe ich die 3-D Koordinaten mit meiner Gerhold-Formel umgewandelt. Die Summe, aus den drei Produkten je einer Koordinate mit je einem 2-D Achsvektor, ergibt einen neuen 2-D Ortsvektor, den richtigen Punkt im, durch ausrichten der drei Achsen gewählten, 3-D Koordinatensystem auf der Fläche, wörtlich Σxiei, wobei x ein R^3 Vektor und e ein Vektor aus drei R^2 Vektoren ist.

Mir kam die Idee, daß ich das und andere geometrischen Modelle alle noch nicht vorgestellt habe. Inzwischen habe ich mir ein paar Gedanken dazu gemacht, denn ich habe das Dokument, was ich vier Wochen entusiastisch entwarf und entwickelte als veraltet deklariert. Aber nicht, um es aufzugeben. Das neue Dokument ist kürzer, prägnanter, die zu angefangenen oder zu korrigierenden Rechnungen werde ich vorlegen, und am Schwierigkeitsgrad werde ich auch was gedreht haben. Es wird sehr interessant, denn ich definiere die Fläche mit den drei Koordinaten. Die R^2x3 Ebene. Ich finde, man kann leicht glauben, daß die lineare Algebra das alles abdeckt.Das Koordinatensystem passt zwar in die Spalten der 2x3 Matrix und bietet eine surjektive, nicht invertierbare lineare Abbildung von 3-D auf 2-D. Allerdings ist es nicht so geläufig. Und ich habe Ableitungen und Integrale einer linearen Funktion entwickelt, welche exakt die selbe lineare Abbildung vornehmen. Ich hatte mir vor einer Weile Grundlagen in Vektoranalysis angeeignet und konnte diese hier prima ausnutzen, um die Funktion zu erforschen. Die Funktion stelle ich ebenso vor wie einige Alternativen, Schlussfolgerungen sowie eine Verallgemeinerung bestimmter linearer Abbildungen.

Abb. 2 Die Sphäre mit Kugelkoordinaten erzeugt und einmal den ersten Winkel festgehalten und einmal den zweiten Winkel, um die einzelnen Ringe einmal zu durchlaufen. Es ist wohl nicht der richtige Algorithmus. Sphären in Matheskripten sehen anders aus. Nächstesmal dann.

 

Wer richtig hinschaut kann am unteren Bildbereich sehen, daß mit den Kugelkoordinaten ein Fehler auftritt. Sollte ich x,y,z tauschen, sieht man keinen Fehler. Allerdings sonst keinen grossartigen Unterschied. Man kriegt durch bewegen des Nordpols nach oben nicht den Sphärenflair aus den Abbildungen aus Mathebüchern mit. Hier ist vielleicht der Algorithmus falsch.

Die Fläche mit den drei Koordinaten hat eine Basis, die am Kreis ausgerichtet wird. Es sind drei Achsen. Drei einheitslange Ortsvektoren die am Kreis ausgerichtet werden. Eine Basis ist linear unabhängig? Ich sage, die Linearkombination bleibt. Für die Fläche mit den drei Koordinaten ist die Achse unverzichtbar. Die lineare Abbildung, die mit den drei Achsen entsteht, ist eine korrekte orthogonale Projektion, kompakt und stetig.

Eine Schreibweise mit drei Koordinaten ist auch möglich. Durch Einsatz der gewohnten xi+yj+zk Notation, kann man, wobei i,j,k nun 2-D Vektoren sind, die Summe mit drei Koordinaten in ihrer Grundform darstellen. Das Ergebnis der Summe ist ein 2-D Punkt, in Vektorschreibweise, dadurch, daß anstelle der 3x3 Basis eine 2x3 Basis eingesetzt wurde. Das ist ein fantastisches Werkzeug in Verbindung mit Funktionen, welche diese Notation nutzen, finde ich.

z entlang einem Vektor

root (Edward Gerhold)

Die einfachste Projektion von x,y,z ist wohl die hier [x,y] + z*[cos(wz), sin(wz)] = [x+zcos(wz), y+zsin(wz)]. Ob wenigstens diese Form unterrichtet wird, kann ich auch nicht sagen. Wenn man jetzt das xy Koordinatensystem nimmt und einen Vektor für die z-Achse mit dem Winkel wz, dann kann man so den Punkt entlang der z-Achse verschieben. Meine Projektion macht alle drei Achsen beliebig drehbar und ich halte auch an dem Dokument fest, was dringend überarbeitet werden muss, weil ich soviele Sachen eintrug und weniger Zeit aufbrachte als ich brauchte. Heute abends geht´s ein paar Takte weiter, jetzt erstmal wieder raus. Aber [x,y]+z*[r*cos(wz),r*sin(wz)] sollte eine dritte Achse und ein korrektes Bild bringen.

[x,y,z]=f(t) plotter mit Cheap 3-D Technik

root (Edward Gerhold)

Vorhin habe ich ein neues File eingegeben, um mir mal die f(t) anzuzeigen. implement.html. Es ist gleichzeitig ein Demo für implement.js, einer Demo Implementierung des Transformationsalgorithmus, den ich fleißig und nachhaltig in gerhold-3dto2d.pdf zu einem richtigen Satz ausarbeite.

Wenn man im implement.html im ersten Input Field, durch Kommata getrennt, drei Array Elemente in JavaScript eingibt, um die Variable t zu verrechnen, dann gibt die Funktion f(t) auch [x,y,z] zurück. Ein Beispiel ist 32*Math.cos(t),15*Math.sin(t),t/2. Die Eingaben werden onchange mit transform2dAll(points3) konvertiert und mit draw2dAll(context, points2, scale) aus implement.js dann auf dem 2-D Canvas Context abgebildet. Das Intervall wird von start bis stop durchlaufen und zwar in times Schritten. Was man ausser dem Code für die drei Koordinaten ausserdem auch noch angeben kann. ausgabe_von_implement.html

Cheap 3-D: Full 3-D to 2-D ES6 function

root (Edward Gerhold)

Ausschnitt aus dem Dokument. Das ist die komplette Transformation der 3-D Punkte, ohne Umwege. Eine Demo hier. Die affinen Transformationen werden vorher und lokal auf den Punkten ausgeführt, wie bei normalen 3-D Programmen.

let rad = (deg) => Math.PI/180*deg;
let r_x = 1, r_y = 1, r_z = 1;
let phi_x = rad(220), phi_y = rad(330), phi_z = rad(90);
let xAxisCos = r_x*Math.cos(phi_x),
    yAxisCos = r_y*Math.cos(phi_y),
    zAxisCos = r_z*Math.cos(phi_z),
    xAxisSin = r_x*Math.sin(phi_x),
    yAxisSin = r_y*Math.sin(phi_y),
    zAxisSin = r_z*Math.sin(phi_z);
let transform2d = ([x,y,z]) => [
    x*xAxisCos+ y*yAxisCos+ z*zAxisCos,
    x*xAxisSin+ y*yAxisSin+ z*zAxisSin
];
let transform2dAll = (P) => P.map(transform2d);

let examplePoints = transform2dAll([[1,2,3], [3,4,5], [14,24,15]]);

Cheap 3-D logo und graph picture (draft)

root (Edward Gerhold)

cheap3dlogo Das Logo der Projektionsmatrix spiegelt das Prinzip wieder.

cheap3dgraph Das Bild zeigt das Koordinatensystem, die Winkel und die Einheitsvektoren, sowie cos-sin am Einheitsvektor. Ist nur viel zu klein und überarbeitungsbedürftig.

Arbeite bereits an dem offiziellen Paper dazu. Die aktuelle Version ist absolut noch nicht ausgereift.

Tagsüber lese ich gerade das Chemiebuch der Sekundarstufe I hier und lerne das, was ich damals nicht getan habe. In Mathematik und auch Physik bin ich bereits viel weiter und möchte mit aufschließen. Leider habe ich kein tragbares Gerät mehr, so daß ich unterwegs nichts elektronisch bearbeiten kann. Darum muss das über mehrere Tage entwickelt werden, anstatt über den Tag.

 

Cheap 3-D als Gerhold Matrix

root (Edward Gerhold)

Erste Spezifikation der Gerhold Projektionsmatrix oder der Gerhold Transformation

Seien x,y,z Koordinaten im R3 und x', y' die resultierenden Koordinaten im R2.

Seien ex, ey, ez die Basisvektoren des Zielkoordinatensystems. Da die Abbildung
auf dem R2 stattfindet, sprich auf der xy-Ebene, sind diese drei Vektoren auch
zweidimensional. Jeder Vektor enthät eine x und eine y Komponente, um die
Richtung der abgebildeten Koordinatenachse zu beschreiben.

ex = (rx*cos(alpha), rz*sin(alpha))T, 
ey = (ry*cos(beta), ry*sin(beta))T, 
ez = (rz*cos(gamma), rz*sin(gamma))T

r{x,y,z} sind die Einheitslängen der Zielbasis je Richtung. Man kann
das resultierende Bild damit vergrößern und verkleinern, da damit die
Einheiten je Koordinatenachse festgelegt werden. Um korrekte Bilder zu erhalten, sollten
sie gleichgross bleiben und man lokale Koordinatensysteme zur Transformation wählen.

Seien α, β und γ die Winkel der drei Einheitsvektoren am Einheitskreis.
Um die Vektoren entsprechend den Winkeln auszurichten, werden die Winkel mit dem
jeweiligen Cosinus und Sinus für die x und die y Komponente angegeben.

Wenn man die Koordinaten transformiert, summiert man die Cosinusterme für x und
die Sinusterme für y. Um es zu erlaeutern, bewege ich mich nach links und 
nach rechts mit dem Kosinusterm, jeweils für x, für y und für z. Dadurch bleibe
ich an der korrekten Stelle stehen, oder mathematisch, erhalte ich die richtige
Zahl. Mit dem Sinusterm bewege ich mich für x, y und z jeweils nach oben oder 
nach unten. Diese gedachte Bewegung erreiche ich durch Multiplikation mit dem
Vektor. Das mache ich jeweils für die x und für die y Komponente getrennt mit
dem Kosinus und dem Sinusterm, dadurch erhalte ich die korrekten Koordinaten
auf der Ebene.

Da es sich um eine Summe mehrerer Produkte handelt, kann man es auch als Matrix
schreiben. Was sich der übersicht halber bewährt. Programmieren kann man es
aber auch direkt ohne Matrix. Die Projektionsmatrix ist 2x3 und rechteckig.

Wir benutzen nur zweidimensionale Basisvektoren, weil das Drei-Koordinaten-System
x,y,z im R2 in einem Zwei-Koordinaten-System eingebettet ist. Wir haben die Option
uns in verschiedene Richtungen zu bewegen.

P = [ ex0, ey0, ez0;
      ex1, ey1, ez1 ]

P ist eine 2x3 Projektionsmatrix. Die 0 steht für die x-Komponente, und die 1
für die y-Komponente unserer neuen Koordinatenbasis. Um das aufzuschlüßeln,
was ich sage, hier die volle Basis in lesbarer Form.

P = [ rx0*Math.cos(α), ry0*Math.cos(β), rz0*Math.cos(γ);
      rx1*Math.sin(α), ry1*Math.sin(β), rz1*Math.sin(γ) ];

Hier steht der r fur den Radius des (dann nicht mehr) Einheitskreises, im Falle, daß man nur
cos und sin wählt, ist er 1. Wenn man keine irritierenden Verzerrungen bei Rotationen von zu
projezierenden Objekten wünscht, sollte man die in alle drei Richtungen gleich gross machen und
ein lokales (mitrotierendes) 3x3 Koordinatensystem für seine Objekte und ihre eigene Transformation
wählen. Die 2x3 Projektionsmatrix ist für die Umwandlung von dreidimensionalen in zweidimensionale
Koordinaten wichtig.

Mit dem Demoprogramm kann ich beweisen, daß die Projektion dann
trotz Rotation dann wirklich korrekt bleibt. Während man den irritierenden Effekt unterschiedlicher
Basiseinheiten, ohne daß diese Einheiten lokal am Objekt mit einem eigenen Koordinatensystem festgemacht
werden, hier beobachten kann, wenn man das Objekt dreht. Lokale 
Koordinatensysteme sind in der Computergrafik und der Physik aber keine Besonderheit, darum sollte das kein
Problem darstellen.

Wenn man die Matrix anwendet, führt man eine Multiplikation mit dem xyz-Koordinatenvektor durch und
erhält einen x'y'-Koordinatenvektor.

P[x;y;z] = [x';y']

Das kann man in einer Schleife mit allen Punkten machen und eine neue Liste zurückgeben. Die Punkte
sind in der gleichen Reihenfolge, wie die 3-D Koordinaten vorher waren. Für den HTML5 Canvas zum
Beispiel kann man nun einfache lineTo´s durchführen und erhält die Linien, die die vorher 
dreidimensionale Fläche verbunden haben.

Für den Programmierer ist keine Matrix nötig. Es sind diese zwei läppischen Zeilen.

x' = x*r*cos(alpha) + y*r*cos(beta) + z*r*cos(gamma);
y' = x*r*sin(alpha) + y*r*sin(beta) + z*r*sin(gamma);

Um die Identifikation mit drei 2-D Basisvektoren, die aus je einem r*cos-Term für die x-Koordinate
und einem r*sin-Term für die y-Koordinate bestehen, einfach zu halten, habe ich die Matrix gerholdsch
genannt. Die Gerhold-Matrix ist 2x3 und hält drei 2-D Vektoren mit je r*cos Achswinkel für den neuen x und
r*sin Achswinkel für den neuen y Wert. 

G = [ rx0*Math.cos(α), ry0*Math.cos(β), rz0*Math.cos(γ); rx1*Math.sin(α), ry1*Math.sin(β), rz1*Math.sin(γ) ];
Die Summationsformel ist nahezu identisch mit der Summationsformel für die Multiplikation mit einer Orthogonalbasis, Σ enxn. Jedoch wird sie in der Literatur nur mit quadratischen Matrizen und gleichgrossen Basis- wie Objektvektoren behandelt.
In der Computergrafik wird eine 4x4 Version mit Viewport Division eingesetzt. Ich habe eigentlich jahrelang nach dieser Formel
gesucht und sie zuletzt selbst erfunden. Warum ich die Matrix zur Unterscheidung mit meinem Namen identifiziere. G*[x;y;z] = [x';y'].

Cheap 3-D Transform

root (Edward Gerhold)

cheap3dtransform Habe Ursprung, Translation und Rotation hinzugefügt.

Nachtrag: Wenn die Einheiten von x,y,z unterschiedlich eingestellt sind, dann wird der Körper beim drehen plötzlich in die Richtung der Vergrösserung gestreckt und in die andere wieder geschrumpft. Das ergibt einen unrealistischen Effekt. Weiterhin ist noch zu ergänzen: Perspektive. Mit einer dynamischen Länge der Einheiten hätte man z- und y- entlang der x-Achse perspektivisch hingekriegt. Der Fall Rotation/Einheiten der Basis spricht erstmal dagegen. Möglicherweise muss die Basis Einheitslang bleiben und ich diese Einheiten getrennt auf das Objekt in lokalen Objektkoordinaten anwenden. Womit wir eine zweite Basis kriegen, die mit rotiert, damit die Proportionen bei der Drehung bleiben und einfach mitgedreht werden.  Desweiteren ist function trafo ein wenig zu überarbeiten, anstatt einen Parameter scale der aus der ersten Version stammt, ein Objekt mit Origin, Translation, Rotation, Punkten und wohl auch lokaler Basis zu nehmen. Naja, die Idee, die ich noch verfolge ist, auf ImageData umzusteigen, und einen einfachen line und fill Algorithmus für zu nutzen, wodurch man Licht und Farbinterpolation möglich macht. Wobei, ich möchte den Gedanken zuende führen, ich denke, daß es trotzdem schnell genug sein wird. fill ist dennoch auszuprobieren, weil ich das sowieso auch noch vorhatte.

Cheap 3d Projektion

root (Edward Gerhold)

cheap3dbase.html

Ich habe mir dann gerade, als ich noch was für unsere Kaninchen holen war,
auf dem Weg nochmal die Formel durch den Kopf gehen lassen. Die Transformation ist 
also eine nahezu perfekte Projektion. Nichts neues, aber wenn man gleich die 
Matrixschreibweise liest, vielleicht gar nicht so bekannt. Hier mal ein
paar Definitionen. Die Winkel hätte ich auch noch gruppieren können, aber
das ist jetzt Latte.

α := rad(65°)
β := rad(135°)
γ := rad(225°)
ex := { Math.cos(α), Math.sin(α) }
ey := { Math.cos(β), Math.sin(β) }
ez := { Math.cos(γ), Math.sin(γ) }
c := { x, y, z }
X := { ex[0], ey[0], ez[0] }
Y := { ex[1], ey[1], ez[1] }

Die Transformation von 3-D Punkten zu 2-D Punkten ist diese

x' := Σ cnXn
y' := Σ cnYn

Ich denke, wenn man zum Beispiel rotieren will, sollte man das vor der 
Trafo machen, warum ich selbige auch in Projektion umbenennen
würde, da sie nach den Aktionen mit den 3-D Koordinaten stattfindet.

Ich sollte nochmal bemerken, daß man, wenn man die Winkel der Achsen ändert,
und es enger wird, es wirklich enger wird. Das ist allerdings aber auch korrekt so.

In gegenwärtiger Matrixschreibweise als 2x3 Matrix mit den Basisvektoren
sieht das dann wie folgt aus.
Man bedenke, das Kosinus und Sinus ohne Multiplikation mit einer Amplitude
einen Radius von 1 haben.

P = [ Math.cos(α), Math.cos(β), Math.cos(γ);
      Math.sin(α), Math.sin(β), Math.sin(γ) ]

und die Eingabe Koordinate als 3x1 Matrix oder 3-D Vektor
v = [x;y;z]

Die ; stehen dabei für neue Zeile und die , für neue Spalte in den [] wie 
in gängiger Software.

Heraus kommt bei Pv oder 2x3*3x1 ein 2-D Vektor oder auch 2x1 Matrix
Pv = [x';y']

Kurzgefasst sieht das so aus.

	...

	x1 = x * ex[0] + y * ey[0] + z * ez[0];
	y1 = x * ex[1] + y * ey[1] + z * ez[1];
	
	...
    }
    return newPoints;
}

Und bewegen kann man sich so, wie man es von entsprechenden Abbildungen zum
Beispiel der ijk-Notation kennt. In Richtung des Vektors, mit Länge der Koordinatenkomponente
als Radius oder Verlängerung des Vektors. Reihenfolge egal, man kann erst z, dann x,
dann y gehen, oder in jeder anderen Reihenfolge. Das Ergebnis ist die selbe Summe.

cheap3dbase.html

Cheap 3D Professional

root (Edward Gerhold)

/* 
Multiplikation der Originalkoordinaten mit 2D-Vektoren, und Addition der x*cos(achswinkel) und x*sin(achswinkel) Komponenten zur neuen x' und y' Koordinate
*/

function trafo(points, scale) { var newPoints = []; var x,y,z; var x1, y1; var ex = [Math.cos(rad(65)), Math.sin(rad(65))]; var ey = [Math.cos(rad(135)), Math.sin(rad(135))]; var ez = [Math.cos(rad(225)), Math.sin(rad(225))]; for (var i = 0; i < points.length; i+=3) { x = points[i]; y = points[i+1]; z = points[i+2]; x1 = x * ex[0]; y1 = x * ex[1]; x1 += y * ey[0]; y1 += y * ey[1]; x1 += z * ez[0]; y1 += z * ez[1]; if (scale) { x1*=scale, y1*=scale; } newPoints.push(x1,y1); } return newPoints; }

Defekt

root (Edward Gerhold)

Nachdem vor einem halben Jahr mein refurbished Notebook nach bereits einem Jahr seinen Geist aufgab, beziehungsweise Gebrauchserscheinungen zeigte, daß er sich nach einmaligem Gebrauch für Stunden bis Tage abstellt, bevor er wieder betriebsbereit ist, hat jetzt mein alter Computer, der Pentium III aus einer Büroauflösung (Baujahr 2001) ebenfalls aufgegeben, zumindest ist die IDE Platte hinüber und das alte DVD Rom schon lange, daß ich es ohne fremde Hilfe mit einem Laufwerk und einem Rescue System nicht mehr umgehen kann. IDE DMA Read Error, alle zwei drei Sekunden. Unmöglich was zu starten, abzumontieren oder zu prüfen. So bin ich dann weiter mit meinem neuen Hobby Mathematik beschäftigt. Mittlerweile kenne ich die Lösungen von einigen partiellen Differentialgleichungen auswendig. Heute morgen habe ich Trigonometrie wiederholt, und musste bemerken, daß es hängen blieb, denn das auflösen der Identitäten bereitete mir keine Probleme. Im Gegenteil, ich war schneller als beim letzten mal. Aber auch in anderen Teilen der Mathematik mache ich rigorose Fortschritte und besonders Stolz bin ich auf meinen Einstieg in die Quantenmechanik. Mittlerweile kenne ich die Schrödingergleichung für verschiedene Anwendungsfälle und habe meinen Spaß damit. Da ich nun keinen funktionierenden Computer mehr habe, lasse ich das Programmieren aber erstmal was ruhen. Bei meinen Möglichkeiten vielleicht etwas länger ;-)

ES6 - destructuring, block scope, generators, modules, ...

root (Edward Gerhold)

Final Draft

This is the final draft of ECME-262 6th Edition, The 2015 ECMAScript Language Specification. This draft has been submitted to the Ecma General Assembly members for their review and consideration. The GA will vote on approving it as a Ecma standard at their June 2015 meeting.

Assuming GA approval, it will still be possible to make very minor editorial corrections in the published version. So, please continue to report any bugs or typos at bugs.ecmascript.org

April 14, 2015 Rev 38 Final Draft

doc
pdf, no change markup pdf with rev38 change markup
Changes marked as “Rev 38“. Change markup is relative to Release Candidate 4 (Rev37).

Changes include:

  • Tweaked completion value generation for iteration statements to enable loop unrolling.
  • Resolved bugs: 4279, 4274-4269, 4266-4258, 4256-4254, 4252-4248, 4133

Release Candidate Drafts

Development of the ECME-262 6h Edition, The 2015 ECMAScript Language Specification is complete. All that remains to find and fix and remaining editorial or technical bugs in the document.
Please report any bugs or typos at bugs.ecmascript.org

April 3, 2015 Rev 37 Release Candidate 4

doc, this is release candidate 4 with cumulative markup
pdf, no change markup pdf with rev37 change markup pdf with cumulative change markup
Changes marked as “Rev 37“. Change markup is cumulative starting with Release Candidate 1 (Rev34).

Changes include:

  • Various formatting tweaks and editorial and technical bug fixes.
  • Resolved bugs: 4247-4242, 4241-4240, 4238-4213, 4211-4202, 4200-4192, 4191-4185, 4183-4169, 4133

March 17, 2015 Rev 36 Release Candidate 3

doc, this is release candidate 3 with cumulative markup
pdf, no change markup pdf with rev36 change markup pdf with cumulative change markup
Changes marked as “Rev 36“. Change markup is cumulative starting with Release Candidate 1 (Rev34).

Changes include:

  • Several significant fixes relating to “completion reform”
  • Various formatting tweaks and minor editorial and technical bug fixes.
  • Resolved bugs: 4167-4166, 4163=4154, 4151=4148, 4145-4144, 4142, 4139-4125, 4123-4109, 4066, 3618, 3442, 1274, 522

March 4, 2015 Rev 35 Release Candidate 2

doc, this is release candidate 2 with rev35 change markup
pdf, no change markup pdf with rev35 change markup
Changes marked as “Rev 35“. Change markup is cumulative starting with Release Candidate 1 (Rev34).

Changes include:

  • Reverted back to no legacy RegExp.proptotype recognition in RegExp.prototype.exec and test
  • Eliminated buggy exotic [[Enumerate]] for String and Integer Indexed exotic objects. Tweaked ordinary [[Enumerate]] so it will work for them
  • Eliminate ambiguous optional tag on semicolon in do-while statement grammar. Added ASI rule to handle the case where that semicolon is missing.
  • Various formatting tweaks and minor editorial and technical bug fixes.
  • Resolved bugs: 4107-4104, 4101-4099, 4097-4096, 4094, 4091-4089, 4087-4084, 4082-4043, 4041-020, 4018-4013, 4000, 3993, 3989, 3979, 3965, 3865, 1223

February 20, 2015 Rev 34 Release Candidate 1

doc, this is release candidate 1 with with no change markup doc, this is release candidate 1 with cumulative markup
pdf, no change markup pdf with rev34 change markup pdf with cumulative change markup since rev22
Changes marked as “Rev 34“.

Changes include:

  • For legacy compatibility, Array.prototype goes back to being an Array exotic object (Array.isArray(Array.prototype) answers true).
  • For legacy compatibility, RegExp.prototype.exec.call/test.call act as if %RegExpPrototype% was still an RegExp instance
  • TypedArray slice, copyWith, set(TypedArray) do encoding preserving (memcopy) transfers when the source and target element types are the same.
  • The ‘next’ method of internally generated list iterator objects and the ‘revoke’ method of the object returned by Proxy.revocable are now non-enumerable, consistent with other built-in methods
  • Renamed Put() abstract operation to Set()
  • Eliminate the [lexical goal] grammar annotation. Instead clarified the explanation of lexical goals in clause 11
  • Eliminated Annexes D.2, D.3, E.2 that copying the ES5/51 Annex D/E into ES6. Too confusing because of section number mismatches. People should just look at Annex D/E of Es 5/5.1
  • Resolved bugs: 4012, 4010, 4005- 4002, 3999, 3995-3992, 3990-3985, 3983-3935, 3933- 3931, 3929-3902, 3900-3880, 3878-3861, 3859-3858, 3856-3846, 3791, 3759, 3753, 3751-3746, 3724, 3694, 3596, 3504, 3490, 3294, 3279, 3138-3137, 3114, 3074, 2916, 2401, 2215, 1801, 1782, 1778, 1770, 1522-1521, 1075, 1059, 635, 172, 116