Rework me on GitHub

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.

Animation

root (Edward Gerhold)

Hier in diesem Demo kann man eine schöne trigonometrische Funktion bei der Drehung beobachten

Konvex heisst auch lx+(1-l)y

root (Edward Gerhold)

Gerade kehre ich aus dem Wohnzimmer zurück. So sind ein paar Minuten seit dem letzten Post vergangen. Ich habe auch mal ausprobiert, was bei lx+(1-l)y rauskommt, sofern l &element [0,1] ist, und x und y je 2-D Vektoren. Wenn man zum Beispiel einen 2-D Vektor v zeichnet, also einen Pfeil in einem xy-Koordinatensystem, vom Ursprung bis zum Punkt v=(x,y), also den Ortsvektor, dann liegt für jedes l zwischen [0,1] mit 0 und 1 inklusive genau auf dem Vektor x+y. Konvexität bedeutet, dass die Menge die Punkte und ihre Verbindungsstrecke enthält. Hihi, ich habe den Fall ausprobiert, wo wir auf einer Linie bleiben. In der Norm heisst das ||lx+(1-l)y|| <= l||x||+(1-l)||y||, was ich in einem Wikipedia Artikel gelesen habe. Das war zwischen meiner Unterlage zur konvexen Analysis mit abgeheftet. Dort ist diese Formel natürlich zentral. Ich sage mal, ich habe das noch nicht verstanden, was in der Vorlesung geschieht. Aber interessant ist es allemal. In einer Unterlage über Funktionalanalysis gibt es einen Artikel über S.Banach. In dem Artikel wird ein Eintrag aus dem schottischen Buch zitiert, was er mit seiner Lemberger Schule in einer Kneipe (Details vergessen) anstatt auf dem Tisch in das Buch schrieb. Darauf war ein Preis aufgeschrieben. Sei die unendliche Reihe xi = y0. Durch Neuordnung erhält man y1 Beweise für alle Elemente im Raum des Typs (B), dass die Summe ly0+(1-l)y1 gilt. Mit Bleistift versuche ich da was rauszukriegen, aber ausser ein paar Umformungen, war da nichts. Ich habe nach y0 und y1 aufgelöst und mir was zu gedacht. Allerdings, wie man liest, weiss ich die Lösung immernoch nicht. Der Wikipedia Artikel brachte mir aber klar nahe, dass der Preis einer Flasche Wein, die damals dann bestimmt auch gewonnen wurde, heute eine gewöhnliche und wichtige Aufgabe darstellt, die es zu lösen gilt. Für mich auch. Mir fehlen die Worte, was die Formel jetzt ausdrückt, worauf mir die Wikipedia eben vorgestelltes Experiment vom Beginn nochmal einleuchtend nahebringt (ich habe während dieses Satzes die Unterlage vom Schreibtisch geholt). http://de.wikipedia.org/wiki/Norm sagt es auf deutsch "Zudem ist die Norm aufgrund der Subadditivität" (Dreiecksungleichung)  "und absoluten Homogenität" (Norm nur 0 wenn der Vektor 0 ist) "eine sublineare und konvexe Abbildung, das heißt, für alle t &element; [0,1] gilt ||tx+(1-t)y|| <= t||x||+(1-t)||y||. " Finde ich unheimlich gut. Nur sind wir jetzt wieder dort, wo wir einige Sekunden vorher waren. Also ich habe das auf der Linie abgebildet. Und ich stelle mir den Füllalgorithmus für konvexe Flächen in der Abbildung auf dem R2 schon seit ich die Transformationsformel herausgefunden habe vor, weil ich denke, dass innerhalb des Gitternetzes innerhalb eines Vierecks (sollte trianguliert werden) alle Punkte durch die Konvexitätsformel erreicht werden können. Das die Verbindungsstrecke in konvexen Mengen innerhalb der Menge liegt und zu den Punkten gehört, im Satz andersrum gesagt, schnappte ich davor schon auf. Ok, ich werde gerufen und habe den Satz noch schnell zuende getippt.

Update: Die Formel lx+(1-l)y gibt auch die Linie von x-y (zwischen x und y) wieder, wenn wir auf drei oder mehrere Dimensionen erweitern. Für mich galt dann weiter die fast schon rhetorische Frage, was sei, wenn man x mit Ax und y mit Ay ersetzt. Sprich, ich habe eingesetzt und umgeformt und das gleiche Ergebnis erhalten.

Update vom Update: Da hat sich sogar ein Fehler eingeschlichen, als ich das ausprobierte. Irgendwie hatte ich es zumindest in Erinnerung, die Line auf x+y zu haben und das zuerst geschrieben. Fakt ist, die Punkte liegen sowohl in zwei als auch in drei Dimensionen exakt auf der Verbindungslinie zwischen den zwei Punkten. Erfreuliches gibt es auch, inzwischen habe ich den Trennungssatz für konvexe Mengen neu verstanden.

 

 

 

Als Function geht auch

root (Edward Gerhold)

Heute fiel mir dann ein, wie ich das als Funktionen ausdrücke. Als f(x) oder auch als f(g(x)), wobei verschiedene Eingabe und Ausgabewerte übergeben und angenommen werden können. Das gesamte Dokument habe ich mir vorhin unterwegs durchgelesen, da ich mir Papier zum Drucken besorgt habe. Dabei habe ich allerhand Fehler entdeckt und mir ist auch eingefallen, wie man die Kapitel besser ordnen kann. Aber das ist nicht alles. Wie lange ich dafür jetzt brauche, weiss ich nicht. Aber ich werde gleich weiter arbeiten. Inzwischen lasse ich den alten Drucker, den ich seit meiner letzten Wohnung mit Bus und Bahn von Wohnheim zu Wohnheim gefahren habe, mit gutem Grund, wie ich heute weiss, warmlaufen, da ich mir einige englische Unterlagen drucke. Nach Topology habe ich heute Functional Analysis gedruckt. Dazu ist mir der Beweis der Cauchyfolge über den R2x3 und damit der der Vollständigkeit eingefallen. Alles für drei Koordinatenachsen, die ich überdeutlich als Basis ausgab, aber viel zu leise als Koordinatenachsen. Letztere Vorstellung befreit von strengen mathematischen Beweisen. Wo mir bei der Erzeugung der richtigen R2x3 Basis auch eine kompliziertere Aufgabe einfiel, da die 2PI Periodische Funktion auch Nullstellen hat. Der Hit ist wohl der Modulus, wobei ich dann an Zahlentheorie und Algebra denke, und daran, daß ich hier wohl noch üben sollte, mir also auch nicht zu viel vornehmen sollte. Der Artikel muss ja frei von solchen Sachen sein, die ich nicht zuende bringe. In den nächsten Versionen...So long. Und viel Spass beim Transformieren der Punkte.

R^3->R^2x3->R^2

root (Edward Gerhold)

Aah, ich glaube, heute ist der Groschen gefallen, wie ich es am besten ausdrücke. Die Basis ist für den R2 keine Basis, sondern eine reine Linearkombination und die Matrix ist eh nicht Mitglied im R^2. Eine Spalte ist zuviel. Für eine R^3 Basis fehlt eine ganze Reihe. Ausgedrückt habe ich das Ding zu Beginn schon als A &element; ℜ2x3 : ℜ3  → ℜ2. Und da liegt die Lösung. Ich male einfach den ℜ2x3 zwischen die beiden, als direkten Pfad von V nach W.  Das gleiche ist durch die Zuordnung von A ja bereits ausgedrückt. Allerdings hatte ich dann im weiteren Verlauf im Text entschieden, das Ding erstmal als R^2 Pseudobasis auszugeben. Jetzt kann ich das korrigieren. Mehr zu tun noch, habe ich mit der korrekten topologischen Begriffsbildung, da es ja zu Überdeckungen oder Überlagerung von Punkten aus dem R^3 kommt, die auf den gleichen Punkt im R^2 abgebildet werden. Da man die Ebene durch sechs Teilen kann, es aber Schnittmengen dazwischen gibt, und weil mir die Praxis fehlt, hausdorffsche Räume mit ihren Einheitskugeln bei Überlagerungen korrekt auszudrücken.

Im R^2x3 hat die Matrix übrigens eine Basis. Sie besteht aus sechs Matrizen, die jeweils eine 1 enthalten. Für jedes Feld ist eine Matrix mit einer einzigen 1 anzusetzen. Damit ist das Problem mit der Pseudobasis erledigt, und es war vor Einführung des Begriffes korrekter. Werde mich korrigieren und bin weiter stolz auf mich, mich weiter für Mathematik zu interessieren.

alternative

root (Edward Gerhold)

Wenn man v = (x,y,z) setzt und c = (r cos phix, r cos phiy, r cos phiz) und s = (r sin phix, r sin phiy, r sin phiz). Dann kann man w=(x',y') mit (dot(v,c),dot(v,s))  berechnen. Die Operation ist die selbe, wie die Multiplikation mit der 2x3 (pseudo) basis. Fiel mir vorhin unterwegs ein, daß ich es direkt eingefügt habe.

Topology

root (Edward Gerhold)

Gerade habe ich mir Topology auf Englisch gedruckt, damit ich einige Sätze, die ich aus der deutschen Topologie kenne, auch auf english lesen kann. Inzwischen bin ich mit meiner Abbildung A:V->W etwas weiter gekommen, nachdem ich mich die letzten zwei Wochen immer mal ein paar Minuten oder Stündchen mit dem Einstieg in LaTeX befasst habe, beziehungsweise andere Teile meiner Projektionsformel erforscht habe. Nach einer längeren Zeit des Nachdenkens ist mir jetzt klar, daß es 3-D Punkte gibt, die auf einen und denselben 2-D Punkt abgebildet werden. Was ja eigentlich klar ist, aber im beschreibenden Zusammenhang ist das eine sehr wichtige Beobachtung. Da drängte sich mir die Frage auf, ist der Raum jetzt kompakt? Ist das die kompakte Menge aus der Topology und der Funktionalanalysis, die mindestens eine endliche Teilüberdeckung enthält? Was ist mit den Vektorräumen V und W als Teilmengen des R^3 und des R^2? Das sind doch schöne Formen, um das zu beschreiben, oder? Genau das bedeutet für mich, das Dokument jetzt mindestens von vorne anzufangen. Wobei ich das Lemma der Orthogonalbasis in der bisherigen Reihenfolge ändern werde, die Remarks über r_n in einen Abschnitt über r_n neu verfasse, die unnötigen Remarks und Fußnoten lösche und mich bis zu Theorem durcharbeite, welches ich dann mit den Mengen V und W und einigen weiteren Begriffen und Symbolen der Mathematik präsentieren werde. Zum Beispiel ist V = Vereinigung aller verwendeten (x,y,z) aus dem R^3 und W = die Vereinigung alle mit A(x,y,z) transformierten Punkte (x,y) aus dem R^2. Ein (x,y) kann also eine Vereinigung mehrerer (x,y,z) sein. (...)

Update: kompakt ist abgeschloßen und beschränkt. Allerdings könnte W ⊂ ℜ2, welcher alle Punkte, die w=Av, v ∈  ℜ3 sind, beinhaltet, das durchaus sein. Wir werden sehen. Überdeckung heisst wohl cover, offen heisst offen. Closure ist wohl der Abschluß. A metric space ist der metrische Raum aller stetigen Abbildungen von zum Beispiel V nach W. Wenn etwas auf Deutsch hausdorffsch ist, ist es auf englisch Hausdorff. Fun, fun, fun.

[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]]);

Das technische Dokument

root (Edward Gerhold)

gerhold-3dto2d.pdf ist der erste Entwurf der Dokumentation der Projektionsmatrix. Das Dokument ist in noch etwas brüchigem Englisch verfasst, beinhaltet aber explizit die Projektionsformel. Der alternative Graphikalgorithmus, der sich in cheap3dperspective.html entwickelt, ist vielleicht geeignet für ein neues. Aber noch ist der nicht fertig. Es fehlt noch das Interpolieren der Flächen zwischen den Punkten, was danach auch Licht ermöglicht, bevor er quasi komplett ist.

Cheap 3D Perspective nur nah

root (Edward Gerhold)

Ich habe das Program ein wenig weiter bearbeitet und cheap3dperspective kam raus. Es ist ein besonderes Zwischenprodukt. Seht selbst.

LaTeX{} lernen und Englisch

root (Edward Gerhold)

Um das Dokument schreiben zu können, bedarf es einer Hirnwäsche. Im nüchternen Sinne. Ein wenig englische Vokabel muß ich ebenso nachschlagen, wie fasziniert vom Setzen mit LaTeX eben selbiges zu lernen. Es gibt zum Setzen der Sätze extra Befehle, wie zum Durchnummerieren, für Fußnoten, wohin ich den Gerholdian Projection Operator, oder die Gerhold Projektionsmatrix verbannen kann, um den Text rein zu halten, für Literaturverzeichnisse. Es gibt tolle Befehle um Seitenköpfe zu gestalten. Der Titel, den ich so hingeschrieben habe, der hat seine eigenen Symbole. Das werde ich dann erstmal eine Weile machen.

Nebenbei muss ich das Demo erweitern. Anstelle des Verbindens der 2-D Punkte, was cheap3danimate macht, sollte ich alle Kurven sammeln und die 3-D Kurven nutzen, um bei gleichem Index beim Zeichnen der 2-D Kurven Werte zu ermitteln. Allerdings muss ich beim Zeichnen der 2-D Kurven nicht mehr eine Ablaufen, sondern mindestens 2, am besten 4, 2 auf x und 2 auf y Richtung, um genau dazwischen die _konvexe Menge_ zu interpolieren oder zu füllen. Hier reicht mit dem 2-D Canvas ein Path zwischen den Punkten und der Fill funktioniert (geht er in eier Version mit einzelnen Kurven nicht korrekt) wie geplant. Nebenher lässt sich noch eine feinere Unterteilung der konvexen Menge zwischen den Punkten anstreben, dann kann man auch mit den 2dContext Funktionen genau füllen, statt wie nur mit ImageData.data.

"Abbildungsmatrix" endlich gefunden

root (Edward Gerhold)

War natürlich genau so wenig schwer zu finden, wie natürlich erwartet. Daß der Fall gar unbekannt sei, kam mir gar nicht in den Sinn. Ich habe jetzt einige weitere Tage nach der Matrix gesucht. Oder nach was vergleichbaren, um herauszufinden, ob sie denn existiert. Den generellen Fall kann man in der Literatur, wie auch in der Wikipedia mit der Abbildungsmatrix entdecken. Aaaber. Nicht nur, daß ich jetzt nochmal nach den richtigen Sätzen in meinen Unterlagen suchen kann, und das nochmal verknüpfen. Ich kenne meine Matrix dennoch nicht aus der Literatur. .Ich habe sie und ihren Inhalt und auch die Hintergründe dazu ja wirklich selbst entwickelt. Und von meinen speziellen Einheitsvektoren wie auf dem Bild und ihre Herleitung vom Einheitskreis wird auch nichts erwähnt. Mittlerweile gehört da auch ein ganzer Satz von alternativem Graphikalgorithmus zu. Ich bin zufrieden und setze das so fort und werde das auch zuende schreiben. Wenn jemand nach der Gerholdmatrix fragt, dann sind da drei trigonometrische Orthonormalvektoren ∈ ℜ2 drin, möglicherweise mit einer größeren Einheit multipliziert. Und der entsprechende Code ist genau zwei Zeilen lang, und vom Gerhold selbst in etlichen Jahren nicht gefunden worden. Daß er die richtige mathematische Matrix dazu gefunden hat, heisst noch gar nichts. Hehe, Er hat sie ja selbst entwickelt. Die Transformationen der Objekte müssen davor durchgeführt werden. Da gab es dann ein paar gute Bemerkungen zu, daß ich mir die fünf Seiten sogar ausgedruckt und mal ganz durchgelesen habe, hehe. Gottseidank habe ich den generellen Fall entdeckt. Macht es mir leichter meinen längst abgeleiteten in den zu überführen.

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 Rotation Animation

root (Edward Gerhold)

cheap3danimate Das ging sehr schnell. Ein Zähler wird zur Rotation addiert. Die komplette Funktion, wird jedesmal neu gerufen. "Das ermöglicht vorab Auslastungsstichproben", wollte ich noch hinzufügen. Und muss mich dabei korrigieren, weil ja der gesamte Handler per setTimeout wiederholt wird, und dabei das DOM ja ebenfalls jedesmal neu gelesen wird, wodurch das Ding zwar live auf Änderungen reagiert, aber fernab vom realistischen Auslastungstest ist, wo der Zugriff auf jeden Fall vorher rausgeflogen ist. Viel Vergnügen.

Update: Persönliche Meinung. Erst optimieren. Wenn man jetzt viel ändert, wird der Handler ständig zwischengerufen. Dabei geht mindestens der Lüfter irgendwann an.

Cheap 3D als TeX Dokument

root (Edward Gerhold)

cheap3drotate.html ist die letzte Datei von gestern. Heute habe ich mir dann überlegt, es auch richtig als TeX Datei aufzusetzen.

Der Korollar beweist die Erweiterbarkeit des Satzes auf mehr als drei Dimensionen, zum Beispiel Minkowski 4-D, und auch Hilberträume. Die Transformation zu niederen Dimensionen lässt sich mit rechteckigen Matrizen verallgemeinern.

Die besondere Änderung an der Matrix ist, daß ich anstelle von α, β, γ nun φx, φy, φz für die Winkel eingetragen habe. Das macht es noch einheitlicher.

α, β, γ erinnern viele direkt an die Winkel von Dreiecken. Letztendlich laufen wir hier die Wege der Ankatheten und Gegenkatheten auf dem Papier ab. Oder an charakteristische DGL vom Euler.

In der Mathematik variieren die Buchstaben in den Schriften und von Person zu Person, darum ist es eigentlich auch nicht wichtig, ob es jetzt φx oder α ist. Allerdings liest es sich so auch sehr gut.

A = [ rxcos(α), rycos(β), rzcos(γ); rxsin(α), rysin(β), rzsin(γ)]
= [ rxcos(φx), rycos(φy), rzcos(φz); rxsin(φx), rysin(φy), rzsin(φz)]
= [ ex, ey, ez ];

Seien A  ∈ ℜ2x3 ein linearer Operator, x ∈ ℜ3 der Eingabevektor und x' ∈ ℜ2 der Ausgabevektor, en ∈ ℜ2 hier ein zweidimensionaler Basisvektor für je eine xyz-Komponente von x für die Projektion auf die xy-Ebene (den ℜ2). Und rn sei die Längeneinheit des jeweiligen Basisvektors en.

Man wendet die Basis wie eine gleichgrosse Basis auf den Koordinatenvektor an.

Damit ist

x' = Σ enxn

oder

(x',y')T = A(x,y,z)T

oder in Worten

x`= Die Summe aus den Produkten von x,y,z mit ihren cos Termen
y' = Die Summe aus den Produkten von x,y,z mit ihren sin Termen
oder der neue Vektor die Summen aus den Produkten der Basis und dem alten Vektor.

Immernoch zu erledigen ist für mich, ein Bild von einem dreidimensionalen Koordinatensystem anzufertigen, auf dem drei Einheitsvektoren auf ihren Achsen in ihre Richtung schauen. Übrigens auch das Logo des Programms. Ein Einheitskreis mit drei Pfeilen drin. Auf dem Blatt Papier hat man das Lineal parallel zur Achse angelegt, und ist zu Fuß gegangen, oder halt mit den Koordinaten multipliziert. Letzteres machen wir nun praktisch mit der Rechenmaschine, und mit mehr Punkten als wir manuell berechnen würden.

Cheap 3-D Local Rotate

root (Edward Gerhold)

cheap3drotate.html Habe den trafo Code wieder vom DOM Code getrennt. Jetzt könnte man jedes x-beliebige Objekt unterschiedlich darstellen. Die Darstellung des aktuellen Graphen wirkt aber bereits verbessert, da die Achse nicht mehr mitrotiert und nicht übersetzt wird, nur weil ich die Daten nicht mit übergeben habe. Das ist aber noch nicht das Ende der Entwicklung. Natürlich geht das noch weiter...

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 Local units

root (Edward Gerhold)

cheap3dlocalunits.html Um die Rotation zu bewahren, aber vielleicht x und y 20 mal so gross zu machen, und z nur 4 mal so gross, muss das lokale Koordinatensystem her. Dieser Edit beschränkt sich auf die Einheiten, statt auf eine Vektorbasis, die eine weitere Verformung des Objekts ermöglicht. Möglicherweise der nächste Edit handhabt das so, dass man den Satz mit Ursprung, Translation, Rotationswinkeln, lokalen Einheiten je Objekt mit übergibt. Dieser hier bewahrt die größe bei der Rotation, obwohl sie veränderlich ist. Dazu habe ich die Projektionsvektoren wieder auf eine gleichgrosse Länge verkürzt.

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 3-D Interval

root (Edward Gerhold)

cheap3dinterval.html Es sieht besser aus, beide Enden des Intervals bestimmen zu können. Ich habe die Achsen neu gedreht und ausserdem die Einheitslänge der Basis auf 10 festgesetzt.

Cheap 3D Stretch

root (Edward Gerhold)

cheap3dstretch.html Hiermit kann man die Länge der Basisvektoren einstellen.Sie verlängern das Bild in beide Richtung. Womit das nächste Vorhaben schnell klar wird. Eine Perspektive wird in eine Richtung grösser, in die andere kleiner. Hierbei sollte man wie auf Blatt Papier in die x-Achse, die in den Raum zeigt, verkleinern und zum Betrachter vergrössern.

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 Pro Demo

root (Edward Gerhold)

Das Dokument ist ein kurzer Hack in das alte Dokument rein. Um die Transformation zu demonstrieren, habe ich Eingabefelder für die Winkel der Achsen und eine Skalierung der Oberfläche mit dem click Ereignis vom Button verbunden.

cheap3dbase.html

Der einfache Code für die Transformation steht einen Beitrag tiefer. Es ist eine Ableitung aus der Mathematik, von Σ en*xn, oder wie man die Multiplikation mit einem Satz Basisvektoren beschreibt. Der Trick ist, dass ich zweidimensionale Basisvektoren nehme, die in die Richtung zeigen, wo ich auf dem Bildschirm lang will. Damit ich keine Zahlen ausdenken muss, wie [1.5, 0.7] (zeigt nach rechts und etwas wenig weit nach oben), habe ich einfach xn * Math.cos(angle<sub>n</sub>) für x multipliziert und xn * Math.sin(angle<sub>n</sub>) für y, den jeweiligen x oder y Teil nach der Multiplikation von der Koordinatenkomponente und dem Basisvektor en zu der resultierenden x' oder y' Koordinate addiert. Ich hatte nach der letzten Version die Vermutung es mal mit der Orthonormalbasis zu probieren. Diese hier ist weder orthonormal, noch orthogonal, aber eine (Normal)Basis. Und zwar eine dreidimensionale Basis für eine zweidimensionale Ebene. Einfacher habe ich mir das noch nie gemacht. Verglichen mit WebGL, OpenGL, und genereller Computergrafik. Wenn man jetzt anstatt Canvas.lineTo ein ImageData Objekt benutzt, kann man sowas wie einen z-Buffer und Farbinterpolation, oder auch Licht, probieren, und vielleicht noch mehr als genug Code sparen. Für einfache Visualisierungen scheint das hier jedenfalls schon zu reichen. Das fill vom Canvas müsste eigentlich sogar noch funktionieren.

Ich freu mich über das Resultat und wünsche euch auch viel Vergnügen.

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 ;-)

cheap 3d Korrektur

root (Edward Gerhold)

// Die xy-Ebene per Z-Rotation um 225 Grad drehen, d.h. z-Angle = rad(225), dann die z-Koordinate zur y-Koordinate zählen.


function trafo(points, scale) { var newPoints = []; var x,y,z, x_1,y_1,x_2,y_2,x_3,y_3; for (var i = 0; i < points.length; i+=3) { x = points[i]; y = points[i+1]; z = points[i+2]; x_1 = Math.cos(zAngle)*x -Math.sin(zAngle)*y; y_1 = Math.sin(zAngle)*x +Math.cos(zAngle)*y; if (scale) { x_1*=scale, y_1*=scale; } y_1 += z; newPoints.push(x_1,y_1); } return newPoints; }

Cheap 3-D

root (Edward Gerhold)

Es muss nicht immer gleich eine ganze Grafik-Pipeline sein, nur, um eine Schraublinie zu ziehen. Man dreht das xy-System nach unten und addiert den z-Wert zur Vertikalen. Die Projektion ist damit natürlich orthogonal. Ein perspektivisches Verhältnis müsste in einer weiteren Zeile vor dem addieren des z-Werts ausgerechnet werden.

.

 

Die folgende Funktion trafo wandelt die 3-D Punkte (x,y,z) in 2-D Punkte (x,y) um. Die draw Funktion zeigt, wie man mit lineTo Punkt für Punkt verbindet.

/*
Die zentrale Funktion trafo: 3-D nach 2-D Transformation in sieben Zeilen.
*/
function trafo(points, scale) {
var newPoints = [];
var x,y,z, x_1,y_1,x_2,y_2,x_3,y_3;
for (var i = 0; i < points.length; i+=3) {
x = points[i];
y = points[i+1];
z = points[i+2];
x_1 = Math.cos(xAngle)*x -Math.sin(xAngle)*y;
y_1 = Math.sin(xAngle)*x +Math.cos(xAngle)*y;
x_2 = Math.cos(yAngle)*x_1 -Math.sin(yAngle)*y_1; // fragen: vielleicht noch tauschen von (x_1,y_1) nach (-y_1,x_1)
y_2 = Math.sin(yAngle)*x_1 +Math.cos(yAngle)*y_1; // und danach zurück. Hab ich wie das 90° tauschen von sin und cos nicht ausprobiert.
y_2 += z;
x_3 = Math.cos(zAngle)*x_2 -Math.sin(zAngle)*y_2;
y_3 = Math.sin(zAngle)*x_2 +Math.cos(zAngle)*y_2;
newPoints.push(x_3,y_3);
}
return newPoints;
}

/*
Die draw Funktion nimmt einen Array x, y nebeneinander und vebindet alle Punkte mit einem lineTo
*/

function draw(points, op) {
op = op || {};
var newPoints;
var scale = 2;
newPoints = trafo(points, op.scale);
context.save();
context.beginPath();
context.moveTo(-x,-y);
if (op) {
if (op.scale) scale = op.scale;
if (op.color) context.strokeStyle = op.color;
if (op.fill) context.fillStyle = op.fill;
if (op.line) context.lineWidth = op.line;
if (op.compo) context.globalAlphaComposition = op.compo;
if (op.alpha) context.globalAlpha = op.alpha;
}
var i = 0;
var x = newPoints[i],
y= newPoints[i+1];
var y_1,x_1;
// Verbinden vom ersten bis zum letzten Punkt ist die Aufgabe
for (var i = 0; i < newPoints.length; i+=2) {
x = newPoints[i];
y = newPoints[i+1];
context.lineTo(-x,-y);
}
if (op.fill) context.fill();
if (op.color) context.stroke();
context.closePath();
context.restore();
}

Beim überlegen, ob das mit den Winkeln für die Achse stimmt, ist das Ausprobieren noch nicht beendet. Es gibt die Möglichkeit im zweiten Schritt x und y erstmal zu tauschen, und nach der Transformation wieder zurück zu tauschen und dann den z-Wert hinzuzuzählen.

Um den Einstieg leichter zu machen, hier noch was Sample Code, um Achsen zu zeichnen, und surfaces mit f(x,y) zu plotten. Bei letzteren sollte man darauf achten, sich im kleinen Intervall zu bewegen, wie [-1,1] und dann ordentlich zu skalieren. Wenn man Oberflächen plottet, zieht man ein paar Kurven von x0 bis xn und ein paar von y0 bis yn und hält die andere Koordinate y, bzw. x konstant. 

cheap3d.html zum selbst editieren


var xAngle = rad(135);
var yAngle = rad(225);
var zAngle = rad(1);

function rad(dg) {
return Math.PI/180*dg;
}

function f(x,y) { // Parabel auf der x-y Ebene nach +z geöffnet. Mit (0,0,0) als tiefsten Punkt
return (x*x+y*y);
}

function axes() {
var X=[];
for (var x = -50; x < 200; x+=10) X.push(x,0,0);
var Y=[];
for (var y = -50; y < 200; y+=10) Y.push(0,y,0);
var Z=[];
for (var z = -50; z < 200; z+=10) Z.push(0,0,z);
draw(X, {
color: "red"
});
draw(Y, {
color: "yellow"
});
draw(Z, {
color: "green"
});
}
function plot(op) {
var domRangX = op.X;
var domRangY = op.Y;
var u = op.f;
var XP, YP;
var x = domRangX[0];
var x_1 = domRangX[1];
var delta_x = op.dX || 1;
var y = domRangY[0];
var y_1 = domRangY[1];
var delta_y = op.dY || 1;
// paint the curves in y direction with x fixed
for (y=domRangY[0];y<=y_1;y+=delta_y) {
XP = [];
for (x=domRangX[0];x<=x_1;x+=delta_x) {
var z = u(x,y);
XP.push(x,y,z);
}
draw(XP, {
color: op.xcolor,
scale: op.scale,
line:0.1
});
}
// paint the curves in y direction, with x fixed
for (x=domRangX[0];x<=x_1;x+=delta_x) {
YP = [];
for (y=domRangY[0];y<=y_1;y+=delta_y) {
var z = u(x,y);
YP.push(x,y,z);
}
draw(YP, {
color: op.ycolor,
scale: op.scale,
line: 0.1
});
}
}

function surfaces(scale) {
plot({
f: f,
X: [-8,8], // Das x-Intervall. Um den Plot sehen zu können, muss skaliert werden.
dX: 0.1, // x-Abstand der Linien
Y: [-8,8], // Macht man das Intervall grösser, schiessen die z-Werte in die Höhe
dY: 0.1, // y-Abstand der Linien
scale: scale || 1,

xcolor: "darkgrey",
ycolor: "lightgrey"
});
}

function translate(points, vector) {
var new_points = [];
var w;
for (var i = 0; i < points.length;i+=3) {
if (w=vector[0]) new_points[i]=points[i]+w;
if (w=vector[1]) new_points[i+1]=points[i+1]+w;
if (w=vector[2]) new_points[i+2]=points[i+2]+w;
}
return new_points;
}


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

Quanten

root (Edward Gerhold)

Gestern und vorgestern habe ich meine ersten Aufgaben der Quantenmechanik gelöst.

 Insbesondere die Schrödingergleichung, die Wellenfunktion, rechnen mit ket- und bra und relativen Wahrscheinlichkeiten sowie Systemzuständen,. erzeugen von Hamilton-Operatoren und Matrixmultiplikation, einsetzen von anderen Operatoren, wie Zustand erhöhen oder erniedrigen. Alles in allem ein Sprung ins kalte Wasser und eine Denknuss nach der anderen. Aber es ist machbar.

Natürlich setze ich das fort, wo ich mich bereits für ein an die Mathematik anschliessendes Selbststudium von Physik, Chemie und auch Wirtschaft entschieden habe.

Hehe, ich hab noch mehr Aufgaben :)

Kopfrechner

root (Edward Gerhold)

Mittlerweile habe ich einige numerische Verfahren handschriftlich ausgerechnet.

Und auch Integraltransformationen habe ich mir beigebracht.

Gerade übe ich Differentialgleichungen ausrechnen. Natürlich ohne Taschenrechner. 

Jetzt sind die Übungsblätter der letzte Hit. 

Lücken stopfen

root (Edward Gerhold)

Heute frisch aus dem Drucker:

Lineare Integralgleichungen

Variationsrechung

Ich habe hier noch Nachholbedarf.

Muss erstmal gucken, ob die PSB auf hat, damit ich lochen und einen Heftstreifen reinstecken kann.

Werde natürlich primär mit der Numerik weitermachen. Ich hatte das geschrieben, weil es Zeit ist, damit fertig zu werden.